preferences.h

Go to the documentation of this file.

/*
 Copyright (C) 1999-2006 Id Software, Inc. and contributors.
 For a list of contributors, see the accompanying CONTRIBUTORS file.

 This file is part of GtkRadiant.

 GtkRadiant is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 GtkRadiant is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with GtkRadiant; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#if !defined(INCLUDED_PREFERENCES_H)
#define INCLUDED_PREFERENCES_H

#include <libxml/parser.h>
#include "../dialog.h"
#include <list>
#include <map>

void Widget_connectToggleDependency (GtkWidget* self, GtkWidget* toggleButton);

class PreferencesPage
{
        Dialog& m_dialog;
        GtkWidget* m_vbox;
    public:
        PreferencesPage (Dialog& dialog, GtkWidget* vbox) :
            m_dialog(dialog), m_vbox(vbox)
        {
        }
        GtkWidget* appendCheckBox (const char* name, const char* flag, bool& data)
        {
            return m_dialog.addCheckBox(m_vbox, name, flag, data);
        }
        GtkWidget* appendCheckBox (const char* name, const char* flag, const BoolImportCallback& importCallback,
                const BoolExportCallback& exportCallback)
        {
            return m_dialog.addCheckBox(m_vbox, name, flag, importCallback, exportCallback);
        }
        void appendCombo (const char* name, StringArrayRange values, const IntImportCallback& importCallback,
                const IntExportCallback& exportCallback)
        {
            m_dialog.addCombo(m_vbox, name, values, importCallback, exportCallback);
        }
        void appendCombo (const char* name, int& data, StringArrayRange values)
        {
            m_dialog.addCombo(m_vbox, name, data, values);
        }
        void appendSlider (const char* name, int& data, gboolean draw_value, const char* low, const char* high,
                double value, double lower, double upper, double step_increment, double page_increment,
                double page_size)
        {
            m_dialog.addSlider(m_vbox, name, data, draw_value, low, high, value, lower, upper, step_increment,
                    page_increment, page_size);
        }
        void appendRadio (const char* name, StringArrayRange names, const IntImportCallback& importCallback,
                const IntExportCallback& exportCallback)
        {
            m_dialog.addRadio(m_vbox, name, names, importCallback, exportCallback);
        }
        void appendRadio (const char* name, int& data, StringArrayRange names)
        {
            m_dialog.addRadio(m_vbox, name, data, names);
        }
        void appendRadioIcons (const char* name, StringArrayRange icons, const IntImportCallback& importCallback,
                const IntExportCallback& exportCallback)
        {
            m_dialog.addRadioIcons(m_vbox, name, icons, importCallback, exportCallback);
        }
        void appendRadioIcons (const char* name, int& data, StringArrayRange icons)
        {
            m_dialog.addRadioIcons(m_vbox, name, data, icons);
        }
        GtkWidget* appendEntry (const char* name, const IntImportCallback& importCallback,
                const IntExportCallback& exportCallback)
        {
            return m_dialog.addIntEntry(m_vbox, name, importCallback, exportCallback);
        }
        GtkWidget* appendEntry (const char* name, int& data)
        {
            return m_dialog.addEntry(m_vbox, name, data);
        }
        GtkWidget* appendEntry (const char* name, const SizeImportCallback& importCallback,
                const SizeExportCallback& exportCallback)
        {
            return m_dialog.addSizeEntry(m_vbox, name, importCallback, exportCallback);
        }
        GtkWidget* appendEntry (const char* name, std::size_t& data)
        {
            return m_dialog.addEntry(m_vbox, name, data);
        }
        GtkWidget* appendEntry (const char* name, const FloatImportCallback& importCallback,
                const FloatExportCallback& exportCallback)
        {
            return m_dialog.addFloatEntry(m_vbox, name, importCallback, exportCallback);
        }
        GtkWidget* appendEntry (const char* name, float& data)
        {
            return m_dialog.addEntry(m_vbox, name, data);
        }
        GtkWidget* appendPathEntry (const char* name, bool browse_directory,
                const StringImportCallback& importCallback, const StringExportCallback& exportCallback)
        {
            return m_dialog.addPathEntry(m_vbox, name, browse_directory, importCallback, exportCallback);
        }
        GtkWidget* appendPathEntry (const char* name, std::string& data, bool directory)
        {
            return m_dialog.addPathEntry(m_vbox, name, data, directory);
        }
        GtkWidget* appendSpinner (const char* name, int& data, double value, double lower, double upper)
        {
            return m_dialog.addSpinner(m_vbox, name, data, value, lower, upper);
        }
        GtkWidget* appendSpinner (const char* name, double value, double lower, double upper,
                const IntImportCallback& importCallback, const IntExportCallback& exportCallback)
        {
            return m_dialog.addSpinner(m_vbox, name, value, lower, upper, importCallback, exportCallback);
        }
        GtkWidget* appendSpinner (const char* name, double value, double lower, double upper,
                const FloatImportCallback& importCallback, const FloatExportCallback& exportCallback)
        {
            return m_dialog.addSpinner(m_vbox, name, value, lower, upper, importCallback, exportCallback);
        }
};

typedef Callback1<PreferencesPage&> PreferencesPageCallback;

class PreferenceGroup
{
    public:
        virtual ~PreferenceGroup ()
        {
        }
        virtual PreferencesPage createPage (const char* treeName, const char* frameName) = 0;
};

typedef Callback1<PreferenceGroup&> PreferenceGroupCallback;

void PreferencesDialog_addInterfacePreferences (const PreferencesPageCallback& callback);
void PreferencesDialog_addInterfacePage (const PreferenceGroupCallback& callback);
void PreferencesDialog_addSettingsPreferences (const PreferencesPageCallback& callback);
void PreferencesDialog_addSettingsPage (const PreferenceGroupCallback& callback);

void PreferencesDialog_restartRequired (const std::string& staticName);

template<typename Value>
class LatchedValue
{
    public:
        Value m_value;
        Value m_latched;
        const std::string m_description;

        LatchedValue (Value value, const std::string& description) :
            m_latched(value), m_description(description)
        {
        }
        void useLatched ()
        {
            m_value = m_latched;
        }
        void import (Value value)
        {
            m_latched = value;
            if (m_latched != m_value) {
                PreferencesDialog_restartRequired(m_description);
            }
        }
};

typedef LatchedValue<bool> LatchedBool;
typedef MemberCaller1<LatchedBool, bool, &LatchedBool::import> LatchedBoolImportCaller;

typedef LatchedValue<int> LatchedInt;
typedef MemberCaller1<LatchedInt, int, &LatchedInt::import> LatchedIntImportCaller;

class CGameDescription
{
    private:
        typedef std::map<std::string, std::string> GameDescription;

    public:
        std::string mGameFile; 
        const std::string emptyString;
        GameDescription m_gameDescription;

        const std::string& getKeyValue (const std::string& key) const
        {
            GameDescription::const_iterator i = m_gameDescription.find(key);
            if (i != m_gameDescription.end()) {
                return (*i).second;
            }
            return CGameDescription::emptyString;
        }
        const std::string& getRequiredKeyValue (const std::string& key) const
        {
            GameDescription::const_iterator i = m_gameDescription.find(key);
            if (i != m_gameDescription.end()) {
                return (*i).second;
            }
            ERROR_MESSAGE("game attribute " << makeQuoted(key) << " not found in " << makeQuoted(mGameFile));
            return CGameDescription::emptyString;
        }

        CGameDescription (xmlDocPtr pDoc, const std::string &GameFile);
};

extern CGameDescription *g_pGameDescription;

typedef struct _GtkWidget GtkWidget;
class PrefsDlg;

class PreferencesPage;

class StringOutputStream;

class CGameDialog: public Dialog
{
    protected:

        mutable int m_nComboSelect; 

    public:

        bool m_bForceLogConsole;
        CGameDialog () :
            m_bForceLogConsole(false)
        {
        }
        virtual ~CGameDialog ();

        void Init ();

        void Reset ();

        GtkWindow* BuildDialog ();

        void CreateGlobalFrame (PreferencesPage& page);

    private:

        CGameDescription *GameDescriptionForComboItem ();
};

extern CGameDialog g_GamesDialog;

class texdef_t;

class PrefsDlg: public Dialog
{
    public:

        GtkWidget *m_notebook;

        virtual ~PrefsDlg ()
        {
        }

        // initialize the above paths
        void Init ();

        void showPrefPage (GtkWidget* prefpage);

    protected:

        GtkWindow* BuildDialog ();
        void PostModal (EMessageBoxReturn code);
};

extern PrefsDlg g_Preferences;

struct preferences_globals_t
{
        // disabled all INI / registry read write .. used when shutting down after registry cleanup
        bool disable_ini;
        preferences_globals_t () :
            disable_ini(false)
        {
        }
};
extern preferences_globals_t g_preferences_globals;

typedef struct _GtkWindow GtkWindow;
void PreferencesDialog_constructWindow (GtkWindow* main_window);
void PreferencesDialog_destroyWindow ();

void PreferencesDialog_showDialog ();

void Preferences_Init ();

void Preferences_Load ();
void Preferences_Save ();

void Preferences_Reset ();

#endif