src/gigedit/Settings.cpp

/*
    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.
*/

#include "global.h"
#include "Settings.h"
#ifdef GLIB_HEADER_FILE
# include GLIB_HEADER_FILE(glib.h)
#else
# include <glib.h>
#endif
#include <glibmm/keyfile.h>
#include <iostream>
#include <stdio.h>
#include <fstream>
#include <string.h>

#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 40) || GTKMM_MAJOR_VERSION < 2
# define HAS_GLIB_KEYFILE_SAVE_TO_FILE 0
#else
# define HAS_GLIB_KEYFILE_SAVE_TO_FILE 1
#endif

static std::string configDir() {
    //printf("configDir '%s'\n", g_get_user_config_dir());
    return g_get_user_config_dir();
}

static std::string dirSep() {
    //printf("sep '%s'\n", G_DIR_SEPARATOR_S);
    return G_DIR_SEPARATOR_S;
}

static std::string configFile() {
    return configDir() + dirSep() + "gigedit.conf";
}

static std::string groupName(Settings::Group_t group) {
    switch (group) {
        case Settings::GLOBAL: return "Global";
        case Settings::MAIN_WINDOW: return "MainWindow";
        case Settings::SCRIPT_EDITOR: return "ScriptEditor";
        case Settings::DIMENSION_MANAGER: return "DimensionManager";
        case Settings::SCRIPT_SLOTS: return "ScriptSlots";
        case Settings::COMBINE_INSTRUMENTS: return "CombineInstruments";
        case Settings::MIDI_RULES: return "MidiRules";
        case Settings::FILE_PROPS: return "FileProps";
        case Settings::INSTR_PROPS: return "InstrProps";
        case Settings::SAMPLE_PROPS: return "SampleProps";
        case Settings::SAMPLE_REFS: return "SampleRefs";
        case Settings::MACRO_EDITOR: return "MacroEditor";
        case Settings::MACROS_SETUP: return "MacrosSetup";
        case Settings::MACROS: return "Macros";
    }
    return "Global";
}

#if !HAS_GLIB_KEYFILE_SAVE_TO_FILE

static bool saveToFile(Glib::KeyFile* keyfile, std::string filename) {
    Glib::ustring s = keyfile->to_data();
    std::ofstream out;
    out.open(filename.c_str(), std::ios_base::out | std::ios_base::trunc);
    out << s;
    out.close();
    return true;
}

#endif // ! HAS_GLIB_KEYFILE_SAVE_TO_FILE

static Settings* _instance = NULL;
    
Settings* Settings::singleton() {
    if (!_instance) {
        _instance = new Settings;
        _instance->load();
    }
    return _instance;
}

