src/gigedit/Settings.h

/*
    Copyright (c) 2014-2017 Christian Schoenebeck
    
    This file is part of "gigedit" and released under the terms of the
    GNU General Public License version 2.
*/

#ifndef GIGEDIT_SETTINGS
#define GIGEDIT_SETTINGS

#include <typeinfo>
#include <glibmm/object.h>
#include <glibmm/property.h>
#include <vector>
#include "global.h"

/**
 * Reflects, saves and restores all settings for the gigedit application.
 *
 * This class holds a bunch of custom Property objects which can be accessed
 * as if they were basic data types (i.e. by using assignment operator, etc.).
 * As soon as a property gets modified this way, it will automatically be saved
 * to a local config file.
 */
class Settings : public Glib::Object {
public:
    /**
     * Data types for the individual settings.
     */
    enum RawValueType_t {
        BOOLEAN,
        INTEGER,
        UNKNOWN
    };

    /**
     * All settings are grouped into these settings groups.
     */
    enum Group_t {
        GLOBAL,
        MAIN_WINDOW,
        SCRIPT_EDITOR,
        DIMENSION_MANAGER,
        SCRIPT_SLOTS,
        COMBINE_INSTRUMENTS,
        MIDI_RULES,
        FILE_PROPS,
        INSTR_PROPS,
        SAMPLE_REFS,
        MACRO_EDITOR,
        MACROS_SETUP,
        MACROS,
    };

    /**
     * Extension of regular Glib::Property template class; this one
     * automatically calls Settings::onPropertyChanged() method passing this
     * property object as pointer; and it allows to assign new values to this
     * property by using the regular assignment operator; and requires a
     * "Setting group" to be assigned to the property at construction time.
     */
    template<typename T>
    class Property : public Glib::Property<T> {
    public:
        Property(Settings& object, Group_t group, const Glib::ustring& name)
            : Glib::Property<T>::Property(object, name)
        {
            m_settings = &object;
            m_group = group;
            const RawValueType_t type = rawValueType();
            Glib::Property<T>::get_proxy().signal_changed().connect(
                sigc::bind(
                    sigc::bind(
                        sigc::bind(
                            sigc::mem_fun(m_settings, &Settings::onPropertyChanged),
                            m_group
                        ),
                        type
                    ),
                    this
                )
            );
        }

        Property(Settings& object, Group_t group, const Glib::ustring& name, const T& default_value)
            : Glib::Property<T>::Property(object, name, default_value)
        {
            m_settings = &object;
            m_group = group;
            const RawValueType_t type = rawValueType();
            Glib::Property<T>::get_proxy().signal_changed().connect(
                sigc::bind(
                    sigc::bind(
                        sigc::bind(
                            sigc::mem_fun(m_settings, &Settings::onPropertyChanged),
                            m_group
                        ),
                        type
                    ),
                    this
                )
            );
        }

        Property<T>& operator=(const T value) {
            Glib::Property<T>::set_value(value);
            return *this;
        }

        RawValueType_t rawValueType() const {
            const std::string name = typeid(T).name();
            if (name == "bool" || name == "b") return BOOLEAN;
            if (name == "int" || name == "i") return INTEGER;
            return UNKNOWN;
        }

        Group_t group() const { return m_group; }

    private:
        Settings* m_settings;
        Group_t m_group;
    };

    // settings of "Global" group
    Property<bool> warnUserOnExtensions; ///< if enabled, the user shall he be warned if he is trying to use a gig format extension that will not work with Gigasampler/GigaStudio
    Property<bool> syncSamplerInstrumentSelection; ///< if enabled, the sampler's current instrument will automatically be switched whenever another instrument was selected in gigedit
    Property<bool> moveRootNoteWithRegionMoved; ///< if enabled, the root note(s) of regions are automatically moving when the user drags a region around at the virtual keyboard
    Property<bool> autoRestoreWindowDimension;
    Property<bool> saveWithTemporaryFile; ///< If enabled and the user selects "Save" from the main menu, then the file is first saved as separate temporary file and after the save operation completed the temporary file is moved over the original file.

