Fix parameter linking

Author: medengineer

Source/Processors/FileReader/FileReader.cpp

@@ -88,16 +88,21 @@ void FileReader::registerParameters()
     addTimeParameter (Parameter::PROCESSOR_SCOPE, "start_time", "Start Time", "Time to start playback", "00:00:00.000");
     addTimeParameter (Parameter::PROCESSOR_SCOPE, "end_time", "Stop Time", "Time to end playback", "00:00:04.999");
 
-    /* Link parameters -- start_time and end_time valid range depends on selected_file */
-    //linkParameters (getParameter ("selected_file"), getParameter ("start_time"), getParameter ("end_time"));
+    /* Link parameters */
+    PathParameter* fileParam = static_cast<PathParameter*>(getParameter("selected_file"));
+    CategoricalParameter* streamParam = static_cast<CategoricalParameter*>(getParameter("active_stream"));
+    TimeParameter* startTimeParam = static_cast<TimeParameter*>(getParameter("start_time"));
+    TimeParameter* endTimeParam = static_cast<TimeParameter*>(getParameter("end_time"));
+
+    Array<Parameter*> linkedParams = {streamParam, startTimeParam, endTimeParam};
+    fileParam->linkParameters(linkedParams);
 }
 
 void FileReader::parameterValueChanged (Parameter* p)
 {
     if (p->getName() == "selected_file")
     {
         setFile (p->getValue(), false);
-        //handled by handleLinkedParameterChange
     }
     else if (p->getName() == "active_stream")
     {
@@ -111,19 +116,25 @@ void FileReader::parameterValueChanged (Parameter* p)
 
         TimeParameter* endTime = static_cast<TimeParameter*> (getParameter ("end_time"));
         endTime->getTimeValue()->setMinTimeInMilliseconds (samplesToMilliseconds (startSample + 1));
+        
+        setPlaybackStart(startSample);
     }
     else if (p->getName() == "end_time")
     {
         TimeParameter* tp = static_cast<TimeParameter*> (p);
         stopSample = millisecondsToSamples (tp->getTimeValue()->getTimeInMilliseconds());
+        
         if (input != nullptr && stopSample == startSample)
         {
             stopSample = input->getActiveNumSamples();
             String newTime = TimeParameter::TimeValue (1000 * stopSample / input->getActiveSampleRate()).toString();
             p->setNextValue (newTime, false);
         }
+        
         TimeParameter* startTime = static_cast<TimeParameter*> (getParameter ("start_time"));
         startTime->getTimeValue()->setMaxTimeInMilliseconds (samplesToMilliseconds (stopSample - 1));
+        
+        setPlaybackStop(stopSample);
     }
 
     currentNumTotalSamples = stopSample - startSample;
@@ -138,7 +149,6 @@ void FileReader::parameterValueChanged (Parameter* p)
             getScrubberInterface()->update();
         }
     }
-
 }
 
 void FileReader::handleLinkedParameterChange (Parameter* param, var newValue)
@@ -183,6 +193,9 @@ void FileReader::initialize (bool signalChainIsLoading)
     setPlaybackStop (input->getActiveNumSamples());
     setCurrentSample (0);
 
+    TimeParameter* startTime = static_cast<TimeParameter*> (getParameter ("start_time"));
+    startTime->getTimeValue()->setMaxTimeInMilliseconds (samplesToMilliseconds (input->getActiveNumSamples() - 1));
+
     TimeParameter* endTime = static_cast<TimeParameter*> (getParameter ("end_time"));
     endTime->getTimeValue()->setMaxTimeInMilliseconds (samplesToMilliseconds (input->getActiveNumSamples()));
 }

Source/Processors/FileReader/FileReaderActions.cpp

@@ -44,7 +44,7 @@ bool SelectFile::perform()
     TimeParameter* startTime = static_cast<TimeParameter*> (Parameter::parameterMap[startTimeKey]);
     TimeParameter* endTime = static_cast<TimeParameter*> (Parameter::parameterMap[endTimeKey]);
 
-    // Set the new path
+    // Set the new path - this will trigger the linked parameter changes
     pathParam->setNextValue (newPath, false);
 
     // Load the new file
@@ -66,12 +66,12 @@ bool SelectFile::perform()
     // Set the start time to the beginning of the file
     startTime->getTimeValue()->setTimeFromMilliseconds (0);
     startTime->setNextValue (startTime->getTimeValue()->toString(), false);
-    processor->setPlaybackStart (originalStartTimeInMs * processor->getCurrentSampleRate() / 1000);
+    processor->setPlaybackStart (0);
 
     // Set the end time to the end of the file
     endTime->getTimeValue()->setTimeFromMilliseconds (int(fileDurationMs));
     endTime->setNextValue (endTime->getTimeValue()->toString(), false);
