Update logic for merger pop-up menu

Author: jsiegle

Source/Processors/Merger/Merger.cpp

@@ -64,8 +64,8 @@ void Merger::setMergerSourceNode(GenericProcessor* sn)
     }
     else
     {
-        sourceNodeB = sn;
         std::cout << "Setting source node B." << std::endl;
+        sourceNodeB = sn;
     }
 
     if (sn != nullptr)
@@ -225,30 +225,23 @@ void Merger::updateSettings()
     {
         std::cout << "   Merger source A found." << std::endl;
         addSettingsFromSourceNode(sourceNodeA);
+    } else {
+        mergeEventsA = true;
+        mergeContinuousA = true;
     }
 
     if (sourceNodeB != 0)
     {
         std::cout << "   Merger source B found." << std::endl;
         addSettingsFromSourceNode(sourceNodeB);
+    } else {
+        mergeEventsB = true;
+        mergeContinuousB = true;
     }
 
     if (sourceNodeA == 0 && sourceNodeB == 0)
     {
-
-
 		settings.numOutputs = getNumOutputs();
-
-    /*    for (int i = 0; i < getNumOutputs(); i++)
-        {
-            Channel* ch = new Channel(this, i, HEADSTAGE_CHANNEL);
-            ch->sampleRate = getDefaultSampleRate();
-            ch->bitVolts = getDefaultBitVolts();
-
-            channels.add(ch);
-        }*/
-
-        //generateDefaultChannelNames(settings.outputChannelNames);
     }
 
     std::cout << "Number of merger outputs: " << getNumInputs() << std::endl;
@@ -345,4 +338,4 @@ void Merger::loadCustomParametersFromXml()
 // 	else
 // 		tabB = t;
 
-// }
+// }

Source/Processors/Merger/Merger.h

@@ -77,11 +77,11 @@ class Merger : public GenericProcessor
 
     bool mergeEventsA, mergeContinuousA, mergeEventsB, mergeContinuousB;
 
-private:
-
     GenericProcessor* sourceNodeA;
     GenericProcessor* sourceNodeB;
 
+private:
+
     int activePath;
 
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(Merger);

Source/Processors/Merger/MergerEditor.cpp

@@ -121,25 +121,15 @@ void MergerEditor::buttonEvent(Button* button)
     AccessClass::getEditorViewport()->makeEditorVisible(this, false);
 }
 
-void MergerEditor::mouseDown(const MouseEvent& e)
+Array<GenericProcessor*> MergerEditor::getSelectableProcessors()
 {
-
-    Merger* merger = (Merger*) getProcessor();
-
-    if (e.mods.isRightButtonDown())
+    Array<GenericProcessor*> selectableProcessors;
+    
+    Array<GenericProcessor*> availableProcessors =
+        AccessClass::getProcessorGraph()->getListOfProcessors();
+    
+    if (availableProcessors.size() > 0)
     {
-
-        PopupMenu menu;
-        int menuItemIndex = 1;
-        
-        menu.addItem(menuItemIndex, // index
-                     "Choose input 2:", // message
-                     false); // isSelectable
-
-		Array<GenericProcessor*> availableProcessors = AccessClass::getProcessorGraph()->getListOfProcessors();
-        
-        Array<GenericProcessor*> selectableProcessors;
-
         for (auto& processorToCheck : availableProcessors)
         {
             if (!processorToCheck->isMerger() &&
@@ -163,63 +153,179 @@ void MergerEditor::mouseDown(const MouseEvent& e)
 
                 if (!isDownstream)
                 {
-                    String name = String(processorToCheck->getNodeId());
-                    name += " - ";
-                    name += processorToCheck->getName();
-
-                    menu.addItem(++menuItemIndex, // index
-                                 name, // message
-                                 true); // isSelectable
-                    
                     selectableProcessors.add(processorToCheck);
                 }
 
             }
         }
+    }
+    
+    return selectableProcessors;
+    
+}
 