    // settings of "MainWindow" group
    Property<int> mainWindowX;
    Property<int> mainWindowY;
    Property<int> mainWindowW;
    Property<int> mainWindowH;

    // settings of "ScriptEditor" group
    Property<int> scriptEditorWindowX;
    Property<int> scriptEditorWindowY;
    Property<int> scriptEditorWindowW;
    Property<int> scriptEditorWindowH;
    Property<int> scriptEditorFontSize;

    // settings of "DimensionManager" group
    Property<int> dimensionManagerWindowX;
    Property<int> dimensionManagerWindowY;
    Property<int> dimensionManagerWindowW;
    Property<int> dimensionManagerWindowH;

    // settings of "ScriptSlots" group
    Property<int> scriptSlotsWindowX;
    Property<int> scriptSlotsWindowY;
    Property<int> scriptSlotsWindowW;
    Property<int> scriptSlotsWindowH;

    // settings of "CombineInstruments" group
    Property<int> combineInstrumentsWindowX;
    Property<int> combineInstrumentsWindowY;
    Property<int> combineInstrumentsWindowW;
    Property<int> combineInstrumentsWindowH;

    // settings of "MidiRules" group
    Property<int> midiRulesWindowX;
    Property<int> midiRulesWindowY;
    Property<int> midiRulesWindowW;
    Property<int> midiRulesWindowH;

    // settings of "FileProps" group
    Property<int> filePropsWindowX;
    Property<int> filePropsWindowY;
    Property<int> filePropsWindowW;
    Property<int> filePropsWindowH;

    // settings of "InstrProps" group
    Property<int> instrPropsWindowX;
    Property<int> instrPropsWindowY;
    Property<int> instrPropsWindowW;
    Property<int> instrPropsWindowH;

    // settings of "SampleRefs" group
    Property<int> sampleRefsWindowX;
    Property<int> sampleRefsWindowY;
    Property<int> sampleRefsWindowW;
    Property<int> sampleRefsWindowH;

    // settings of "MacroEditor" group
    Property<int> macroEditorWindowX;
    Property<int> macroEditorWindowY;
    Property<int> macroEditorWindowW;
    Property<int> macroEditorWindowH;

    // settings of "MacrosSetup" group
    Property<int> macrosSetupWindowX;
    Property<int> macrosSetupWindowY;
    Property<int> macrosSetupWindowW;
    Property<int> macrosSetupWindowH;

    static Settings* singleton();
    Settings();
    void load();
    void loadMacros(std::vector<Serialization::Archive>& macros);
    void saveMacros(const std::vector<Serialization::Archive>& macros);

protected:
    void onPropertyChanged(Glib::PropertyBase* pProperty, RawValueType_t type, Group_t group);

private:
    std::vector<Glib::PropertyBase*> m_boolProps; ///< Pointers to all 'bool' type properties this Setting class manages.
    std::vector<Glib::PropertyBase*> m_intProps; ///< Pointers to all 'int' type properties this Setting class manages.
    bool m_ignoreNotifies;
};