Settings::Settings() : Glib::ObjectBase(typeid(Settings)),
    warnUserOnExtensions(*this, GLOBAL, "warnUserOnExtensions", true),
    syncSamplerInstrumentSelection(*this, GLOBAL, "syncSamplerInstrumentSelection", true),
    moveRootNoteWithRegionMoved(*this, GLOBAL, "moveRootNoteWithRegionMoved", true),
    autoRestoreWindowDimension(*this, GLOBAL, "autoRestoreWindowDimension", false),
    saveWithTemporaryFile(*this, GLOBAL, "saveWithTemporaryFile", false),
    showTooltips(*this, GLOBAL, "showNewbieTooltips", true),
    instrumentDoubleClickOpensProps(*this, GLOBAL, "openInstrPropsByDoubleClick", true),
    mainWindowX(*this, MAIN_WINDOW, "x", -1),
    mainWindowY(*this, MAIN_WINDOW, "y", -1),
    mainWindowW(*this, MAIN_WINDOW, "w", -1),
    mainWindowH(*this, MAIN_WINDOW, "h", -1),
    scriptEditorWindowX(*this, SCRIPT_EDITOR, "x", -1),
    scriptEditorWindowY(*this, SCRIPT_EDITOR, "y", -1),
    scriptEditorWindowW(*this, SCRIPT_EDITOR, "w", -1),
    scriptEditorWindowH(*this, SCRIPT_EDITOR, "h", -1),
    scriptEditorFontSize(*this, SCRIPT_EDITOR, "fontSize", -1),
    dimensionManagerWindowX(*this, DIMENSION_MANAGER, "x", -1),
    dimensionManagerWindowY(*this, DIMENSION_MANAGER, "y", -1),
    dimensionManagerWindowW(*this, DIMENSION_MANAGER, "w", -1),
    dimensionManagerWindowH(*this, DIMENSION_MANAGER, "h", -1),
    scriptSlotsWindowX(*this, SCRIPT_SLOTS, "x", -1),
    scriptSlotsWindowY(*this, SCRIPT_SLOTS, "y", -1),
    scriptSlotsWindowW(*this, SCRIPT_SLOTS, "w", -1),
    scriptSlotsWindowH(*this, SCRIPT_SLOTS, "h", -1),
    combineInstrumentsWindowX(*this, COMBINE_INSTRUMENTS, "x", -1),
    combineInstrumentsWindowY(*this, COMBINE_INSTRUMENTS, "y", -1),
    combineInstrumentsWindowW(*this, COMBINE_INSTRUMENTS, "w", -1),
    combineInstrumentsWindowH(*this, COMBINE_INSTRUMENTS, "h", -1),
    midiRulesWindowX(*this, MIDI_RULES, "x", -1),
    midiRulesWindowY(*this, MIDI_RULES, "y", -1),
    midiRulesWindowW(*this, MIDI_RULES, "w", -1),
    midiRulesWindowH(*this, MIDI_RULES, "h", -1),
    filePropsWindowX(*this, FILE_PROPS, "x", -1),
    filePropsWindowY(*this, FILE_PROPS, "y", -1),
    filePropsWindowW(*this, FILE_PROPS, "w", -1),
    filePropsWindowH(*this, FILE_PROPS, "h", -1),
    instrPropsWindowX(*this, INSTR_PROPS, "x", -1),
    instrPropsWindowY(*this, INSTR_PROPS, "y", -1),
    instrPropsWindowW(*this, INSTR_PROPS, "w", -1),
    instrPropsWindowH(*this, INSTR_PROPS, "h", -1),
    samplePropsWindowX(*this, SAMPLE_PROPS, "x", -1),
    samplePropsWindowY(*this, SAMPLE_PROPS, "y", -1),
    samplePropsWindowW(*this, SAMPLE_PROPS, "w", -1),
    samplePropsWindowH(*this, SAMPLE_PROPS, "h", -1),
    sampleRefsWindowX(*this, SAMPLE_REFS, "x", -1),
    sampleRefsWindowY(*this, SAMPLE_REFS, "y", -1),
    sampleRefsWindowW(*this, SAMPLE_REFS, "w", -1),
    sampleRefsWindowH(*this, SAMPLE_REFS, "h", -1),
    macroEditorWindowX(*this, MACRO_EDITOR, "x", -1),
    macroEditorWindowY(*this, MACRO_EDITOR, "y", -1),
    macroEditorWindowW(*this, MACRO_EDITOR, "w", -1),
    macroEditorWindowH(*this, MACRO_EDITOR, "h", -1),
    macrosSetupWindowX(*this, MACROS_SETUP, "x", -1),
    macrosSetupWindowY(*this, MACROS_SETUP, "y", -1),
    macrosSetupWindowW(*this, MACROS_SETUP, "w", -1),
    macrosSetupWindowH(*this, MACROS_SETUP, "h", -1),
    m_ignoreNotifies(false)
{
    m_boolProps.push_back(&warnUserOnExtensions);
    m_boolProps.push_back(&syncSamplerInstrumentSelection);
    m_boolProps.push_back(&moveRootNoteWithRegionMoved);
    m_boolProps.push_back(&autoRestoreWindowDimension);
    m_boolProps.push_back(&saveWithTemporaryFile);
    m_boolProps.push_back(&showTooltips);
    m_boolProps.push_back(&instrumentDoubleClickOpensProps);
    m_intProps.push_back(&mainWindowX);
    m_intProps.push_back(&mainWindowY);
    m_intProps.push_back(&mainWindowW);
    m_intProps.push_back(&mainWindowH);
    m_intProps.push_back(&scriptEditorWindowX);
    m_intProps.push_back(&scriptEditorWindowY);
    m_intProps.push_back(&scriptEditorWindowW);
    m_intProps.push_back(&scriptEditorWindowH);
    m_intProps.push_back(&scriptEditorFontSize);
    m_intProps.push_back(&dimensionManagerWindowX);
    m_intProps.push_back(&dimensionManagerWindowY);
    m_intProps.push_back(&dimensionManagerWindowW);
    m_intProps.push_back(&dimensionManagerWindowH);
    m_intProps.push_back(&scriptSlotsWindowX);
    m_intProps.push_back(&scriptSlotsWindowY);
    m_intProps.push_back(&scriptSlotsWindowW);
    m_intProps.push_back(&scriptSlotsWindowH);
    m_intProps.push_back(&combineInstrumentsWindowX);
    m_intProps.push_back(&combineInstrumentsWindowY);
    m_intProps.push_back(&combineInstrumentsWindowW);
    m_intProps.push_back(&combineInstrumentsWindowH);
    m_intProps.push_back(&midiRulesWindowX);
    m_intProps.push_back(&midiRulesWindowY);
    m_intProps.push_back(&midiRulesWindowW);
    m_intProps.push_back(&midiRulesWindowH);
    m_intProps.push_back(&filePropsWindowX);
    m_intProps.push_back(&filePropsWindowY);
    m_intProps.push_back(&filePropsWindowW);
    m_intProps.push_back(&filePropsWindowH);
    m_intProps.push_back(&instrPropsWindowX);
    m_intProps.push_back(&instrPropsWindowY);
    m_intProps.push_back(&instrPropsWindowW);
    m_intProps.push_back(&instrPropsWindowH);
    m_intProps.push_back(&samplePropsWindowX);
    m_intProps.push_back(&samplePropsWindowY);
    m_intProps.push_back(&samplePropsWindowW);
    m_intProps.push_back(&samplePropsWindowH);
    m_intProps.push_back(&sampleRefsWindowX);
    m_intProps.push_back(&sampleRefsWindowY);
    m_intProps.push_back(&sampleRefsWindowW);
    m_intProps.push_back(&sampleRefsWindowH);
    m_intProps.push_back(&macroEditorWindowX);
    m_intProps.push_back(&macroEditorWindowY);
    m_intProps.push_back(&macroEditorWindowW);
    m_intProps.push_back(&macroEditorWindowH);
    m_intProps.push_back(&macrosSetupWindowX);
    m_intProps.push_back(&macrosSetupWindowY);
    m_intProps.push_back(&macrosSetupWindowW);
    m_intProps.push_back(&macrosSetupWindowH);
}

