src/gigedit/Settings.h

/*
    Copyright (c) 2014-2020 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_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.
    Property<bool> showTooltips; ///< Whether tooltips specifically intended for newbies should be displayed throughout the application (default: yes).
    Property<bool> instrumentDoubleClickOpensProps; ///< If enabled then double clicking on an instrument of the instruments list view will show the selected instrument's properties dialog.

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

    // 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 "SampleProps" group
    Property<int> samplePropsWindowX;
    Property<int> samplePropsWindowY;
    Property<int> samplePropsWindowW;
    Property<int> samplePropsWindowH;

    // 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	/*
2	Copyright (c) 2014-2020 Christian Schoenebeck
3
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	#include <typeinfo>
12	#include <glibmm/object.h>
13	#include <glibmm/property.h>
14	#include <vector>
15	#include "global.h"
16
17	/**
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	GLOBAL,
41	MAIN_WINDOW,
42	SCRIPT_EDITOR,
43	DIMENSION_MANAGER,
44	SCRIPT_SLOTS,
45	COMBINE_INSTRUMENTS,
46	MIDI_RULES,
47	FILE_PROPS,
48	INSTR_PROPS,
49	SAMPLE_PROPS,
50	SAMPLE_REFS,
51	MACRO_EDITOR,
52	MACROS_SETUP,
53	MACROS,
54	};
55
56	/**
57	* Extension of regular Glib::Property template class; this one
58	* automatically calls Settings::onPropertyChanged() method passing this
59	* property object as pointer; and it allows to assign new values to this
60	* property by using the regular assignment operator; and requires a
61	* "Setting group" to be assigned to the property at construction time.
62	*/
63	template<typename T>
64	class Property : public Glib::Property<T> {
65	public:
66	Property(Settings& object, Group_t group, const Glib::ustring& name)
67	: Glib::Property<T>::Property(object, name)
68	{
69	m_settings = &object;
70	m_group = group;
71	const RawValueType_t type = rawValueType();
72	Glib::Property<T>::get_proxy().signal_changed().connect(
73	sigc::bind(
74	sigc::bind(
75	sigc::bind(
76	sigc::mem_fun(*m_settings, &Settings::onPropertyChanged),
77	m_group
78	),
79	type
80	),
81	this
82	)
83	);
84	}
85
86	Property(Settings& object, Group_t group, const Glib::ustring& name, const T& default_value)
87	: Glib::Property<T>::Property(object, name, default_value)
88	{
89	m_settings = &object;
90	m_group = group;
91	const RawValueType_t type = rawValueType();
92	Glib::Property<T>::get_proxy().signal_changed().connect(
93	sigc::bind(
94	sigc::bind(
95	sigc::bind(
96	sigc::mem_fun(*m_settings, &Settings::onPropertyChanged),
97	m_group
98	),
99	type
100	),
101	this
102	)
103	);
104	}
105
106	Property<T>& operator=(const T value) {
107	Glib::Property<T>::set_value(value);
108	return *this;
109	}
110
111	RawValueType_t rawValueType() const {
112	const std::string name = typeid(T).name();
113	if (name == "bool" \|\| name == "b") return BOOLEAN;
114	if (name == "int" \|\| name == "i") return INTEGER;
115	return UNKNOWN;
116	}
117
118	Group_t group() const { return m_group; }
119
120	private:
121	Settings* m_settings;
122	Group_t m_group;
123	};
124
125	// settings of "Global" group
126	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
127	Property<bool> syncSamplerInstrumentSelection; ///< if enabled, the sampler's current instrument will automatically be switched whenever another instrument was selected in gigedit
128	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
129	Property<bool> autoRestoreWindowDimension;
130	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.
131	Property<bool> showTooltips; ///< Whether tooltips specifically intended for newbies should be displayed throughout the application (default: yes).
132	Property<bool> instrumentDoubleClickOpensProps; ///< If enabled then double clicking on an instrument of the instruments list view will show the selected instrument's properties dialog.
133
134	// settings of "MainWindow" group
135	Property<int> mainWindowX;
136	Property<int> mainWindowY;
137	Property<int> mainWindowW;
138	Property<int> mainWindowH;
139	Property<int> mainWindowSplitterPosX;
140
141	// settings of "ScriptEditor" group
142	Property<int> scriptEditorWindowX;
143	Property<int> scriptEditorWindowY;
144	Property<int> scriptEditorWindowW;
145	Property<int> scriptEditorWindowH;
146	Property<int> scriptEditorFontSize;
147
148	// settings of "DimensionManager" group
149	Property<int> dimensionManagerWindowX;
150	Property<int> dimensionManagerWindowY;
151	Property<int> dimensionManagerWindowW;
152	Property<int> dimensionManagerWindowH;
153
154	// settings of "ScriptSlots" group
155	Property<int> scriptSlotsWindowX;
156	Property<int> scriptSlotsWindowY;
157	Property<int> scriptSlotsWindowW;
158	Property<int> scriptSlotsWindowH;
159
160	// settings of "CombineInstruments" group
161	Property<int> combineInstrumentsWindowX;
162	Property<int> combineInstrumentsWindowY;
163	Property<int> combineInstrumentsWindowW;
164	Property<int> combineInstrumentsWindowH;
165
166	// settings of "MidiRules" group
167	Property<int> midiRulesWindowX;
168	Property<int> midiRulesWindowY;
169	Property<int> midiRulesWindowW;
170	Property<int> midiRulesWindowH;
171
172	// settings of "FileProps" group
173	Property<int> filePropsWindowX;
174	Property<int> filePropsWindowY;
175	Property<int> filePropsWindowW;
176	Property<int> filePropsWindowH;
177
178	// settings of "InstrProps" group
179	Property<int> instrPropsWindowX;
180	Property<int> instrPropsWindowY;
181	Property<int> instrPropsWindowW;
182	Property<int> instrPropsWindowH;
183
184	// settings of "SampleProps" group
185	Property<int> samplePropsWindowX;
186	Property<int> samplePropsWindowY;
187	Property<int> samplePropsWindowW;
188	Property<int> samplePropsWindowH;
189
190	// settings of "SampleRefs" group
191	Property<int> sampleRefsWindowX;
192	Property<int> sampleRefsWindowY;
193	Property<int> sampleRefsWindowW;
194	Property<int> sampleRefsWindowH;
195
196	// settings of "MacroEditor" group
197	Property<int> macroEditorWindowX;
198	Property<int> macroEditorWindowY;
199	Property<int> macroEditorWindowW;
200	Property<int> macroEditorWindowH;
201
202	// settings of "MacrosSetup" group
203	Property<int> macrosSetupWindowX;
204	Property<int> macrosSetupWindowY;
205	Property<int> macrosSetupWindowW;
206	Property<int> macrosSetupWindowH;
207
208	static Settings* singleton();
209	Settings();
210	void load();
211	void loadMacros(std::vector<Serialization::Archive>& macros);
212	void saveMacros(const std::vector<Serialization::Archive>& macros);
213
214	protected:
215	void onPropertyChanged(Glib::PropertyBase* pProperty, RawValueType_t type, Group_t group);
216
217	private:
218	std::vector<Glib::PropertyBase*> m_boolProps; ///< Pointers to all 'bool' type properties this Setting class manages.
219	std::vector<Glib::PropertyBase*> m_intProps; ///< Pointers to all 'int' type properties this Setting class manages.
220	bool m_ignoreNotifies;
221	};
222
223	#endif // GIGEDIT_SETTINGS