gearmulator

commit 4e6cd6dc59719b5326ebe79a69e091cae381f3fb
parent 95feb5814ef0d112338b4657793b6726554a1209
Author: dsp56300 <dsp56300@users.noreply.github.com>
Date:   Sun,  5 May 2024 15:49:32 +0200

add more save options to "save patch" buttons: allow to save to new user bank / allow to save to any existing user bank

Diffstat:
M
source/jucePluginEditorLib/patchmanager/patchmanager.cpp
 | 
41
+++++++++++++++++++++++++++++++++++++++--
M
source/jucePluginLib/patchdb/db.cpp
 | 
36
+++++++++++++++++++++++++++++-------
M
source/jucePluginLib/patchdb/db.h
 | 
7
+++++--

3 files changed, 73 insertions(+), 11 deletions(-)
diff --git a/source/jucePluginEditorLib/patchmanager/patchmanager.cpp b/source/jucePluginEditorLib/patchmanager/patchmanager.cpp
@@ -336,19 +336,56 @@ namespace jucePluginEditorLib::patchManager
 			}
 		}
 
+		auto createSaveToUserBankEntry = [this, &countAdded, _part, &_menu](const pluginLib::patchDB::DataSourceNodePtr& _ds)
+		{
+			++countAdded;
+			_menu.addItem("Add to user bank '" + _ds->name + "'", true, false, [this, _ds, _part]
+			{
+				const auto newPatch = requestPatchForPart(_part);
+
+				if(!newPatch)
+					return;
+
+				copyPatchesToLocalStorage(_ds, {newPatch}, static_cast<int>(_part));
+			});
+		};
+
 		if(const auto ds = getSelectedDataSource())
 		{
 			if(ds->type == pluginLib::patchDB::SourceType::LocalStorage)
+				createSaveToUserBankEntry(ds);
+		}
+
+		if(!countAdded)
+		{
+			const auto existingLocalDS = getDataSourcesOfSourceType(pluginLib::patchDB::SourceType::LocalStorage);
+
+			if(!existingLocalDS.empty())
+			{
+				for (const auto& ds : existingLocalDS)
+					createSaveToUserBankEntry(ds);
+			}
+			else
 			{
 				++countAdded;
-				_menu.addItem("Add to user bank '" + ds->name + "'", true, false, [this, ds, _part]
+				_menu.addItem("Create new user bank and add patch", true, false, [this, _part]
 				{
 					const auto newPatch = requestPatchForPart(_part);
 
 					if(!newPatch)
 						return;
 
-					copyPatchesToLocalStorage(ds, {newPatch}, static_cast<int>(_part));
+					pluginLib::patchDB::DataSource ds;
+
+					ds.name = "User Bank";
+					ds.type = pluginLib::patchDB::SourceType::LocalStorage;
+					ds.origin = pluginLib::patchDB::DataSourceOrigin::Manual;
+					ds.timestamp = std::chrono::system_clock::now();
+					addDataSource(ds, false, [newPatch, _part, this](const bool _success, const std::shared_ptr<pluginLib::patchDB::DataSourceNode>& _ds)
+					{
+						if(_success)
+							copyPatchesToLocalStorage(_ds, {newPatch}, static_cast<int>(_part));
+					});
 				});
 			}
 		}
diff --git a/source/jucePluginLib/patchdb/db.cpp b/source/jucePluginLib/patchdb/db.cpp
@@ -55,9 +55,9 @@ namespace pluginLib::patchDB
 			saveCache();
 	}
 
-	DataSourceNodePtr DB::addDataSource(const DataSource& _ds)
+	DataSourceNodePtr DB::addDataSource(const DataSource& _ds, const DataSourceLoadedCallback& _callback)
 	{
-		return addDataSource(_ds, true);
+		return addDataSource(_ds, true, _callback);
 	}
 
 	bool DB::writePatchesToFile(const juce::File& _file, const std::vector<PatchPtr>& _patches)
@@ -91,19 +91,25 @@ namespace pluginLib::patchDB
 		_mods->updateCache();
 	}
 
-	DataSourceNodePtr DB::addDataSource(const DataSource& _ds, const bool _save)
+	DataSourceNodePtr DB::addDataSource(const DataSource& _ds, const bool _save, const DataSourceLoadedCallback& _callback)
 	{
 		const auto needsSave = _save && _ds.origin == DataSourceOrigin::Manual && _ds.type != SourceType::Rom;
 
 		auto ds = std::make_shared<DataSourceNode>(_ds);
 
-		runOnLoaderThread([this, ds, needsSave]
+		runOnLoaderThread([this, ds, needsSave, _callback]
+		{
+			addDataSource(ds);
+
+			runOnUiThread([ds, _callback]
 			{
-				addDataSource(ds);
-				if(needsSave)
-					saveJson();
+				_callback(true, ds);
 			});
 
+			if(needsSave)
+				saveJson();
+		});
+
 		return ds;
 	}
 
@@ -251,6 +257,22 @@ namespace pluginLib::patchDB
 		return it->second;
 	}
 
+	std::set<DataSourceNodePtr> DB::getDataSourcesOfSourceType(const SourceType _type)
+	{
+		std::set<DataSourceNodePtr> results;
+
+		{
+			std::shared_lock lockDS(m_dataSourcesMutex);
+			for (const auto& ds : m_dataSources)
+			{
+				if(ds.second->type == _type)
+					results.insert(ds.second);
+			}
+		}
+
+		return results;
+	}
+
 	bool DB::setTagColor(const TagType _type, const Tag& _tag, const Color _color)
 	{
 		std::shared_lock lock(m_patchesMutex);
diff --git a/source/jucePluginLib/patchdb/db.h b/source/jucePluginLib/patchdb/db.h
@@ -23,16 +23,19 @@ namespace pluginLib::patchDB
 	class DB
 	{
 	public:
+		using DataSourceLoadedCallback = std::function<void(bool,DataSourceNodePtr)>;
+
 		DB(juce::File _dir);
 		virtual ~DB();
 
 		void uiProcess(Dirty& _dirty);
 
-		DataSourceNodePtr addDataSource(const DataSource& _ds);
+		DataSourceNodePtr addDataSource(const DataSource& _ds, const DataSourceLoadedCallback& = [](bool, std::shared_ptr<DataSourceNode>) {});
 		void removeDataSource(const DataSource& _ds, bool _save = true);
 		void refreshDataSource(const DataSourceNodePtr& _ds);
 		void renameDataSource(const DataSourceNodePtr& _ds, const std::string& _newName);
 		DataSourceNodePtr getDataSource(const DataSource& _ds);
+		std::set<DataSourceNodePtr> getDataSourcesOfSourceType(SourceType _type);
 
 		void getDataSources(std::vector<DataSourceNodePtr>& _dataSources)
 		{
@@ -80,7 +83,7 @@ namespace pluginLib::patchDB
 		static void assign(const PatchPtr& _patch, const PatchModificationsPtr& _mods);
 
 	protected:
-		DataSourceNodePtr addDataSource(const DataSource& _ds, bool _save);
+		DataSourceNodePtr addDataSource(const DataSource& _ds, bool _save, const DataSourceLoadedCallback& = [](bool , std::shared_ptr<DataSourceNode>) {});
 
 	public:
 		virtual bool loadData(DataList& _results, const DataSourceNodePtr& _ds);