Move read volumes logic to dataloadermodule and dir-is-read

modules/dataloader/dataloadermodule.cpp

@@ -35,9 +35,42 @@ namespace {
     constexpr const char* _loggerCat = "DataLoaderModule";
 }
 
+namespace {
+    static const openspace::properties::Property::PropertyInfo ShowInternalVolumesInfo = {
+        "ShowInternalVolumesTrigger",
+        "Trigger load volume data files",
+        "If this property is triggered it will call the function to load and show volume data"
+    };
+
+    static const openspace::properties::Property::PropertyInfo VolumesInfo = {
+        "Volumes",
+        "List of volume items stored internally and ready to load",
+        "This list contains names of volume data files converted from the CDF format"
+    };
+
+    static const openspace::properties::Property::PropertyInfo FieldlinesInfo = {
+        "Fieldlines",
+        "List of fieldline items stored internally and ready to load",
+        "This list contains names of fieldline data files converted from the CDF format"
+    };
+}
+
 namespace openspace {
 
-DataLoaderModule::DataLoaderModule() : OpenSpaceModule(Name) {}
+DataLoaderModule::DataLoaderModule() 
+    : OpenSpaceModule(Name)
+    , _showInternalVolumesTrigger(ShowInternalVolumesInfo)
+    , _volumeDataItems(VolumesInfo)
+{
+    _showInternalVolumesTrigger.onChange([this](){
+        // showInternalDataType(DataTypes.volume);
+        validateDataDirectory();
+        _loader->createInternalDataItemProperties();
+    });
+
+    addProperty(_volumeDataItems);
+    addProperty(_showInternalVolumesTrigger);
+}
 
 DataLoaderModule::~DataLoaderModule() {}
 
@@ -56,7 +89,9 @@ void DataLoaderModule::setDataDirectoryRead(bool isRead) {
 }
 
 void DataLoaderModule::validateDataDirectory() {
-    if(!_dataDirectoryIsRead) {
+    if(_dataDirectoryIsRead == false) {
+
+        // TODO: generalize
         _reader->readVolumeDataItems();
     }
 }

modules/dataloader/dataloadermodule.h

@@ -26,6 +26,9 @@
 #define __OPENSPACE_MODULE_DATALOADER___DATALOADERMODULE___H__
 
 #include <openspace/util/openspacemodule.h>
+#include <openspace/properties/property.h> // do we need this
+#include <openspace/properties/stringlistproperty.h>
+#include <openspace/properties/triggerproperty.h>
 
 namespace openspace::dataloader {
     class Reader;
@@ -34,6 +37,10 @@ namespace openspace::dataloader {
 
 namespace openspace {
 
+enum DataTypes {
+    volume
+};
+
 /**
  * Reference reader, writer, loader
  * Have functions like getDataItemList that gets list from reader
@@ -57,12 +64,13 @@ public:
     dataloader::Loader* loader();
 
 private:
-    bool _dataDirectoryIsRead = true;
+    bool _dataDirectoryIsRead = false;
 
     std::unique_ptr<dataloader::Reader> _reader;
     std::unique_ptr<dataloader::Loader> _loader;
 
-    std::vector<std::string> _volumeDataItems;
+    properties::StringListProperty _volumeDataItems;
+    properties::TriggerProperty _showInternalVolumesTrigger;
 };
 
 } // namespace openspace

modules/dataloader/operators/loader.cpp

@@ -23,6 +23,7 @@
  ****************************************************************************************/
 
 #include <iostream>
+#include <string>
 #include <modules/dataloader/operators/loader.h>
 #include <modules/dataloader/dataloadermodule.h>
 #include <ghoul/logging/logmanager.h>
@@ -129,19 +130,25 @@ void Loader::uploadData() {
 ;
 }
 
-void Loader::addInternalDataItemProperties() {
+void Loader::createInternalDataItemProperties() {
     getModule()->validateDataDirectory();
     std::vector<std::string> volumeItems = getModule()->volumeDataItems();
 
+    LDEBUG("volume items vec size " + std::to_string(volumeItems.size()));
+
+    int step = 0;
     for (auto item : volumeItems) {
+        const std::string dirLeaf = openspace::dataloader::helpers::getDirLeaf(item);
         static const openspace::properties::Property::PropertyInfo info = {
-            "ItemTrigger_" + openspace::dataloader::helpers::getDirLeaf(item),
-            "",
+            "ItemTrigger_" + dirLeaf + std::to_string(step),
+            dirLeaf + std::to_string(step),
             ""
         };
 
+        step++;
+
         // Initialize trigger property with data item name (are they unique?)
-        properties::TriggerProperty volumeItemTrigger(info);
+        auto volumeItemTrigger = properties::TriggerProperty(info);
 
         // Set onChange method to call loadDataItem with the path as argument
         volumeItemTrigger.onChange([this](){
@@ -149,6 +156,7 @@ void Loader::addInternalDataItemProperties() {
         });
 
         addProperty(volumeItemTrigger);
+        LDEBUG("Added property " + dirLeaf);
     }
 }
 

modules/dataloader/operators/loader.h

@@ -41,8 +41,10 @@ class Loader : public PropertyOwner, public Operator {
     // Select file data path
     void uploadData();
 
-    // Add trigger properties for data items in internal directory
-    void addInternalDataItemProperties();
+    /**
+     * Creates and adds trigger properties for data items in the internal directory
+     */
+    void createInternalDataItemProperties();
 
     // Add one data item trigger property
     void addDataItemProperty();

modules/dataloader/operators/operator.h

@@ -1,7 +1,6 @@
 
 #ifndef __OPENSPACE_MODULE_DATALOADER___OPERATOR___H__
 #define __OPENSPACE_MODULE_DATALOADER___OPERATOR___H__
-// #include <modules/dataloader/dataloadermodule.h>
 
 namespace openspace {
 

modules/dataloader/operators/reader.cpp

@@ -44,50 +44,36 @@ namespace {
     constexpr const char* _loggerCat = "Reader";
 } 
 
-namespace {
-    static const openspace::properties::Property::PropertyInfo VolumesInfo = {
-        "Volumes",
-        "List of volume items stored internally and ready to load",
-        "This list contains names of volume data files converted from the CDF format"
-    };
+// namespace {
+//     static const openspace::properties::Property::PropertyInfo ReadVolumesTriggerInfo = {
+//         "ReadVolumesTrigger",
+//         "Trigger load volume data files",
+//         "If this property is triggered it will call the function to load volume data"
+//     };
 
-    static const openspace::properties::Property::PropertyInfo FieldlinesInfo = {
-        "Fieldlines",
-        "List of fieldline items stored internally and ready to load",
-        "This list contains names of fieldline data files converted from the CDF format"
-    };
-
-    static const openspace::properties::Property::PropertyInfo ReadVolumesTriggerInfo = {
-        "ReadVolumesTrigger",
-        "Trigger load volume data files",
-        "If this property is triggered it will call the function to load volume data"
-    };
-
-    static const openspace::properties::Property::PropertyInfo ReadFieldlinesTriggerInfo = {
-        "ReadFieldlinesTrigger",
-        "Trigger load fieldline data files",
-        "If this property is triggered it will call the function to load fieldline data"
-    };
-}
+//     static const openspace::properties::Property::PropertyInfo ReadFieldlinesTriggerInfo = {
+//         "ReadFieldlinesTrigger",
+//         "Trigger load fieldline data files",
+//         "If this property is triggered it will call the function to load fieldline data"
+//     };
+// }
 
 namespace openspace::dataloader {
 
 Reader::Reader()
     : PropertyOwner({ "Reader" })
-    , _volumeItems(VolumesInfo) 
-    , _readVolumesTrigger(ReadVolumesTriggerInfo) 
+    // , _readVolumesTrigger(ReadVolumesTriggerInfo)
 {
     _topDir = ghoul::filesystem::Directory(
       "${DATA}/.internal",
       ghoul::filesystem::Directory::RawPath::No
     );
 
-    _readVolumesTrigger.onChange([this](){
-        readVolumeDataItems();
-    });
+    // _readVolumesTrigger.onChange([this](){
+    //     readVolumeDataItems();
+    // });
 
-    addProperty(_volumeItems);
-    addProperty(_readVolumesTrigger);
+    // addProperty(_readVolumesTrigger);
 }
 
 void Reader::readVolumeDataItems() {
@@ -97,12 +83,12 @@ void Reader::readVolumeDataItems() {
         "volumes_from_cdf" 
     );
 
-    _volumeItems = volumeDir.readDirectories(
+    std::vector volumeItems = volumeDir.readDirectories(
       ghoul::filesystem::Directory::Recursive::No,
       ghoul::filesystem::Directory::Sort::Yes
     );
 
-    getModule()->setVolumeDataItems(_volumeItems);
+    getModule()->setVolumeDataItems(volumeItems);
     getModule()->setDataDirectoryRead(true);
 
     // for (auto el : volumeItems) {

modules/dataloader/operators/reader.h

@@ -28,7 +28,6 @@
 #include <modules/dataloader/operators/operator.h>
 #include <openspace/properties/propertyowner.h>
 #include <openspace/properties/property.h> // do we need this
-#include <openspace/properties/stringlistproperty.h>
 #include <openspace/properties/triggerproperty.h>
 #include <ghoul/filesystem/directory.h>
 
@@ -43,10 +42,9 @@ class Reader : public PropertyOwner, public Operator {
     void readVolumeDataItems();
 
   private:
-    properties::StringListProperty _volumeItems;
-    properties::TriggerProperty _readVolumesTrigger;
-    
     ghoul::filesystem::Directory _topDir;
+
+    // properties::TriggerProperty _readVolumesTrigger;
 };
 
 }

modules/webgui/web/src/components/DataLoader/DataLoader.jsx

@@ -46,7 +46,7 @@ class DataLoader extends Component {
   }
 
   getUriForDataToLoad(dataType) {
-    let uri = 'Modules.DataLoader.Reader.';
+    let uri = 'Modules.DataLoader.';
 
     for (const type of this.dataTypesToLoad) {
       if (dataType == type) {
@@ -58,7 +58,7 @@ class DataLoader extends Component {
   }
 
   triggerDataToLoad(dataType) {
-    DataManager.trigger(`Modules.DataLoader.Reader.Read${dataType}Trigger`)
+    DataManager.trigger(`Modules.DataLoader.ShowInternal${dataType}Trigger`)
   }
 
   handleDataTypeList(data) {