-    processor->setPlaybackStop (originalEndTimeInMs * processor->getCurrentSampleRate() / 1000);
+    processor->setPlaybackStop (fileDuration);
 
     // Register the action in case the processor is deleted
     processor->registerUndoableAction (processor->getNodeId(), this);
@@ -81,11 +81,13 @@ bool SelectFile::perform()
 
 bool SelectFile::undo()
 {
+    // Get pointers to parameters
     PathParameter* pathParam = static_cast<PathParameter*> (Parameter::parameterMap[pathKey]);
+    CategoricalParameter* activeStream = static_cast<CategoricalParameter*> (Parameter::parameterMap[streamKey]);
     TimeParameter* startTime = static_cast<TimeParameter*> (Parameter::parameterMap[startTimeKey]);
     TimeParameter* endTime = static_cast<TimeParameter*> (Parameter::parameterMap[endTimeKey]);
 
-    // Set the path to the original path
+    // Set the path to the original path - this will trigger the linked parameter changes
     pathParam->setNextValue (originalPath, false);
 
     // Load the original file

Source/Processors/Parameter/Parameter.cpp

@@ -137,12 +137,6 @@ void Parameter::setOwner (ParameterOwner* parameterOwner_)
     Parameter::registerParameter (this);
 }
 
-void Parameter::linkParameter (Parameter* child1, Parameter* child2)
-{
-    linkedParameters.add (child1);
-    linkedParameters.add (child2);
-}
-
 void Parameter::setEnabled (bool enabled)
 {
     isEnabledFlag = enabled;
@@ -227,38 +221,48 @@ Parameter::ChangeValue::ChangeValue (std::string key_, var newValue_)
     : key (key_), newValue (newValue_)
 {
     Parameter* p = Parameter::parameterMap[key_];
-
-    originalValue = p->currentValue;
+    if (p != nullptr)
+    {
+        originalValue = p->getValue();
+        
+        // Store linked parameter states before the change
+        if (p->isLinked())
+        {
+            p->storeLinkedStates();
+        }
+    }
 }
 
 bool Parameter::ChangeValue::perform()
 {
     Parameter* p = Parameter::parameterMap[key];
-
-    if (! p->isEnabled() || p->currentValue == newValue)
+    if (p == nullptr || !p->isEnabled() || p->getValue() == newValue)
         return false;
 
-    p->newValue = newValue;
-    p->getOwner()->parameterChangeRequest (p);
-
+    p->setNextValue(newValue, false);
     p->valueChanged();
 
-    if (p->currentValue == p->previousValue)
-        return false;
-    else
+    // Compare current value with new value to check if the change was effective
+    if (p->getValue() == newValue)
         return true;
+    else
+        return false;
 }
 
 bool Parameter::ChangeValue::undo()
 {
     Parameter* p = Parameter::parameterMap[key];
+    if (p == nullptr)
+        return false;
 
-    p->newValue = originalValue;
-    p->getOwner()->parameterChangeRequest (p);
-
+    p->setNextValue(originalValue, false);
     p->valueChanged();
 
-    //p->logValueChange();
+    // Restore linked parameter states
+    if (p->isLinked())
+    {
+        p->restoreLinkedStates();
+    }
 
     return true;
 }
@@ -1448,6 +1452,7 @@ void TimeParameter::setNextValue (var newValue_, bool undoable)
         {
             currentValue = newValue;
             timeValue->setTimeFromString (currentValue.toString());
+            getOwner()->parameterChangeRequest(this);
             valueChanged();
         }
     }
@@ -1468,32 +1473,49 @@ TimeParameter::ChangeValue::ChangeValue (std::string key_, var newValue_)
     : key (key_), newValue (newValue_)
 {
     Parameter* p = Parameter::parameterMap[key_];
-    originalValue = p->currentValue;
+    if (p != nullptr)
+    {
+        originalValue = p->getValue();
+        
+        // Store linked parameter states before the change
+        if (p->isLinked())
+        {
+            p->storeLinkedStates();
+        }
+    }
 }
 
 bool TimeParameter::ChangeValue::perform()
 {
-    TimeParameter* p = (TimeParameter*) Parameter::parameterMap[key];
-    p->getTimeValue()->setTimeFromString (newValue.toString());
-
-    p->newValue = newValue;
-    p->getOwner()->parameterChangeRequest (p);
+    Parameter* p = Parameter::parameterMap[key];
+    if (p == nullptr || !p->isEnabled() || p->getValue() == newValue)
+        return false;
 
+    p->setNextValue(newValue, false);
     p->valueChanged();
 
-    return true;
+    // Compare current value with new value to check if the change was effective
+    if (p->getValue() == newValue)
+        return true;
+    else
+        return false;
 }
 
 bool TimeParameter::ChangeValue::undo()
 {
-    TimeParameter* p = (TimeParameter*) Parameter::parameterMap[key];
-    p->getTimeValue()->setTimeFromString (originalValue.toString());
-
-    p->newValue = originalValue;
-    p->getOwner()->parameterChangeRequest (p);
+    Parameter* p = Parameter::parameterMap[key];
+    if (p == nullptr)
+        return false;
 
+    p->setNextValue(originalValue, false);
     p->valueChanged();
 
+    // Restore linked parameter states
+    if (p->isLinked())
+    {
+        p->restoreLinkedStates();
+    }
+
     return true;
 }
 