void Settings::onPropertyChanged(Glib::PropertyBase* pProperty, RawValueType_t type, Group_t group) {
    if (m_ignoreNotifies) return;

    //printf("Settings::onPropertyChanged(%s)\n", pProperty->get_name().c_str());

    Glib::KeyFile file;
    try {
        bool ok = file.load_from_file(configFile());
        if (!ok) {
            std::cerr << "Could not load '" << configFile() << "'\n" << std::flush;
        }
    } catch (...) {
        std::cerr << "Could not load '" << configFile() << "'\n" << std::flush;
    }

    switch (type) {
        case BOOLEAN: {
            Property<bool>* prop = static_cast<Property<bool>*>(pProperty);
            //std::cout << "Saving bool setting '" << prop->get_name() << "'\n" << std::flush;
            file.set_boolean(groupName(prop->group()), prop->get_name(), prop->get_value());
            break;
        }
        case INTEGER: {
            Property<int>* prop = static_cast<Property<int>*>(pProperty);
            //std::cout << "Saving int setting '" << prop->get_name() << "'\n" << std::flush;
            file.set_integer(groupName(prop->group()), prop->get_name(), prop->get_value());
            break;
        }
        case UNKNOWN:
            std::cerr << "BUG: Unknown setting raw type of property '" << pProperty->get_name() << "'\n" << std::flush;
            return;
    }

    try {
#if HAS_GLIB_KEYFILE_SAVE_TO_FILE
        bool ok = file.save_to_file(configFile());
#else
        bool ok = saveToFile(&file, configFile());
#endif
        if (!ok) {
            std::cerr << "Failed saving gigedit config to '" << configFile() << "'\n" << std::flush;
        } else {
            //std::cout <<"gigedit CONFIG SAVED\n";
        }
    } catch (...) {
        std::cerr << "Failed saving gigedit config to '" << configFile() << "'\n" << std::flush;
    }
}

