file writing/access for wavetablesfile

Author: hsetlik

plugin/include/Electrum/Identifiers.h

@@ -120,6 +120,14 @@ DECLARE_ID(patchAuthor)
 DECLARE_ID(patchDesc)
 DECLARE_ID(patchCategory)
 
+// wave metadata stuff
+DECLARE_ID(WAVE_INFO)
+DECLARE_ID(waveName)
+DECLARE_ID(wavePath)
+DECLARE_ID(waveAuthor)
+DECLARE_ID(waveCategory)
+DECLARE_ID(waveStringData)
+
 apvts::ParameterLayout getParameterLayout();
 }  // namespace ID
 

plugin/include/Electrum/Shared/FileSystem.h

@@ -5,7 +5,7 @@
 // the categories we'll divide the patch library into
 enum patch_categ_t { Bass, Lead, Keys, Pad, Other };
 
-// our file extensions
+enum wave_categ_t { Analog, Digital, User };
 
 // what the library/patch browser system needs to know
 // about a patch
@@ -20,28 +20,47 @@ struct patch_meta_t {
   static patch_meta_t fromValueTree(ValueTree& vt);
 };
 
+// same idea for wavetables
+struct wave_meta_t {
+  String name = "untitled";
+  String path;
+  String author;
+  int category;
+  //------------
+  // NOTE- the wave's serial data still needs to be attached
+  // to this ValueTree before saving the fine
+  static ValueTree toValueTree(const wave_meta_t& wave);
+  static wave_meta_t fromValueTree(ValueTree& vt);
+};
+
 /* Namespace for handling access to patches
  * on the file system
  * */
 namespace UserFiles {
 
 const juce::StringArray PatchCategStrings = {"Bass", "Lead", "Keys", "Pad",
                                              "Other"};
-
+const juce::StringArray WaveCategStrings = {"Analog", "Digital", "User"};
 #define NUM_PATCH_CATEGORIES 5
+#define NUM_WAVE_CATEGORIES 3
+
 const String patchFileExt = ".epf";
 const String waveFileExt = ".ewf";
 File getPatchesFolder();
 File getWavetablesFolder();
 // check whether a file is a valid Electrum patch
 bool isValidPatch(const File& file);
+// check for a valid wavetable
+bool isValidWave(const File& file);
 // call this with the 'state' member of ElectrumState
 // save a patch. returns success or failure
 bool attemptPatchSave(ValueTree& state);
+bool attemptWaveSave(const wave_meta_t& wave, const String& waveString);
 
 // this should run on startup to
 // save the list of patches on the system
 std::vector<patch_meta_t> getAvailiblePatches();
+std::vector<wave_meta_t> getAvailableWaves();
 }  // namespace UserFiles
 
 //====================================================
@@ -61,14 +80,15 @@ class ElectrumUserLib {
   struct Listener {
     Listener() {}
     virtual ~Listener() {}
-    virtual void patchWasSaved(patch_meta_t* patch) {}
+    virtual void patchWasSaved(patch_meta_t*) {}
   };
   ElectrumUserLib();
   // GUI should call this to check if
   // the user's entered metadata is legal
   bool validatePatchData(patch_meta_t* patch) const;
   int numPatches() const { return (int)patches.size(); }
   bool attemptPatchSave(apvts* tree, const patch_meta_t& patchData);
+  bool attemptWaveSave(const wave_meta_t& waveData, const String& waveString);
   patch_meta_t* getPatchAtIndex(int index);
   patch_meta_t* getPatch(const String& name);
 

plugin/source/FileSystem.cpp

@@ -22,6 +22,26 @@ patch_meta_t patch_meta_t::fromValueTree(ValueTree& vt) {
   return patch;
 }
 
+//--------------------------------------------------
+
+ValueTree wave_meta_t::toValueTree(const wave_meta_t& wave) {
+  ValueTree vt(ID::WAVE_INFO);
+  vt.setProperty(ID::waveName, wave.name, nullptr);
+  vt.setProperty(ID::wavePath, wave.path, nullptr);
+  vt.setProperty(ID::waveAuthor, wave.author, nullptr);
+  vt.setProperty(ID::waveCategory, wave.category, nullptr);
+
+  return vt;
+}
+
+wave_meta_t wave_meta_t::fromValueTree(ValueTree& vt) {
+  wave_meta_t wave;
+  wave.name = vt[ID::waveName];
+  wave.author = vt[ID::waveAuthor];
+  wave.path = vt[ID::wavePath];
+  wave.category = vt[ID::waveCategory];
+  return wave;
+}
 //===================================================
 namespace UserFiles {
 
@@ -32,7 +52,6 @@ File getPatchesFolder() {
           .getChildFile("Patches");
   if (!folder.exists() || !folder.isDirectory())
     folder.createDirectory();
-  DLog::log("Patches folder is at: " + String(folder.getFullPathName()));
   return folder;
 }
 
@@ -55,6 +74,14 @@ bool isValidPatch(const File& file) {
   return child.isValid();
 }
 
+bool isValidWave(const File& file) {
+  auto str = file.loadFileAsString();
+  ValueTree parent = ValueTree::fromXml(str);
+  if (!parent.isValid())
+    return false;
+  return parent.hasType(ID::PATCH_INFO);
+}
+
 bool attemptPatchSave(ValueTree& state) {
   auto patchTree = state.getChildWithName(ID::PATCH_INFO);
   if (!patchTree.isValid())
@@ -69,6 +96,17 @@ bool attemptPatchSave(ValueTree& state) {
   return file.replaceWithText(xml);
 }
 
+bool attemptWaveSave(const wave_meta_t& waveData, const String& waveString) {
+  wave_meta_t wd = waveData;
+  auto dir = getWavetablesFolder();
+  auto file = dir.getNonexistentChildFile(wd.name, waveFileExt, false);
+  wd.path = file.getRelativePathFrom(dir);
+  auto vt = wave_meta_t::toValueTree(wd);
+  vt.setProperty(ID::waveStringData, waveString, nullptr);
+  auto xml = vt.toXmlString();
+  return file.replaceWithText(xml);
+}
+
 std::vector<patch_meta_t> getAvailiblePatches() {
   std::vector<patch_meta_t> vec;
   auto patches = getPatchesFolder();
@@ -84,6 +122,20 @@ std::vector<patch_meta_t> getAvailiblePatches() {
   return vec;
 }
 
+std::vector<wave_meta_t> getAvailableWaves() {
+  std::vector<wave_meta_t> vec;
+  auto folder = getWavetablesFolder();
+  auto waves = folder.findChildFiles(File::findFiles, true);
+  for (auto& wave : waves) {
+    auto str = wave.loadFileAsString();
+    auto parent = ValueTree::fromXml(str);
+    if (parent.isValid()) {
+      vec.push_back(wave_meta_t::fromValueTree(parent));
+    }
+  }
+  return vec;
+}
+
 }  // namespace UserFiles
 //===================================================