Source/Processors/Parameter/Parameter.h

@@ -336,11 +336,68 @@ class PLUGIN_API Parameter
     /** Broadcasts a value change to all listeners */
     void valueChanged();
 
-    /** Links this parameter to another parameter */
-    void linkParameter (Parameter* first, Parameter* second = nullptr);
+    /** Class to store the state of a linked parameter */
+    class LinkedParameterState
+    {
+    public:
+        LinkedParameterState(Parameter* param, var value) 
+            : parameter(param), value(value) {}
+        
+        Parameter* parameter;
+        var value;
+    };
+
+    /** Links this parameter to another parameter and stores its state */
+    void linkParameter(Parameter* param) 
+    { 
+        if (param != nullptr && !linkedParameters.contains(param))
+        {
+            linkedParameters.add(param);
+        }
+    }
+
+    /** Links this parameter to an array of parameters */
+    void linkParameters(const Array<Parameter*>& params)
+    {
+        for (auto* param : params)
+        {
+            if (param != nullptr)
+            {
+                linkParameter(param);
+            }
+        }
+    }
 
     /** Returns true if this parameter is linked to another parameter */
-    bool isLinked() { return linkedParameters.size() > 0; }
+    bool isLinked() const { return linkedParameters.size() > 0; }
+
+    /** Stores the current state of all linked parameters */
+    void storeLinkedStates()
+    {
+        linkedParameterStates.clear();
+        for (auto* param : linkedParameters)
+        {
+            if (param != nullptr)
+            {
+                linkedParameterStates.add(new LinkedParameterState(param, param->getValue()));
+            }
+        }
+    }
+
+    /** Restores the stored state of all linked parameters */
+    void restoreLinkedStates()
+    {
+        for (auto* state : linkedParameterStates)
+        {
+            if (state != nullptr && state->parameter != nullptr)
+            {
+                state->parameter->setNextValue(state->value, false);
+            }
+        }
+    }
+
+    /** Returns the array of linked parameters */
+    const Array<Parameter*>& getLinkedParameters() const { return linkedParameters; }
 
     /** Makes it possible to undo value changes */
     class PLUGIN_API ChangeValue : public UndoableAction
@@ -363,7 +420,6 @@ class PLUGIN_API Parameter
 
     private:
         std::string key;
-
         var originalValue;
         var newValue;
         bool logChange = false;
@@ -373,27 +429,23 @@ class PLUGIN_API Parameter
 
 protected:
     ParameterOwner* parameterOwner;
-
     var newValue;
     var previousValue;
-
     var defaultValue;
+    Array<Listener*> parameterListeners;
+    Array<Parameter*> linkedParameters;
+    Array<LinkedParameterState*> linkedParameterStates;
 
 private:
     std::string m_identifier;
-
     ParameterType m_parameterType;
     ParameterScope m_parameterScope;
     ParameterEditorType m_editorType;
     String m_name;
     String m_displayName;
     String m_description;
-
     bool m_deactivateDuringAcquisition;
     bool isEnabledFlag;
-
-    Array<Listener*> parameterListeners;
-    Array<Parameter*> linkedParameters;
 };
 
 /** 

Source/Processors/Parameter/ParameterCollection.cpp

@@ -339,7 +339,17 @@ void ParameterCollection::clear()
     parameterMap.clear();
 }
 
-void ParameterCollection::linkParameters (Parameter* parent, Parameter* child1, Parameter* child2)
+void ParameterCollection::linkParameters(Parameter* parent, Parameter* child1, Parameter* child2)
 {
-    parent->linkParameter (child1, child2);
+    if (parent != nullptr)
+    {
+        if (child1 != nullptr)
+        {
+            parent->linkParameter(child1);
+        }
+        if (child2 != nullptr)
+        {
+            parent->linkParameter(child2);
+        }
+    }
 }