void Settings::load() {
    Glib::KeyFile file;
    try {
        bool ok = file.load_from_file(configFile());
        if (!ok) return;
    } catch (...) {
        std::cerr << "Could not load gigedit config file '" << configFile() << "'\n" << std::flush;
        return;
    }

    // ignore onPropertyChanged() calls during updating the property values below
    m_ignoreNotifies = true;

    for (int i = 0; i < m_boolProps.size(); ++i) {
        Property<bool>* prop = static_cast<Property<bool>*>(m_boolProps[i]);
        try {
            const std::string group = groupName(prop->group());
            if (!file.has_group(group)) continue;
            if (!file.has_key(group, prop->get_name())) continue;
            const bool value = file.get_boolean(group, prop->get_name());
            prop->set_value(value);
        } catch (...) {
            continue;
        }
    }

    for (int i = 0; i < m_intProps.size(); ++i) {
        Property<int>* prop = static_cast<Property<int>*>(m_intProps[i]);
        try {
            const std::string group = groupName(prop->group());
            if (!file.has_group(group)) continue;
            if (!file.has_key(group, prop->get_name())) continue;
            const int value = file.get_integer(group, prop->get_name());
            prop->set_value(value);
        } catch (...) {
            continue;
        }
    }

    m_ignoreNotifies = false;
}

#define MACRO_LIST_NAME "srlzl"

void Settings::loadMacros(std::vector<Serialization::Archive>& macros) {
    const std::string group = groupName(MACROS);
    macros.clear();
    Glib::KeyFile file;
    try {
        bool ok = file.load_from_file(configFile());
        if (!ok) return;
    } catch (...) {
        std::cerr << "Could not load gigedit config file '" << configFile() << "'\n" << std::flush;
        return;
    }
    if (!file.has_group(group)) return;
    if (!file.has_key(group, MACRO_LIST_NAME))
        return;
    std::vector<Glib::ustring> v = file.get_string_list(group, MACRO_LIST_NAME);
    for (int i = 0; i < v.size(); ++i) {
        Serialization::Archive macro;
        macro.decode((const uint8_t*)v[i].c_str(), v[i].length());
        macros.push_back(macro);
    }
}