#endif // GIGEDIT_SETTINGS
1	schoenebeck	2541	/*
2	schoenebeck	3151	Copyright (c) 2014-2017 Christian Schoenebeck
3	schoenebeck	2541
4			This file is part of "gigedit" and released under the terms of the
5			GNU General Public License version 2.
6			*/
7
8			#ifndef GIGEDIT_SETTINGS
9			#define GIGEDIT_SETTINGS
10
11	schoenebeck	2891	#include <typeinfo>
12			#include <glibmm/object.h>
13			#include <glibmm/property.h>
14			#include <vector>
15	schoenebeck	3157	#include "global.h"
16	schoenebeck	2773
17	schoenebeck	2891	/**
18			* Reflects, saves and restores all settings for the gigedit application.
19			*
20			* This class holds a bunch of custom Property objects which can be accessed
21			* as if they were basic data types (i.e. by using assignment operator, etc.).
22			* As soon as a property gets modified this way, it will automatically be saved
23			* to a local config file.
24			*/
25			class Settings : public Glib::Object {
26			public:
27			/**
28			* Data types for the individual settings.
29			*/
30			enum RawValueType_t {
31			BOOLEAN,
32			INTEGER,
33			UNKNOWN
34			};
35
36			/**
37			* All settings are grouped into these settings groups.
38			*/
39			enum Group_t {
40	schoenebeck	2893	GLOBAL,
41			MAIN_WINDOW,
42			SCRIPT_EDITOR,
43	schoenebeck	2894	DIMENSION_MANAGER,
44			SCRIPT_SLOTS,
45			COMBINE_INSTRUMENTS,
46			MIDI_RULES,
47			FILE_PROPS,
48			INSTR_PROPS,
49			SAMPLE_REFS,
50	schoenebeck	3151	MACRO_EDITOR,
51	schoenebeck	3157	MACROS_SETUP,
52			MACROS,
53	schoenebeck	2891	};
54
55			/**
56			* Extension of regular Glib::Property template class; this one
57			* automatically calls Settings::onPropertyChanged() method passing this
58			* property object as pointer; and it allows to assign new values to this
59			* property by using the regular assignment operator; and requires a
60			* "Setting group" to be assigned to the property at construction time.
61			*/
62			template<typename T>
63			class Property : public Glib::Property<T> {
64			public:
65			Property(Settings& object, Group_t group, const Glib::ustring& name)
66			: Glib::Property<T>::Property(object, name)
67			{
68			m_settings = &object;
69			m_group = group;
70			const RawValueType_t type = rawValueType();
71			Glib::Property<T>::get_proxy().signal_changed().connect(
72			sigc::bind(
73			sigc::bind(
74			sigc::bind(
75			sigc::mem_fun(m_settings, &Settings::onPropertyChanged),
76			m_group
77			),
78			type
79			),
80			this
81			)
82			);
83			}
84
85			Property(Settings& object, Group_t group, const Glib::ustring& name, const T& default_value)
86			: Glib::Property<T>::Property(object, name, default_value)
87			{
88			m_settings = &object;
89			m_group = group;
90			const RawValueType_t type = rawValueType();
91			Glib::Property<T>::get_proxy().signal_changed().connect(
92			sigc::bind(
93			sigc::bind(
94			sigc::bind(
95			sigc::mem_fun(m_settings, &Settings::onPropertyChanged),
96			m_group
97			),
98			type
99			),
100			this
101			)
102			);
103			}
104
105			Property<T>& operator=(const T value) {
106			Glib::Property<T>::set_value(value);
107			return *this;
108			}
109
110			RawValueType_t rawValueType() const {
111			const std::string name = typeid(T).name();
112			if (name == "bool" \|\| name == "b") return BOOLEAN;
113			if (name == "int" \|\| name == "i") return INTEGER;
114			return UNKNOWN;
115			}
116
117			Group_t group() const { return m_group; }
118
119			private:
120			Settings* m_settings;
121			Group_t m_group;
122			};
123
124	schoenebeck	2893	// settings of "Global" group
125	schoenebeck	2891	Property<bool> warnUserOnExtensions; ///< if enabled, the user shall he be warned if he is trying to use a gig format extension that will not work with Gigasampler/GigaStudio
126			Property<bool> syncSamplerInstrumentSelection; ///< if enabled, the sampler's current instrument will automatically be switched whenever another instrument was selected in gigedit
127			Property<bool> moveRootNoteWithRegionMoved; ///< if enabled, the root note(s) of regions are automatically moving when the user drags a region around at the virtual keyboard
128	schoenebeck	2918	Property<bool> autoRestoreWindowDimension;
129	schoenebeck	2967	Property<bool> saveWithTemporaryFile; ///< If enabled and the user selects "Save" from the main menu, then the file is first saved as separate temporary file and after the save operation completed the temporary file is moved over the original file.
130	schoenebeck	2891
131	schoenebeck	2893	// settings of "MainWindow" group
132			Property<int> mainWindowX;
133			Property<int> mainWindowY;
134			Property<int> mainWindowW;
135			Property<int> mainWindowH;
136
137			// settings of "ScriptEditor" group
138			Property<int> scriptEditorWindowX;
139			Property<int> scriptEditorWindowY;
140			Property<int> scriptEditorWindowW;
141			Property<int> scriptEditorWindowH;
142	schoenebeck	2956	Property<int> scriptEditorFontSize;
143	schoenebeck	2893
144	schoenebeck	2894	// settings of "DimensionManager" group
145			Property<int> dimensionManagerWindowX;
146			Property<int> dimensionManagerWindowY;
147			Property<int> dimensionManagerWindowW;
148			Property<int> dimensionManagerWindowH;
149
150			// settings of "ScriptSlots" group
151			Property<int> scriptSlotsWindowX;
152			Property<int> scriptSlotsWindowY;
153			Property<int> scriptSlotsWindowW;
154			Property<int> scriptSlotsWindowH;
155
156			// settings of "CombineInstruments" group
157			Property<int> combineInstrumentsWindowX;
158			Property<int> combineInstrumentsWindowY;
159			Property<int> combineInstrumentsWindowW;
160			Property<int> combineInstrumentsWindowH;
161
162			// settings of "MidiRules" group
163			Property<int> midiRulesWindowX;
164			Property<int> midiRulesWindowY;
165			Property<int> midiRulesWindowW;
166			Property<int> midiRulesWindowH;
167
168			// settings of "FileProps" group
169			Property<int> filePropsWindowX;
170			Property<int> filePropsWindowY;
171			Property<int> filePropsWindowW;
172			Property<int> filePropsWindowH;
173
174			// settings of "InstrProps" group
175			Property<int> instrPropsWindowX;
176			Property<int> instrPropsWindowY;
177			Property<int> instrPropsWindowW;
178			Property<int> instrPropsWindowH;
179
180			// settings of "SampleRefs" group
181			Property<int> sampleRefsWindowX;
182			Property<int> sampleRefsWindowY;
183			Property<int> sampleRefsWindowW;
184			Property<int> sampleRefsWindowH;
185
186	schoenebeck	3151	// settings of "MacroEditor" group
187			Property<int> macroEditorWindowX;
188			Property<int> macroEditorWindowY;
189			Property<int> macroEditorWindowW;
190			Property<int> macroEditorWindowH;
191
192	schoenebeck	3157	// settings of "MacrosSetup" group
193			Property<int> macrosSetupWindowX;
194			Property<int> macrosSetupWindowY;
195			Property<int> macrosSetupWindowW;
196			Property<int> macrosSetupWindowH;
197
198	schoenebeck	2541	static Settings* singleton();
199			Settings();
200	schoenebeck	2891	void load();
201	schoenebeck	3157	void loadMacros(std::vector<Serialization::Archive>& macros);
202			void saveMacros(const std::vector<Serialization::Archive>& macros);
203	schoenebeck	2891
204			protected:
205			void onPropertyChanged(Glib::PropertyBase* pProperty, RawValueType_t type, Group_t group);
206
207			private:
208			std::vector<Glib::PropertyBase*> m_boolProps; ///< Pointers to all 'bool' type properties this Setting class manages.
209			std::vector<Glib::PropertyBase*> m_intProps; ///< Pointers to all 'int' type properties this Setting class manages.
210			bool m_ignoreNotifies;
211	schoenebeck	2541	};
212
213			#endif // GIGEDIT_SETTINGS