PresetManager.cpp

Go to the documentation of this file.

namespace krotos
{
    const String PresetManager::m_cutoffVersion =
            "0.0.17"; // oldest preset version allowed to be loaded, version for new template system
    const String PresetManager::m_factoryPresetFolderName = "Factory";
    const String PresetManager::m_userPresetFolderName = "User";
    const String PresetManager::m_presetFileExtension = "ksp";
    const String PresetManager::m_initFileName = "init";
 
    bool PresetManager::checkPresetVersion(const File& presetFile, const String& pluginVersion,
                                           const bool showAlertWindow)
    {
        jassert(presetFile.hasFileExtension(m_presetFileExtension)); // is valid preset
 
        auto presetVersion = PresetManager::getPresetVersion(presetFile);
 
        // remove decimal points for comparison, ie 0.0.15 becomes 15
        auto presetVersionAsInt = presetVersion.removeCharacters(".").getIntValue();
        auto versionCutoffAsInt = m_cutoffVersion.removeCharacters(".").getIntValue();
 
        if (presetVersion.equalsIgnoreCase("") || presetVersionAsInt < versionCutoffAsInt)
        {
            if (showAlertWindow)
            {
                PresetManagerUI::alertPresetVersion(pluginVersion, presetVersion, m_cutoffVersion);
            }
 
            return false;
        }
 
        return true;
    }
 
    String PresetManager::getPresetVersion(const File& presetFile)
    {
        jassert(presetFile.hasFileExtension(m_presetFileExtension)); // is valid preset
 
        auto incomingPreset = PresetManager::getPresetFromFile(presetFile);
        auto valueTree = PresetManager::getValueTreeFromFile(incomingPreset.path);
 
        auto presetVersion = valueTree.getChildWithProperty(XmlType::Property::id, "PluginVersion");
        auto versionString = presetVersion.getProperty(XmlType::Property::value);
 
        return versionString;
    }
 
    String PresetManager::getPresetVersion(const ValueTree& state)
    {
        jassert(state.isValid());
 
        auto presetVersion = state.getChildWithProperty(XmlType::Property::id, "PluginVersion");
        auto versionString = presetVersion.getProperty(XmlType::Property::value);
 
        return versionString;
    }
 
    void PresetManager::writePresetVersion(ValueTree& state, const String& versionNumber)
    {
        jassert(state.isValid());
 
        ValueTree pluginData{XmlType::Tag::pluginData,
                             {{XmlType::Property::id, "PluginVersion"}, // preset saved with this version of the plugin
                              {XmlType::Property::value, versionNumber}}};
 
        state.appendChild(pluginData, nullptr);
    }
 
    void PresetManager::writeReformerVersion(ValueTree& state)
    {
        jassert(state.isValid());
 
        // iterate through the child trees of "state" and find the "KWIDGETDATA" tree with "id" equal to
        // "ReformerVersion"
        ValueTree kwidgetData;
        for (int i = 0; i < state.getNumChildren(); ++i)
        {
            ValueTree child = state.getChild(i);
            if (child.getType() == XmlType::Tag::kwidgetData &&
                child.getProperty(XmlType::Property::id) == "ReformerVersion")
            {
                kwidgetData = child;
                break; // found the "KWIDGETDATA" tree with the "ReformerVersion" ID, no need to continue searching
            }
        }
 
        if (kwidgetData.isValid())
        {
            // the "KWIDGETDATA" tree with "ReformerVersion" exists, so update its value
            kwidgetData.setProperty(XmlType::Property::value, Kwidget_Reformer::Version, nullptr);
        }
        else
        {
            // create a new "KWIDGETDATA" tree and add it to the state tree
            kwidgetData = ValueTree(XmlType::Tag::kwidgetData, {{XmlType::Property::id, "ReformerVersion"},
                                                                {XmlType::Property::value, Kwidget_Reformer::Version}});
 
            state.appendChild(kwidgetData, nullptr);
        }
    }
 
    void PresetManager::checkReformerVersion(ValueTree& state) { checkReformerVersionInternal(state); }
 