void Settings::saveMacros(const std::vector<Serialization::Archive>& macros) {
    const std::string group = groupName(MACROS);
    Glib::KeyFile file;
    try {
        bool ok = file.load_from_file(configFile());
        if (!ok) {
            std::cerr << "Could not load '" << configFile() << "'\n" << std::flush;
        }
    } catch (...) {
        std::cerr << "Could not load '" << configFile() << "'\n" << std::flush;
        return;
    }

    std::vector<Glib::ustring> v;
    for (int i = 0; i < macros.size(); ++i) {
        const Serialization::RawData& rawData = const_cast<Serialization::Archive&>(macros[i]).rawData();
        std::string s((const char*)&rawData[0], rawData.size());
        v.push_back(s);
    }

    file.set_string_list(group, MACRO_LIST_NAME, v);

    try {
#if HAS_GLIB_KEYFILE_SAVE_TO_FILE
        bool ok = file.save_to_file(configFile());
#else
        bool ok = saveToFile(&file, configFile());
#endif
        if (!ok) {
            std::cerr << "Failed saving gigedit config to '" << configFile() << "'\n" << std::flush;
        } else {
            //std::cout <<"gigedit CONFIG SAVED\n";
        }
    } catch (...) {
        std::cerr << "Failed saving gigedit config to '" << configFile() << "'\n" << std::flush;
    }

}
1	schoenebeck	2541	/*
2	schoenebeck	3711	Copyright (c) 2014-2020 Christian Schoenebeck
3
4	schoenebeck	2541	This file is part of "gigedit" and released under the terms of the
5			GNU General Public License version 2.
6			*/
7
8	persson	3202	#include "global.h"
9	schoenebeck	2541	#include "Settings.h"
10	schoenebeck	3364	#ifdef GLIB_HEADER_FILE
11			# include GLIB_HEADER_FILE(glib.h)
12			#else
13			# include <glib.h>
14			#endif
15	schoenebeck	2891	#include <glibmm/keyfile.h>
16			#include <iostream>
17			#include <stdio.h>
18	schoenebeck	2892	#include <fstream>
19	schoenebeck	3157	#include <string.h>
20	schoenebeck	2541
21	schoenebeck	2892	#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 40) \|\| GTKMM_MAJOR_VERSION < 2
22			# define HAS_GLIB_KEYFILE_SAVE_TO_FILE 0
23			#else
24			# define HAS_GLIB_KEYFILE_SAVE_TO_FILE 1
25			#endif
26
27	schoenebeck	2891	static std::string configDir() {
28			//printf("configDir '%s'\n", g_get_user_config_dir());
29			return g_get_user_config_dir();
30			}
31
32			static std::string dirSep() {
33			//printf("sep '%s'\n", G_DIR_SEPARATOR_S);
34			return G_DIR_SEPARATOR_S;
35			}
36
37			static std::string configFile() {
38			return configDir() + dirSep() + "gigedit.conf";
39			}
40
41			static std::string groupName(Settings::Group_t group) {
42	schoenebeck	2893	switch (group) {
43			case Settings::GLOBAL: return "Global";
44			case Settings::MAIN_WINDOW: return "MainWindow";
45			case Settings::SCRIPT_EDITOR: return "ScriptEditor";
46	schoenebeck	2894	case Settings::DIMENSION_MANAGER: return "DimensionManager";
47			case Settings::SCRIPT_SLOTS: return "ScriptSlots";
48			case Settings::COMBINE_INSTRUMENTS: return "CombineInstruments";
49			case Settings::MIDI_RULES: return "MidiRules";
50			case Settings::FILE_PROPS: return "FileProps";
51			case Settings::INSTR_PROPS: return "InstrProps";
52	schoenebeck	3637	case Settings::SAMPLE_PROPS: return "SampleProps";
53	schoenebeck	2894	case Settings::SAMPLE_REFS: return "SampleRefs";
54	schoenebeck	3157	case Settings::MACRO_EDITOR: return "MacroEditor";
55			case Settings::MACROS_SETUP: return "MacrosSetup";
56			case Settings::MACROS: return "Macros";
57	schoenebeck	2893	}
58	schoenebeck	2891	return "Global";
59			}
60
61	schoenebeck	2892	#if !HAS_GLIB_KEYFILE_SAVE_TO_FILE
62
63			static bool saveToFile(Glib::KeyFile* keyfile, std::string filename) {
64			Glib::ustring s = keyfile->to_data();
65			std::ofstream out;
66			out.open(filename.c_str(), std::ios_base::out \| std::ios_base::trunc);
67			out << s;
68			out.close();
69			return true;
70			}
71
72			#endif // ! HAS_GLIB_KEYFILE_SAVE_TO_FILE
73
74	schoenebeck	2891	static Settings* _instance = NULL;
75	schoenebeck	2541
76			Settings* Settings::singleton() {
77	schoenebeck	2891	if (!_instance) {
78			_instance = new Settings;
79			_instance->load();
80			}
81			return _instance;
82	schoenebeck	2541	}
83
84	schoenebeck	2891	Settings::Settings() : Glib::ObjectBase(typeid(Settings)),
85			warnUserOnExtensions(*this, GLOBAL, "warnUserOnExtensions", true),
86			syncSamplerInstrumentSelection(*this, GLOBAL, "syncSamplerInstrumentSelection", true),
87			moveRootNoteWithRegionMoved(*this, GLOBAL, "moveRootNoteWithRegionMoved", true),
88	schoenebeck	2918	autoRestoreWindowDimension(*this, GLOBAL, "autoRestoreWindowDimension", false),
89	schoenebeck	2967	saveWithTemporaryFile(*this, GLOBAL, "saveWithTemporaryFile", false),
90	schoenebeck	3409	showTooltips(*this, GLOBAL, "showNewbieTooltips", true),
91	schoenebeck	3711	instrumentDoubleClickOpensProps(*this, GLOBAL, "openInstrPropsByDoubleClick", true),
92	schoenebeck	2893	mainWindowX(*this, MAIN_WINDOW, "x", -1),
93			mainWindowY(*this, MAIN_WINDOW, "y", -1),
94			mainWindowW(*this, MAIN_WINDOW, "w", -1),
95			mainWindowH(*this, MAIN_WINDOW, "h", -1),
96			scriptEditorWindowX(*this, SCRIPT_EDITOR, "x", -1),
97			scriptEditorWindowY(*this, SCRIPT_EDITOR, "y", -1),
98			scriptEditorWindowW(*this, SCRIPT_EDITOR, "w", -1),
99			scriptEditorWindowH(*this, SCRIPT_EDITOR, "h", -1),
100	schoenebeck	2956	scriptEditorFontSize(*this, SCRIPT_EDITOR, "fontSize", -1),
101	schoenebeck	2894	dimensionManagerWindowX(*this, DIMENSION_MANAGER, "x", -1),
102			dimensionManagerWindowY(*this, DIMENSION_MANAGER, "y", -1),
103			dimensionManagerWindowW(*this, DIMENSION_MANAGER, "w", -1),
104			dimensionManagerWindowH(*this, DIMENSION_MANAGER, "h", -1),
105			scriptSlotsWindowX(*this, SCRIPT_SLOTS, "x", -1),
106			scriptSlotsWindowY(*this, SCRIPT_SLOTS, "y", -1),
107			scriptSlotsWindowW(*this, SCRIPT_SLOTS, "w", -1),
108			scriptSlotsWindowH(*this, SCRIPT_SLOTS, "h", -1),
109			combineInstrumentsWindowX(*this, COMBINE_INSTRUMENTS, "x", -1),
110			combineInstrumentsWindowY(*this, COMBINE_INSTRUMENTS, "y", -1),
111			combineInstrumentsWindowW(*this, COMBINE_INSTRUMENTS, "w", -1),
112			combineInstrumentsWindowH(*this, COMBINE_INSTRUMENTS, "h", -1),
113			midiRulesWindowX(*this, MIDI_RULES, "x", -1),
114			midiRulesWindowY(*this, MIDI_RULES, "y", -1),
115			midiRulesWindowW(*this, MIDI_RULES, "w", -1),
116			midiRulesWindowH(*this, MIDI_RULES, "h", -1),
117			filePropsWindowX(*this, FILE_PROPS, "x", -1),
118			filePropsWindowY(*this, FILE_PROPS, "y", -1),
119			filePropsWindowW(*this, FILE_PROPS, "w", -1),
120			filePropsWindowH(*this, FILE_PROPS, "h", -1),
121			instrPropsWindowX(*this, INSTR_PROPS, "x", -1),
122			instrPropsWindowY(*this, INSTR_PROPS, "y", -1),
123			instrPropsWindowW(*this, INSTR_PROPS, "w", -1),
124			instrPropsWindowH(*this, INSTR_PROPS, "h", -1),
125	schoenebeck	3637	samplePropsWindowX(*this, SAMPLE_PROPS, "x", -1),
126			samplePropsWindowY(*this, SAMPLE_PROPS, "y", -1),
127			samplePropsWindowW(*this, SAMPLE_PROPS, "w", -1),
128			samplePropsWindowH(*this, SAMPLE_PROPS, "h", -1),
129	schoenebeck	2894	sampleRefsWindowX(*this, SAMPLE_REFS, "x", -1),
130			sampleRefsWindowY(*this, SAMPLE_REFS, "y", -1),
131			sampleRefsWindowW(*this, SAMPLE_REFS, "w", -1),
132			sampleRefsWindowH(*this, SAMPLE_REFS, "h", -1),
133	schoenebeck	3151	macroEditorWindowX(*this, MACRO_EDITOR, "x", -1),
134			macroEditorWindowY(*this, MACRO_EDITOR, "y", -1),
135			macroEditorWindowW(*this, MACRO_EDITOR, "w", -1),
136			macroEditorWindowH(*this, MACRO_EDITOR, "h", -1),
137	schoenebeck	3157	macrosSetupWindowX(*this, MACROS_SETUP, "x", -1),
138			macrosSetupWindowY(*this, MACROS_SETUP, "y", -1),
139			macrosSetupWindowW(*this, MACROS_SETUP, "w", -1),
140			macrosSetupWindowH(*this, MACROS_SETUP, "h", -1),
141	schoenebeck	2891	m_ignoreNotifies(false)
142			{
143			m_boolProps.push_back(&warnUserOnExtensions);
144			m_boolProps.push_back(&syncSamplerInstrumentSelection);
145			m_boolProps.push_back(&moveRootNoteWithRegionMoved);
146	schoenebeck	2918	m_boolProps.push_back(&autoRestoreWindowDimension);
147	schoenebeck	2967	m_boolProps.push_back(&saveWithTemporaryFile);
148	schoenebeck	3409	m_boolProps.push_back(&showTooltips);
149	schoenebeck	3711	m_boolProps.push_back(&instrumentDoubleClickOpensProps);
150	schoenebeck	2893	m_intProps.push_back(&mainWindowX);
151			m_intProps.push_back(&mainWindowY);
152			m_intProps.push_back(&mainWindowW);
153			m_intProps.push_back(&mainWindowH);
154			m_intProps.push_back(&scriptEditorWindowX);
155			m_intProps.push_back(&scriptEditorWindowY);
156			m_intProps.push_back(&scriptEditorWindowW);
157			m_intProps.push_back(&scriptEditorWindowH);
158	schoenebeck	2956	m_intProps.push_back(&scriptEditorFontSize);
159	schoenebeck	2894	m_intProps.push_back(&dimensionManagerWindowX);
160			m_intProps.push_back(&dimensionManagerWindowY);
161			m_intProps.push_back(&dimensionManagerWindowW);
162			m_intProps.push_back(&dimensionManagerWindowH);
163			m_intProps.push_back(&scriptSlotsWindowX);
164			m_intProps.push_back(&scriptSlotsWindowY);
165			m_intProps.push_back(&scriptSlotsWindowW);
166			m_intProps.push_back(&scriptSlotsWindowH);
167			m_intProps.push_back(&combineInstrumentsWindowX);
168			m_intProps.push_back(&combineInstrumentsWindowY);
169			m_intProps.push_back(&combineInstrumentsWindowW);
170			m_intProps.push_back(&combineInstrumentsWindowH);
171			m_intProps.push_back(&midiRulesWindowX);
172			m_intProps.push_back(&midiRulesWindowY);
173			m_intProps.push_back(&midiRulesWindowW);
174			m_intProps.push_back(&midiRulesWindowH);
175			m_intProps.push_back(&filePropsWindowX);
176			m_intProps.push_back(&filePropsWindowY);
177			m_intProps.push_back(&filePropsWindowW);
178			m_intProps.push_back(&filePropsWindowH);
179			m_intProps.push_back(&instrPropsWindowX);
180			m_intProps.push_back(&instrPropsWindowY);
181			m_intProps.push_back(&instrPropsWindowW);
182			m_intProps.push_back(&instrPropsWindowH);
183	schoenebeck	3637	m_intProps.push_back(&samplePropsWindowX);
184			m_intProps.push_back(&samplePropsWindowY);
185			m_intProps.push_back(&samplePropsWindowW);
186			m_intProps.push_back(&samplePropsWindowH);
187	schoenebeck	2894	m_intProps.push_back(&sampleRefsWindowX);
188			m_intProps.push_back(&sampleRefsWindowY);
189			m_intProps.push_back(&sampleRefsWindowW);
190			m_intProps.push_back(&sampleRefsWindowH);
191	schoenebeck	3151	m_intProps.push_back(&macroEditorWindowX);
192			m_intProps.push_back(&macroEditorWindowY);
193			m_intProps.push_back(&macroEditorWindowW);
194			m_intProps.push_back(&macroEditorWindowH);
195	schoenebeck	3157	m_intProps.push_back(&macrosSetupWindowX);
196			m_intProps.push_back(&macrosSetupWindowY);
197			m_intProps.push_back(&macrosSetupWindowW);
198			m_intProps.push_back(&macrosSetupWindowH);
199	schoenebeck	2541	}
200	schoenebeck	2891
201			void Settings::onPropertyChanged(Glib::PropertyBase* pProperty, RawValueType_t type, Group_t group) {
202			if (m_ignoreNotifies) return;
203
204			//printf("Settings::onPropertyChanged(%s)\n", pProperty->get_name().c_str());
205
206			Glib::KeyFile file;
207			try {
208			bool ok = file.load_from_file(configFile());
209			if (!ok) {
210			std::cerr << "Could not load '" << configFile() << "'\n" << std::flush;
211			}
212			} catch (...) {
213			std::cerr << "Could not load '" << configFile() << "'\n" << std::flush;
214			}
215
216			switch (type) {
217			case BOOLEAN: {
218			Property<bool>* prop = static_cast<Property<bool>*>(pProperty);
219			//std::cout << "Saving bool setting '" << prop->get_name() << "'\n" << std::flush;
220			file.set_boolean(groupName(prop->group()), prop->get_name(), prop->get_value());
221			break;
222			}
223			case INTEGER: {
224			Property<int>* prop = static_cast<Property<int>*>(pProperty);
225			//std::cout << "Saving int setting '" << prop->get_name() << "'\n" << std::flush;
226			file.set_integer(groupName(prop->group()), prop->get_name(), prop->get_value());
227			break;
228			}
229			case UNKNOWN:
230			std::cerr << "BUG: Unknown setting raw type of property '" << pProperty->get_name() << "'\n" << std::flush;
231			return;
232			}
233
234			try {
235	schoenebeck	2892	#if HAS_GLIB_KEYFILE_SAVE_TO_FILE
236	schoenebeck	2891	bool ok = file.save_to_file(configFile());
237	schoenebeck	2892	#else
238			bool ok = saveToFile(&file, configFile());
239			#endif
240	schoenebeck	2891	if (!ok) {
241			std::cerr << "Failed saving gigedit config to '" << configFile() << "'\n" << std::flush;
242			} else {
243			//std::cout <<"gigedit CONFIG SAVED\n";
244			}
245			} catch (...) {
246			std::cerr << "Failed saving gigedit config to '" << configFile() << "'\n" << std::flush;
247			}
248			}
249
250			void Settings::load() {
251			Glib::KeyFile file;
252			try {
253			bool ok = file.load_from_file(configFile());
254			if (!ok) return;
255			} catch (...) {
256			std::cerr << "Could not load gigedit config file '" << configFile() << "'\n" << std::flush;
257			return;
258			}
259
260			// ignore onPropertyChanged() calls during updating the property values below
261			m_ignoreNotifies = true;
262
263			for (int i = 0; i < m_boolProps.size(); ++i) {
264			Property<bool>* prop = static_cast<Property<bool>*>(m_boolProps[i]);
265			try {
266			const std::string group = groupName(prop->group());
267	schoenebeck	3157	if (!file.has_group(group)) continue;
268	schoenebeck	2891	if (!file.has_key(group, prop->get_name())) continue;
269			const bool value = file.get_boolean(group, prop->get_name());
270			prop->set_value(value);
271			} catch (...) {
272			continue;
273			}
274			}
275
276			for (int i = 0; i < m_intProps.size(); ++i) {
277			Property<int>* prop = static_cast<Property<int>*>(m_intProps[i]);
278			try {
279			const std::string group = groupName(prop->group());
280	schoenebeck	3157	if (!file.has_group(group)) continue;
281	schoenebeck	2891	if (!file.has_key(group, prop->get_name())) continue;
282			const int value = file.get_integer(group, prop->get_name());
283			prop->set_value(value);
284			} catch (...) {
285			continue;
286			}
287			}
288
289			m_ignoreNotifies = false;
290			}
291
292	schoenebeck	3157	#define MACRO_LIST_NAME "srlzl"
293
294			void Settings::loadMacros(std::vector<Serialization::Archive>& macros) {
295			const std::string group = groupName(MACROS);
296			macros.clear();
297			Glib::KeyFile file;
298			try {
299			bool ok = file.load_from_file(configFile());
300			if (!ok) return;
301			} catch (...) {
302			std::cerr << "Could not load gigedit config file '" << configFile() << "'\n" << std::flush;
303			return;
304			}
305			if (!file.has_group(group)) return;
306			if (!file.has_key(group, MACRO_LIST_NAME))
307			return;
308			std::vector<Glib::ustring> v = file.get_string_list(group, MACRO_LIST_NAME);
309			for (int i = 0; i < v.size(); ++i) {
310			Serialization::Archive macro;
311			macro.decode((const uint8_t*)v[i].c_str(), v[i].length());
312			macros.push_back(macro);
313			}
314			}
315
316			void Settings::saveMacros(const std::vector<Serialization::Archive>& macros) {
317			const std::string group = groupName(MACROS);
318			Glib::KeyFile file;
319			try {
320			bool ok = file.load_from_file(configFile());
321			if (!ok) {
322			std::cerr << "Could not load '" << configFile() << "'\n" << std::flush;
323			}
324			} catch (...) {
325			std::cerr << "Could not load '" << configFile() << "'\n" << std::flush;
326			return;
327			}
328
329			std::vector<Glib::ustring> v;
330			for (int i = 0; i < macros.size(); ++i) {
331			const Serialization::RawData& rawData = const_cast<Serialization::Archive&>(macros[i]).rawData();
332			std::string s((const char*)&rawData[0], rawData.size());
333			v.push_back(s);
334			}
335
336			file.set_string_list(group, MACRO_LIST_NAME, v);
337
338			try {
339			#if HAS_GLIB_KEYFILE_SAVE_TO_FILE
340			bool ok = file.save_to_file(configFile());
341			#else
342			bool ok = saveToFile(&file, configFile());
343			#endif
344			if (!ok) {
345			std::cerr << "Failed saving gigedit config to '" << configFile() << "'\n" << std::flush;
346			} else {
347			//std::cout <<"gigedit CONFIG SAVED\n";
348			}
349			} catch (...) {
350			std::cerr << "Failed saving gigedit config to '" << configFile() << "'\n" << std::flush;
351			}
352
353			}