-        int eventMerge = ++menuItemIndex;
-        int continuousMerge = ++menuItemIndex;
+String MergerEditor::getNameString(GenericProcessor* p)
+{
+    return p->getName() + " (" + String(p->getNodeId()) + ")";
+}
+
+void MergerEditor::mouseDown(const MouseEvent& e)
+{
 
-        bool* eventPtr;
-        bool* continuousPtr;
+    Merger* merger = (Merger*) getProcessor();
+
+    if (e.mods.isRightButtonDown())
+    {
 
-        if (pipelineSelectorA->getToggleState())
+        PopupMenu menu;
+        int menuItemIndex = 1;
+        int eventMergeIndexA, eventMergeIndexB, continuousMergeIndexA, continuousMergeIndexB = -1;
+        int inputSelectionIndexA, inputSelectionIndexB = -1;
+        
+        Array<GenericProcessor*> selectableProcessors = getSelectableProcessors();
+        
+        if (merger->sourceNodeA != 0)
         {
-            eventPtr = &merger->mergeEventsA;
-            continuousPtr = &merger->mergeContinuousA;   
+            menu.addItem(menuItemIndex, // index
+            "Input A: " + getNameString(merger->sourceNodeA), // message
+            false); // isSelectable
+            
+            eventMergeIndexA = ++menuItemIndex;
+            continuousMergeIndexA = ++menuItemIndex;
+            
+            menu.addItem(eventMergeIndexA,
+                         "Merge event data",
+                         !acquisitionIsActive,
+                         merger->mergeEventsA);
+            
+            menu.addItem(continuousMergeIndexA,
+                         "Merge continuous data",
+                         !acquisitionIsActive,
+                         merger->mergeContinuousA);
+
         } else {
-            eventPtr = &merger->mergeEventsB;
-            continuousPtr = &merger->mergeContinuousB;  
+            menu.addItem(++menuItemIndex, // index
+            "Choose input A:", // message
+            false); // isSelectable
+            
+            if (selectableProcessors.size() > 0)
+            {
+                inputSelectionIndexA = menuItemIndex + 1;
+                
+                for (auto& selectableProcessor : selectableProcessors)
+                {
+                    menu.addItem(++menuItemIndex, // index
+                                 getNameString(selectableProcessor), // message
+                                 true); // isSelectable
+                }
+            } else {
+                menu.addItem(++menuItemIndex, // index
+                             " NONE AVAILABLE", // message
+                             false); // isSelectable
+            }
+            
         }
 
-        menu.addItem(eventMerge, "Events", !acquisitionIsActive, *eventPtr);
-        menu.addItem(continuousMerge, "Continuous", !acquisitionIsActive, *continuousPtr);
+        menu.addItem(++menuItemIndex,
+                     " ",
+                     false);
+        
+        if (merger->sourceNodeB != 0)
+        {
+            menu.addItem(menuItemIndex, // index
+            "Input B: " + getNameString(merger->sourceNodeB), // message
+            false); // isSelectable
+            
+            eventMergeIndexB = ++menuItemIndex;
+            continuousMergeIndexB = ++menuItemIndex;
+            
+            menu.addItem(eventMergeIndexB,
+                         "Merge event data",
+                         !acquisitionIsActive,
+                         merger->mergeEventsB);
+            
+            menu.addItem(continuousMergeIndexB,
+                         "Merge continuous data",
+                         !acquisitionIsActive,
+                         merger->mergeContinuousB);
+
+        } else {
+            menu.addItem(++menuItemIndex, // index
+            "Choose input B:", // message
+            false); // isSelectable
+            
+            if (selectableProcessors.size() > 0)
+            {
+                inputSelectionIndexB = menuItemIndex + 1;
+                
+                for (auto& selectableProcessor : selectableProcessors)
+                {
+                    menu.addItem(++menuItemIndex, // index
+                                 getNameString(selectableProcessor), // message
+                                 true); // isSelectable
+                }
+            } else {
+                menu.addItem(++menuItemIndex, // index
+                " NONE AVAILABLE", // message
+                false); // isSelectable
+            }
+        }
 
         const int result = menu.show(); // returns 0 if nothing is selected
 
         std::cout << "Selection: " << result << std::endl;
 
-        if (result > 1 && result < eventMerge)
+        
+        if (result == eventMergeIndexA)
         {
-            std::cout << "Selected " << selectableProcessors[result-2]->getName() << std::endl;
-
-            switchSource(1);
-
-            Merger* processor = (Merger*) getProcessor();
-            processor->setMergerSourceNode(selectableProcessors[result-2]);
-            selectableProcessors[result-2]->setDestNode(getProcessor());
-
-			AccessClass::getGraphViewer()->updateNodeLocations();
-
-			AccessClass::getEditorViewport()->makeEditorVisible(this, false, true);
-        } else if (result == eventMerge)
+            merger->mergeEventsA = !(merger->mergeEventsA);
+            CoreServices::updateSignalChain(this);
+            return;
+        } else if (result == continuousMergeIndexA)
+        {
+            merger->mergeContinuousA = !merger->mergeContinuousA;
+            CoreServices::updateSignalChain(this);
+            return;
+        } else if (result == eventMergeIndexB)
         {
-            *eventPtr = !(*eventPtr);
+            merger->mergeEventsB = !merger->mergeEventsB;
             CoreServices::updateSignalChain(this);
-        } else if (result == continuousMerge)
+            return;
+        } else if (result == continuousMergeIndexB)
         {
-            *continuousPtr = !(*continuousPtr);
+            merger->mergeContinuousB = !merger->mergeContinuousB;
             CoreServices::updateSignalChain(this);
+            return;
+        }
+        
+        if (inputSelectionIndexA > 0)
+        {
+            if (result >= inputSelectionIndexA
+                    && result < inputSelectionIndexA + selectableProcessors.size())
+            {
+                switchSource(0);
+                merger->setMergerSourceNode(selectableProcessors[result - inputSelectionIndexA]);
+                selectableProcessors[result-inputSelectionIndexA]->setDestNode(merger);
+
+                AccessClass::getGraphViewer()->updateNodeLocations();
+                AccessClass::getEditorViewport()->makeEditorVisible(this, false, true);
+                return;
+            }
+        }
+        
+        if (inputSelectionIndexB > 0)
+        {
+            if (result >= inputSelectionIndexB
+                    && result < inputSelectionIndexB + selectableProcessors.size())
+            {
+                switchSource(1);
+                merger->setMergerSourceNode(selectableProcessors[result - inputSelectionIndexB]);
+                selectableProcessors[result-inputSelectionIndexB]->setDestNode(merger);
+
+                AccessClass::getGraphViewer()->updateNodeLocations();
+                AccessClass::getEditorViewport()->makeEditorVisible(this, false, true);
+                return;
+            }
         }
     }
 }

Source/Processors/Merger/MergerEditor.h

@@ -70,6 +70,9 @@ class MergerEditor : public GenericEditor
 
 private:
 
+    String getNameString(GenericProcessor*);
+    Array<GenericProcessor*> getSelectableProcessors();
+    
     ImageButton* pipelineSelectorA;
     ImageButton* pipelineSelectorB;