    void PresetManager::checkReformerVersion(File& preset)
    {
        auto state = getValueTreeFromFile(preset);
        checkReformerVersionInternal(state);
        PresetManager::writeValueTreeToFile(state, preset);
    }
 
    void PresetManager::checkReformerVersionInternal(ValueTree& state)
    {
        bool hasReformerKwidget = false;
 
        auto kwidgets = state.getChildWithName(XmlType::Tag::kwidgets);
 
        for (const auto& kwidget : kwidgets)
        {
            if (kwidget.getProperty(XmlType::Property::type).equals("Reformer"))
            {
                hasReformerKwidget = true;
                break;
            }
        }
 
        if (!hasReformerKwidget)
        {
            return;
        }
 
        auto incomingReformerVersion = PresetManager::getReformerVersion(state);
 
        // remove decimal points for comparison, i.e., 0.15 becomes 15
        auto incomingReformerVersionAsInt = incomingReformerVersion.removeCharacters(".").getIntValue();
        auto currentReformerVersionAsInt = Kwidget_Reformer::Version.removeCharacters(".").getIntValue();
 
        if ((incomingReformerVersion.equalsIgnoreCase("") ||
             incomingReformerVersionAsInt < currentReformerVersionAsInt) &&
            currentReformerVersionAsInt < 2)
        {
            writeReformerVersion(state);
 
            // TODO: any future serialization step(s) required can be called here!
        }
    }
 
    String PresetManager::getReformerVersion(ValueTree& state)
    {
        auto reformerVersion = state.getChildWithProperty(XmlType::Property::id, "ReformerVersion");
        auto versionString = reformerVersion.getProperty(XmlType::Property::value);
 
        return versionString;
    }
 
    ValueTree PresetManager::getValueTreeFromFile(const File& presetFile)
    {
        jassert(presetFile.hasFileExtension(m_presetFileExtension));
 
        XmlDocument doc(presetFile);
        auto xml = doc.getDocumentElement();
        return ValueTree::fromXml(*xml);
    }
 
    void PresetManager::writeValueTreeToFile(const ValueTree& valueTree, const File& outputFile)
    {
        jassert(outputFile.hasFileExtension(m_presetFileExtension));
 
        auto xml = valueTree.createXml();
        xml->writeTo(outputFile);
    }
 
    PresetManager::Preset PresetManager::getPresetFromFile(const File& file)
    {
        jassert(file.hasFileExtension(m_presetFileExtension));
 
        auto name = file.getFileNameWithoutExtension();
        return {name, file};
    }
 
    File PresetManager::getFactoryTemplateDirectory()
    {
#ifdef JUCE_MAC
        return File::getSpecialLocation(File::commonApplicationDataDirectory).getFullPathName() +
               "/Application Support/Krotos/" + JucePlugin_Name + "/UITemplates/";
#else
        return File("C:\\ProgramData\\Krotos\\" JucePlugin_Name "\\UITemplates\\");
#endif
    }
 
    File PresetManager::getUserTemplateDirectory()
    {
#ifdef JUCE_MAC
        return File::getSpecialLocation(File::userApplicationDataDirectory).getFullPathName() +
               "/Application Support/Krotos/" + JucePlugin_Name + "/UITemplates/";
#else
        return File::getSpecialLocation(File::userApplicationDataDirectory).getFullPathName() + "\\Krotos\\" +
               JucePlugin_Name + "\\UITemplates\\";
#endif
    }
 
    File PresetManager::getFactoryPresetDirectory()
    {
#ifdef JUCE_MAC
        return File::getSpecialLocation(File::commonApplicationDataDirectory).getFullPathName() +
               "/Application Support/Krotos/" + JucePlugin_Name + "/Presets/main/";
#else
        return File::getSpecialLocation(File::commonApplicationDataDirectory).getFullPathName() + "\\Krotos\\" +
               JucePlugin_Name + "\\Presets\\main";
#endif
    }
 
    File PresetManager::getUserPresetDirectory()
    {
#ifdef JUCE_MAC
        return File::getSpecialLocation(File::userApplicationDataDirectory).getFullPathName() +
               "/Application Support/Krotos/" + JucePlugin_Name + "/Presets/main/";
#else
        return File::getSpecialLocation(File::userApplicationDataDirectory).getFullPathName() + "\\Krotos\\" +
               JucePlugin_Name + "\\Presets\\main\\";
#endif
    }
 
    File PresetManager::getInitPresetFile()
    {
        File initFile = File(getFactoryPresetDirectory().getFullPathName() + File::getSeparatorString() +
                             m_initFileName + "." + m_presetFileExtension);
 
        if (!initFile.exists())
        {
            throw PresetException(/*what*/ "Error: Cannot find init.ksp",
                                  /*when*/ "On load of init preset");
        }
 
        if (!initFile.hasFileExtension(m_presetFileExtension))
        {
            throw PresetException(/*what*/ "Error: Invalid init file",
                                  /*when*/ "On load of init preset");
        }
        return initFile;
    }
 
    PresetManager::PresetManager()
    {
// do not try to init resources/directories when running unit tests!
#ifndef UNIT_TEST
        PluginHostType host;
 
        if (!host.isPluginval()) // pluginval currently not compatible with state loading
        {
            try
            {
                initializePresetDirectories();
            }
            catch (PresetException& ex)
            {
                std::cout << ex.what() << std::endl;
            }
        }
#endif
    }
 
    const PresetManager::Preset& PresetManager::getCurrentPreset() const { return m_currentPreset; }
 
    void PresetManager::setCurrentPreset(const File& presetFile)
    {
        jassert(presetFile.hasFileExtension(m_presetFileExtension));
        m_currentPreset = getPresetFromFile(presetFile);
 
        if (presetChanged)
            MessageManager::callAsync([=] { presetChanged(getValueTreeFromFile(m_currentPreset.path)); });
    }
 
    PopupMenu PresetManager::getCurrentPopupMenu()
    {
        PopupMenu menu;
 
        menu.addSubMenu(m_factoryPresetFolderName, getPopupMenuFromDirectory(getFactoryPresetDirectory()));
        menu.addSubMenu(m_userPresetFolderName, getPopupMenuFromDirectory(getUserPresetDirectory()));
 
        return menu;
    }
 
    void PresetManager::initializePresetDirectories()
    {
        auto userPresetPath = getUserPresetDirectory();
        auto factoryPresetPath = getFactoryPresetDirectory();
 
        if (userPresetPath.isDirectory() != true)
        {
            if (userPresetPath.createDirectory() != Result::ok())
            {
                throw PresetException(/*what*/ "Error: Cannot find or create user preset directory",
                                      /*when*/ "On init of user preset dir");
            }
        }
 
        if (factoryPresetPath.isDirectory() != true)
        {
            throw PresetException(/*what*/ "Error: Factory preset folder does not exist",
                                  /*when*/ "On init of factory preset dir");
        }
 
        auto userTemplatePath = getUserTemplateDirectory();
        auto factoryTemplatePath = getFactoryTemplateDirectory();
 
        if (userTemplatePath.isDirectory() != true)
        {
            if (userTemplatePath.createDirectory() != Result::ok())
            {
                throw PresetException(/*what*/ "Error: Cannot find or create user template directory",
                                      /*when*/ "On init of user template dir");
            }
        }
 
        if (factoryTemplatePath.isDirectory() != true)
        {
            throw PresetException(/*what*/ "Error: Factory template folder does not exist",
                                  /*when*/ "On init of factory template dir");
        }
    }
 
    PopupMenu PresetManager::getPopupMenuFromDirectory(const File& presetDirectory)
    {
        PopupMenu menu;
 
        auto files = presetDirectory.findChildFiles(File::findFilesAndDirectories, false, "*");
        for (auto& file : files)
        {
            auto name = file.getFileNameWithoutExtension();
 
            if (file.hasFileExtension(m_presetFileExtension))
                menu.addItem(name, [=]() { setCurrentPreset(file); });
            else if (file.isDirectory())
                menu.addSubMenu(name, getPopupMenuFromDirectory(file));
        }
 
        return menu;
    }
 
    char const* PresetException::what() const noexcept { return runtime_error::what(); }
 
    String PresetException::when() const { return m_whenDidItHappen; }
} // namespace krotos