TwoDFieldMultisliderComponent.cpp

Go to the documentation of this file.

/* Copyright (c) 2024-2025, Christian Ahrens
 *
 * This file is part of Mema <https://github.com/ChristianAhrens/Mema>
 *
 * This tool is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 3.0 as published
 * by the Free Software Foundation.
 *
 * This tool is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this tool; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#include "TwoDFieldMultisliderComponent.h"
 
#include <CustomLookAndFeel.h>
#include <FixedFontTextEditor.h>
 
 
namespace Mema
{
 
//#define PAINTINGHELPER
 
 
//==============================================================================
class TwoDFieldMultisliderKeyboardFocusTraverser : public juce::KeyboardFocusTraverser
{
public:
    //==============================================================================
    TwoDFieldMultisliderKeyboardFocusTraverser(const std::vector<juce::Component*>& focusElements)
        : juce::KeyboardFocusTraverser()
    {
        m_focusElements = focusElements;
    };
    virtual ~TwoDFieldMultisliderKeyboardFocusTraverser() = default;
 
    juce::Component* getDefaultComponent(juce::Component* parentComponent) override
    {
        if (m_focusElements.empty() || m_focusElements.front() == parentComponent)
            return nullptr;
        else
            return m_focusElements.front();
    };
    juce::Component* getNextComponent(juce::Component* current) override
    {
        if (m_focusElements.empty())
            return nullptr;
 
        auto currentIter = std::find(m_focusElements.begin(), m_focusElements.end(), current);
        if (currentIter == m_focusElements.end())
            return nullptr;
        else
        {
            if (currentIter == (m_focusElements.end() - 1))
                return *(m_focusElements.begin());
            else
                return *(currentIter + 1);
        }
    };
    juce::Component* getPreviousComponent(juce::Component* current) override
    {
        if (m_focusElements.empty())
            return nullptr;
 
        auto currentIter = std::find(m_focusElements.begin(), m_focusElements.end(), current);
        if (currentIter == m_focusElements.end())
            return nullptr;
        else
        {
            if (currentIter == m_focusElements.begin())
                return *(m_focusElements.end() - 1);
            else
                return *(currentIter - 1);
        }
    };
    std::vector<juce::Component*> getAllComponents(juce::Component* /*parentComponent*/) override
    {
        return m_focusElements;
    };
 
private:
    //==============================================================================
    std::vector<juce::Component*>   m_focusElements;
};
 
 
//==============================================================================
TwoDFieldMultisliderComponent::TwoDFieldMultisliderComponent()
    : JUCEAppBasics::TwoDFieldBase(), juce::Component()
{
    m_sharpnessEdit = std::make_unique<JUCEAppBasics::FixedFontTextEditor>("SharpnessEdit");
    m_sharpnessEdit->setTooltip("Panning sharpness 0.0 ... 1.0");
    m_sharpnessEdit->setText(juce::String(0.5), false);
    m_sharpnessEdit->setInputFilter(new juce::TextEditor::LengthAndCharacterRestriction(3, "0123456789."), true);
    m_sharpnessEdit->setJustification(juce::Justification::centred);
    m_sharpnessEdit->onReturnKey = [=]() {
        if (0 != m_currentlySelectedInput)
        {
            m_inputPositions[m_currentlySelectedInput].sharpness = jlimit(0.0f, 1.0f, m_sharpnessEdit->getText().getFloatValue());
            if (onInputPositionChanged)
                onInputPositionChanged(m_currentlySelectedInput, m_inputPositions[m_currentlySelectedInput].value, m_inputPositions[m_currentlySelectedInput].sharpness, m_inputPositions[m_currentlySelectedInput].layer);
        }
        else
        {
            for (auto& inputPositionKV : m_inputPositions)
            {
                inputPositionKV.second.sharpness = jlimit(0.0f, 1.0f, m_sharpnessEdit->getText().getFloatValue());
                if (onInputPositionChanged)
                    onInputPositionChanged(inputPositionKV.first, inputPositionKV.second.value, inputPositionKV.second.sharpness, inputPositionKV.second.layer);
            }
        }
    };
    addAndMakeVisible(m_sharpnessEdit.get());
    m_sharpnessLabel = std::make_unique<juce::Label>("SharpnessLabel");
    m_sharpnessLabel->setText("Sharpness", juce::dontSendNotification);
    m_sharpnessLabel->setJustificationType(juce::Justification::centredLeft);
    addAndMakeVisible(m_sharpnessLabel.get());
}
 
TwoDFieldMultisliderComponent::~TwoDFieldMultisliderComponent()
{
}
 
std::unique_ptr<juce::ComponentTraverser> TwoDFieldMultisliderComponent::createKeyboardFocusTraverser()
{
    return std::make_unique<TwoDFieldMultisliderKeyboardFocusTraverser>(std::vector<juce::Component*>({ this, m_sharpnessEdit.get() }));
    //juce::Component::createKeyboardFocusTraverser();
}
 
void TwoDFieldMultisliderComponent::paint(juce::Graphics& g)
{
    // (Our component is opaque, so we must completely fill the background with a solid colour)
    g.fillAll(getLookAndFeel().findColour(juce::ResizableWindow::backgroundColourId));
 
    // paint the level indications where applicable
    if (!m_positionedChannelsArea.isEmpty())
        paintCircularLevelIndication(g, m_positionedChannelsArea, m_channelLevelMaxPoints, m_clockwiseOrderedChannelTypes);
    if (!m_positionedHeightChannelsArea.isEmpty())
        paintCircularLevelIndication(g, m_positionedHeightChannelsArea, m_channelHeightLevelMaxPoints, m_clockwiseOrderedHeightChannelTypes);
 
    // paint slider knobs
    jassert(m_inputPositions.size() == m_inputPositionStackingOrder.size());
    // reverse iteration, since what we want to be painted last(on top of everything) is at the beginning of the list!
    for (auto const & inputNumber : std::vector<std::uint16_t>(m_inputPositionStackingOrder.rbegin(), m_inputPositionStackingOrder.rend()))
    {
        auto& inputPosition = m_inputPositions[inputNumber];
        auto emptyRect = juce::Rectangle<float>();
        auto& area = emptyRect;
        if (ChannelLayer::Positioned == inputPosition.layer && !m_positionedChannelsArea.isEmpty())
            area = m_positionedChannelsArea;
        else if (ChannelLayer::PositionedHeight == inputPosition.layer && !m_positionedHeightChannelsArea.isEmpty())
            area = m_positionedHeightChannelsArea;
 
        if (!area.isEmpty())
            paintSliderKnob(g, area, inputPosition.value.relXPos, inputPosition.value.relYPos, inputNumber, inputPosition.isOn, inputPosition.isSliding);
    }
}
 
void TwoDFieldMultisliderComponent::paintCircularLevelIndication(juce::Graphics& g, const juce::Rectangle<float>& circleArea, const std::map<int, juce::Point<float>>& channelLevelMaxPoints, const juce::Array<juce::AudioChannelSet::ChannelType>& channelsToPaint)
{
#if defined DEBUG && defined PAINTINGHELPER
    g.setColour(juce::Colours::blueviolet);
    g.drawRect(circleArea);
#endif
 
    // fill circle background
    g.setColour(getLookAndFeel().findColour(juce::ResizableWindow::backgroundColourId).darker());
    g.fillEllipse(circleArea);
 
#if defined DEBUG && defined PAINTINGHELPER
    g.setColour(juce::Colours::red);
    g.drawRect(circleArea);
    g.setColour(juce::Colours::blue);
    g.drawRect(getLocalBounds());
#endif
 
 
    const float meterWidth = 5.0f;
    const float halfMeterWidth = 2.0f;
 
 
    auto circleCenter = circleArea.getCentre();
 
    // prepare max points
    std::map<int, juce::Point<float>> centerToMaxVectors;
    std::map<int, juce::Point<float>> meterWidthOffsetVectors;
    for (int i = 0; i < channelsToPaint.size(); i++)
    {
        auto const& channelType = channelsToPaint[i];
        auto iTy = int(channelType);
        if (0 < channelLevelMaxPoints.count(iTy))
        {
            auto angleRad = juce::degreesToRadians(getAngleForChannelTypeInCurrentConfiguration(channelType));
            centerToMaxVectors[iTy] = circleCenter - channelLevelMaxPoints.at(iTy);
            meterWidthOffsetVectors[iTy] = { cosf(angleRad) * halfMeterWidth, sinf(angleRad) * halfMeterWidth };
        }
    }
 
    // helper std::functions to avoid codeclones below
    auto createAndPaintLevelPath = [=](std::map<int, juce::Point<float>>& centerToMaxPoints, std::map<int, juce::Point<float>>& meterWidthOffsetPoints, std::map<juce::AudioChannelSet::ChannelType, float>& levels, juce::Graphics& g, const juce::Colour& colour, bool stroke) {
        juce::Path path;
        auto pathStarted = false;
        for (auto const& channelType : channelsToPaint)
        {
            auto iTy = int(channelType);
            auto channelMaxPoint = circleCenter - (centerToMaxPoints[iTy] * levels[channelType]);
 
            if (!pathStarted)
            {
                path.startNewSubPath(channelMaxPoint - meterWidthOffsetPoints[iTy]);
                pathStarted = true;
            }
            else
                path.lineTo(channelMaxPoint - meterWidthOffsetPoints[iTy]);
 
            path.lineTo(channelMaxPoint + meterWidthOffsetPoints[iTy]);
        }
        path.closeSubPath();
 
        g.setColour(colour);
        if (stroke)
            g.strokePath(path, juce::PathStrokeType(1));
        else
            g.fillPath(path);
#if defined DEBUG && defined PAINTINGHELPER
        g.setColour(juce::Colours::yellow);
        g.drawRect(path.getBounds());
#endif
    };
    auto paintLevelMeterLines = [=](std::map<int, juce::Point<float>>& centerToMaxPoints, std::map<int, juce::Point<float>>& meterWidthOffsetPoints, std::map<juce::AudioChannelSet::ChannelType, float>& levels, juce::Graphics& g, const juce::Colour& colour, bool isHoldLine) {
        g.setColour(colour);
        for (auto const& channelType : channelsToPaint)
        {
            auto iTy = int(channelType);
            auto channelMaxPoint = circleCenter - (centerToMaxPoints[iTy] * levels[channelType]);
 
            if (isHoldLine)
                g.drawLine(juce::Line<float>(channelMaxPoint - meterWidthOffsetPoints[iTy], channelMaxPoint + meterWidthOffsetPoints[iTy]), 1.0f);
            else
                g.drawLine(juce::Line<float>(circleCenter, channelMaxPoint), meterWidth);
        }
        };
    
    std::map<juce::AudioChannelSet::ChannelType, float> levels;
    for (auto& vKV : m_inputToOutputVals)
    {
        levels.clear();
        for (auto const& oVals : vKV.second)
        {
            auto& channel = oVals.first;
            auto& state = oVals.second.first;
            auto& level = oVals.second.second;
            levels[channel] = state ? level : 0.0f;
        }
 
        juce::Colour colour;
        if (m_currentlySelectedInput == vKV.first)
            colour = getLookAndFeel().findColour(JUCEAppBasics::CustomLookAndFeel::ColourIds::MeteringRmsColourId).withAlpha(0.8f);
        else
            colour = getLookAndFeel().findColour(JUCEAppBasics::CustomLookAndFeel::ColourIds::MeteringRmsColourId).withAlpha(0.4f);
 
        // paint hold values as path
        createAndPaintLevelPath(centerToMaxVectors, meterWidthOffsetVectors, levels, g, colour, false);
        // paint hold values as max line
        paintLevelMeterLines(centerToMaxVectors, meterWidthOffsetVectors, levels, g, colour, false);
    }
 
    // draw a simple circle surrounding
    g.setColour(getLookAndFeel().findColour(juce::TextButton::textColourOffId));
    g.drawEllipse(circleArea, 1);
 
    // draw dashed field dimension indication lines
    float dparam[]{ 4.0f, 5.0f };
    for (auto const& channelType : channelsToPaint)
        if (0 < channelLevelMaxPoints.count(channelType))
            g.drawDashedLine(juce::Line<float>(channelLevelMaxPoints.at(channelType), circleCenter), dparam, 2);
 
    // draw channelType naming legend
    g.setColour(getLookAndFeel().findColour(juce::TextButton::textColourOffId));
    for (auto const& channelType : channelsToPaint)
    {
        if (0 >= channelLevelMaxPoints.count(channelType))
            continue;
 
        auto channelName = juce::AudioChannelSet::getAbbreviatedChannelTypeName(channelType);
        auto textRect = juce::Rectangle<float>(juce::GlyphArrangement::getStringWidth(g.getCurrentFont(), channelName), g.getCurrentFont().getHeight());
        auto angle = getAngleForChannelTypeInCurrentConfiguration(channelType);
        auto textRectOffset = juce::Point<int>(-int(textRect.getWidth() / 2.0f), 0);
        if (90.0f < angle)
            angle += 180.0f;
        else if (-90.0f > angle)
            angle -= 180.0f;
        else
            textRectOffset.addXY(0, -int(g.getCurrentFont().getHeight()));
        auto angleRad = juce::degreesToRadians(angle);
 
        g.saveState();
        g.setOrigin(channelLevelMaxPoints.at(channelType).toInt());
        g.addTransform(juce::AffineTransform().translated(textRectOffset).rotated(angleRad));
        g.drawText(channelName, textRect, Justification::centred, true);
 
#if defined DEBUG && defined PAINTINGHELPER
        g.setColour(juce::Colours::lightblue);
        g.drawRect(textRect);
        g.setColour(getLookAndFeel().findColour(juce::TextButton::textColourOffId));
#endif
 
        g.restoreState();
    }
}
 
void TwoDFieldMultisliderComponent::paintSliderKnob(juce::Graphics& g, const juce::Rectangle<float>& sliderArea, const float& relXPos, const float& relYPos, const int& silderNumber, bool isSliderOn, bool isSliderSliding)
{
    juce::Path valueTrack;
    auto minPoint = sliderArea.getCentre();
    auto maxPoint = sliderArea.getCentre() + juce::Point<float>((sliderArea.getWidth() / 2) * relXPos, (sliderArea.getHeight() / 2) * relYPos * -1.0f);
 
    if (isSliderOn)
    {
        if (isSliderSliding)
        {
            valueTrack.startNewSubPath(minPoint);
            valueTrack.lineTo(maxPoint);
            g.setColour(getLookAndFeel().findColour(JUCEAppBasics::CustomLookAndFeel::ColourIds::MeteringPeakColourId));
            g.strokePath(valueTrack, { m_trackWidth, juce::PathStrokeType::curved, juce::PathStrokeType::rounded });
        }
 
        g.setColour(getLookAndFeel().findColour(juce::Slider::thumbColourId));
        g.fillEllipse(juce::Rectangle<float>(static_cast<float>(m_thumbWidth), static_cast<float>(m_thumbWidth)).withCentre(maxPoint));
 
        g.setColour(getLookAndFeel().findColour(juce::TextButton::textColourOnId));
        g.drawText(juce::String(silderNumber), juce::Rectangle<float>(static_cast<float>(m_thumbWidth), static_cast<float>(m_thumbWidth)).withCentre(maxPoint), juce::Justification::centred);
    }
    else
    {
        if (isSliderSliding)
        {
            valueTrack.startNewSubPath(minPoint);
            valueTrack.lineTo(maxPoint);
            auto valueTrackOutline = valueTrack;
            juce::PathStrokeType pt(m_trackWidth, juce::PathStrokeType::curved, juce::PathStrokeType::rounded);
            pt.createStrokedPath(valueTrackOutline, valueTrack);
            g.setColour(getLookAndFeel().findColour(JUCEAppBasics::CustomLookAndFeel::ColourIds::MeteringPeakColourId));
            g.strokePath(valueTrackOutline, juce::PathStrokeType(1.0f));
        }
 
        g.setColour(getLookAndFeel().findColour(juce::ResizableWindow::ColourIds::backgroundColourId));
        g.fillEllipse(juce::Rectangle<float>(static_cast<float>(m_thumbWidth - 1), static_cast<float>(m_thumbWidth - 1)).withCentre(maxPoint));
 
        g.setColour(getLookAndFeel().findColour(juce::Slider::thumbColourId));
        g.drawEllipse(juce::Rectangle<float>(static_cast<float>(m_thumbWidth), static_cast<float>(m_thumbWidth)).withCentre(maxPoint), 1.0f);
 
        g.drawText(juce::String(silderNumber), juce::Rectangle<float>(static_cast<float> (m_thumbWidth), static_cast<float> (m_thumbWidth)).withCentre(maxPoint), juce::Justification::centred);
    }
}
 
void TwoDFieldMultisliderComponent::resized()
{
    // process areas for level indication painting
    auto coreTwoDFieldOnly = usesPositionedChannels() && !usesPositionedHeightChannels() && !usesDirectionlessChannels();
    auto coreTwoDFieldWithMeterbridge = usesPositionedChannels() && !usesPositionedHeightChannels() && usesDirectionlessChannels();
    auto bothTwoDFields = usesPositionedChannels() && usesPositionedHeightChannels() && !usesDirectionlessChannels();
    auto bothTwoDFieldsWithMeterbridge = usesPositionedChannels() && usesPositionedHeightChannels() && usesDirectionlessChannels();
 
    auto margin = 12.0f;
    auto bounds = getLocalBounds().reduced(8).toFloat();
    auto width = bounds.getWidth();
    auto height = bounds.getHeight();
 
    auto sharpnessBounds = bounds.toNearestInt();
    sharpnessBounds = sharpnessBounds.removeFromBottom(40);
    if (m_sharpnessEdit)
        m_sharpnessEdit->setBounds(sharpnessBounds.removeFromBottom(20).removeFromLeft(40));
    if (m_sharpnessLabel)
        m_sharpnessLabel->setBounds(sharpnessBounds.removeFromLeft(75));
 
    if (coreTwoDFieldOnly)
    {
        m_positionedChannelsArea = bounds.reduced(margin);
        m_positionedHeightChannelsArea = {};
        m_directionlessChannelsArea = {};
    }
    else if (coreTwoDFieldWithMeterbridge)
    {
        m_positionedChannelsArea = bounds;
        m_directionlessChannelsArea = m_positionedChannelsArea.removeFromRight(float(m_directionLessChannelTypes.size() * m_ctrlsSize));
        m_positionedChannelsArea.reduce(margin, margin);
 
        m_positionedHeightChannelsArea = {};
    }
    else if (bothTwoDFields)
    {
        m_positionedHeightChannelsArea = bounds.reduced(margin);
        m_positionedHeightChannelsArea.removeFromRight(width * (8.4f / 12.0f));
        m_positionedHeightChannelsArea.removeFromBottom(height * (5.4f / 10.0f));
 
        m_positionedChannelsArea = bounds.reduced(margin);
        m_positionedChannelsArea.removeFromLeft(width * (3.4f / 12.0f));
        m_positionedChannelsArea.removeFromTop(height * (1.4f / 10.0f));
 
        m_directionlessChannelsArea = {};
    }
    else if (bothTwoDFieldsWithMeterbridge)
    {
        m_positionedHeightChannelsArea = bounds.reduced(margin);
        m_positionedHeightChannelsArea.removeFromRight(width * (8.4f / 13.0f));
        m_positionedHeightChannelsArea.removeFromBottom(height * (5.4f / 10.0f));
 
        m_positionedChannelsArea = bounds;
        m_directionlessChannelsArea = m_positionedChannelsArea.removeFromRight(float(m_directionLessChannelTypes.size() * m_ctrlsSize));
        m_positionedChannelsArea.reduce(margin, margin);
        m_positionedChannelsArea.removeFromLeft(width * (3.4f / 13.0f));
        m_positionedChannelsArea.removeFromTop(height * (1.4f / 10.0f));
    }
 
    // Constrain each field area to a square so the drawn circle is not distorted
    if (!m_positionedChannelsArea.isEmpty())
    {
        auto squareSize = juce::jmin(m_positionedChannelsArea.getWidth(), m_positionedChannelsArea.getHeight());
        m_positionedChannelsArea = juce::Rectangle<float>(squareSize, squareSize).withCentre(m_positionedChannelsArea.getCentre());
    }
    if (!m_positionedHeightChannelsArea.isEmpty())
    {
        auto squareSize = juce::jmin(m_positionedHeightChannelsArea.getWidth(), m_positionedHeightChannelsArea.getHeight());
        m_positionedHeightChannelsArea = juce::Rectangle<float>(squareSize, squareSize).withCentre(m_positionedHeightChannelsArea.getCentre());
    }
 
    for (auto const& channelType : m_clockwiseOrderedChannelTypes)
    {
        auto angleRad = juce::degreesToRadians(getAngleForChannelTypeInCurrentConfiguration(channelType));
        auto radius = m_positionedChannelsArea.getWidth() / 2;
        auto xLength = sinf(angleRad) * radius;
        auto yLength = cosf(angleRad) * radius;
        m_channelLevelMaxPoints[channelType] = m_positionedChannelsArea.getCentre() + juce::Point<float>(xLength, -yLength);
    }
 
    for (auto const& channelType : m_clockwiseOrderedHeightChannelTypes)
    {
        auto angleRad = juce::degreesToRadians(getAngleForChannelTypeInCurrentConfiguration(channelType));
        auto radius = m_positionedHeightChannelsArea.getWidth() / 2;
        auto xLength = sinf(angleRad) * radius;
        auto yLength = cosf(angleRad) * radius;
        m_channelHeightLevelMaxPoints[channelType] = m_positionedHeightChannelsArea.getCentre() + juce::Point<float>(xLength, -yLength);
    }
 
    if (!m_directionlessChannelsArea.isEmpty() && !m_directionslessChannelSliders.empty() && !m_directionslessChannelLabels.empty())
    {
        jassert(m_directionslessChannelSliders.size() == m_directionslessChannelLabels.size());
        auto directionlessChannelsWidth = m_directionlessChannelsArea.getWidth() / m_directionslessChannelSliders.size();
        auto areaToDivide = m_directionlessChannelsArea;
        for (auto const& sliderKV : m_directionslessChannelSliders)
        {
            auto const& slider = sliderKV.second;
            auto const& label = m_directionslessChannelLabels.at(sliderKV.first);
            auto sliderBounds = areaToDivide.removeFromLeft(directionlessChannelsWidth).toNearestInt();
            auto labelBounds = sliderBounds.removeFromBottom(m_thumbWidth);
            if (slider)
                slider->setBounds(sliderBounds);
            if (label)
                label->setBounds(labelBounds);
        }
    }
}
 
void TwoDFieldMultisliderComponent::lookAndFeelChanged()
{
    if (!m_directionslessChannelSliders.empty())
    {
        for (auto const& slider : m_directionslessChannelSliders)
            if (slider.second)
                slider.second->setColour(juce::Slider::ColourIds::trackColourId, getLookAndFeel().findColour(JUCEAppBasics::CustomLookAndFeel::ColourIds::MeteringRmsColourId));
    }
}
 
void TwoDFieldMultisliderComponent::mouseDown(const juce::MouseEvent& e)
{
    // hit-test slider knobs
    auto hadHit = false;
    jassert(m_inputPositions.size() == m_inputPositionStackingOrder.size());
    for (auto const& inputNumber : m_inputPositionStackingOrder)
    {
        auto& inputPosition = m_inputPositions[inputNumber];
        auto emptyRect = juce::Rectangle<float>();
        auto& area = emptyRect;
        if (ChannelLayer::Positioned == inputPosition.layer && !m_positionedChannelsArea.isEmpty())
            area = m_positionedChannelsArea;
        else if (ChannelLayer::PositionedHeight == inputPosition.layer && !m_positionedHeightChannelsArea.isEmpty())
            area = m_positionedHeightChannelsArea;
        else if (ChannelLayer::Directionless == inputPosition.layer && !m_directionlessChannelsArea.isEmpty())
            area = m_directionlessChannelsArea;
 
        auto maxPoint = area.getCentre() - juce::Point<float>((area.getWidth() / 2) * -inputPosition.value.relXPos, (area.getHeight() / 2) * inputPosition.value.relYPos);
        auto sliderKnob = juce::Rectangle<float>(static_cast<float>(m_thumbWidth), static_cast<float>(m_thumbWidth)).withCentre(maxPoint);
        if (sliderKnob.contains(e.getMouseDownPosition().toFloat()) && false == hadHit)
        {
            inputPosition.isOn = true;
 
            selectInput(inputNumber, true, juce::sendNotification);
 
            hadHit = true;
        }
        else
        {
            selectInput(inputNumber, false, juce::sendNotification);
        }
    }
 
    juce::Component::mouseDown(e);
}
 
void TwoDFieldMultisliderComponent::mouseUp(const MouseEvent& e)
{
    juce::Component::mouseUp(e);
}
 
void TwoDFieldMultisliderComponent::mouseDrag(const MouseEvent& e)
{
    if (e.mouseWasDraggedSinceMouseDown())
    {
        // reset any sliding states slider knobs
        jassert(m_inputPositions.size() == m_inputPositionStackingOrder.size());
        for (auto const& inputNumber : m_inputPositionStackingOrder)
        {
            auto& inputPosition = m_inputPositions[inputNumber];
            if (inputPosition.isSliding)
            {
                auto emptyRect = juce::Rectangle<float>();
                auto& area = emptyRect;
                if (ChannelLayer::Positioned == inputPosition.layer && !m_positionedChannelsArea.isEmpty())
                    area = m_positionedChannelsArea;
                else if (ChannelLayer::PositionedHeight == inputPosition.layer && !m_positionedHeightChannelsArea.isEmpty())
                    area = m_positionedHeightChannelsArea;
                else if (ChannelLayer::Directionless == inputPosition.layer && !m_directionlessChannelsArea.isEmpty())
                    area = m_directionlessChannelsArea;
 
                auto mousePosition = e.getMouseDownPosition() + e.getOffsetFromDragStart();
                
                juce::Path ellipsePath;
                ellipsePath.addEllipse(area);
                // if the mouse is within the resp. circle, do the regular calculation of knob pos
                if (ellipsePath.contains(mousePosition.toFloat()))
                {
                    auto positionInArea = area.getCentre() - area.getConstrainedPoint(mousePosition.toFloat());
                    auto relXPos = positionInArea.getX() / (0.5f * area.getWidth());
                    auto relYPos = positionInArea.getY() / (0.5f * area.getHeight());
                    setInputPosition(inputNumber, { -relXPos, relYPos }, inputPosition.sharpness, inputPosition.layer, juce::sendNotification);
                }
                else
                {
                    juce::Path positionedChannelsEllipsePath, positionedHeightChannelsEllipsePath;
                    positionedChannelsEllipsePath.addEllipse(m_positionedChannelsArea);
                    positionedHeightChannelsEllipsePath.addEllipse(m_positionedHeightChannelsArea);
                    // check if the mouse has entered another circle area while dragging
                    if (positionedChannelsEllipsePath.contains(mousePosition.toFloat()))
                    {
                        auto positionInArea = m_positionedChannelsArea.getCentre() - m_positionedChannelsArea.getConstrainedPoint(mousePosition.toFloat());
                        auto relXPos = positionInArea.getX() / (0.5f * m_positionedChannelsArea.getWidth());
                        auto relYPos = positionInArea.getY() / (0.5f * m_positionedChannelsArea.getHeight());
                        setInputPosition(inputNumber, { -relXPos, relYPos }, inputPosition.sharpness, ChannelLayer::Positioned, juce::sendNotification);
                    }
                    else if (positionedHeightChannelsEllipsePath.contains(mousePosition.toFloat()))
                    {
                        auto positionInArea = m_positionedHeightChannelsArea.getCentre() - m_positionedHeightChannelsArea.getConstrainedPoint(mousePosition.toFloat());
                        auto relXPos = positionInArea.getX() / (0.5f * m_positionedHeightChannelsArea.getWidth());
                        auto relYPos = positionInArea.getY() / (0.5f * m_positionedHeightChannelsArea.getHeight());
                        setInputPosition(inputNumber, { -relXPos, relYPos }, inputPosition.sharpness, ChannelLayer::PositionedHeight, juce::sendNotification);
                    }
                    // finally do the clipping to original circle, if the dragging happens somewhere outside everything
                    else
                    {
                        juce::Point<float> constrainedPoint;
                        ellipsePath.getNearestPoint(mousePosition.toFloat(), constrainedPoint);
                        auto positionInArea = area.getCentre() - constrainedPoint;
                        auto relXPos = positionInArea.getX() / (0.5f * area.getWidth());
                        auto relYPos = positionInArea.getY() / (0.5f * area.getHeight());
                        inputPosition.value = { relXPos, relYPos };
                        setInputPosition(inputNumber, { -relXPos, relYPos }, inputPosition.sharpness, inputPosition.layer, juce::sendNotification);
                    }
 
                }
            }
        }
    }
 
    juce::Component::mouseDrag(e);
}
 
void TwoDFieldMultisliderComponent::setInputPosition(std::uint16_t channel, const TwoDMultisliderValue& value, const float& sharpness, const ChannelLayer& layer, juce::NotificationType notification)
{
    jassert(m_inputPositions.size() == m_inputPositionStackingOrder.size());
    m_inputPositions[channel].value = value;
    m_inputPositions[channel].sharpness = sharpness;
    m_inputPositions[channel].layer = layer;
 
    repaint();
 
    DBG(juce::String(__FUNCTION__) << " new pos: " << int(channel) << " " << value.relXPos << "," << value.relYPos << "(" << sharpness << "/" << layer << ")");
 
    if (juce::dontSendNotification != notification && onInputPositionChanged)
        onInputPositionChanged(channel, value, sharpness, layer);
}
 
void TwoDFieldMultisliderComponent::setInputPositionValue(std::uint16_t channel, const TwoDMultisliderValue& value, juce::NotificationType notification)
{
    jassert(m_inputPositions.size() == m_inputPositionStackingOrder.size());
    m_inputPositions[channel].value = value;
 
    repaint();
 
    DBG(juce::String(__FUNCTION__) << " new pos: " << int(channel) << " " << value.relXPos << "," << value.relYPos << "(" << m_inputPositions[channel].sharpness << "/" << m_inputPositions[channel].layer << ")");
 
    if (juce::dontSendNotification != notification && onInputPositionChanged)
        onInputPositionChanged(channel, value, m_inputPositions[channel].sharpness, m_inputPositions[channel].layer);
}
 
void TwoDFieldMultisliderComponent::setInputPositionSharpness(std::uint16_t channel, const float& sharpness, juce::NotificationType notification)
{
    jassert(m_inputPositions.size() == m_inputPositionStackingOrder.size());
    m_inputPositions[channel].sharpness = sharpness;
 
    if (m_sharpnessEdit && 0 != m_currentlySelectedInput)
        m_sharpnessEdit->setText(juce::String(sharpness), juce::dontSendNotification);
 
    repaint();
 
    DBG(juce::String(__FUNCTION__) << " new pos: " << int(channel) << " " << m_inputPositions[channel].value.relXPos << "," << m_inputPositions[channel].value.relYPos << "(" << sharpness << "/" << m_inputPositions[channel].layer << ")");
 
    if (juce::dontSendNotification != notification && onInputPositionChanged)
        onInputPositionChanged(channel, m_inputPositions[channel].value, sharpness, m_inputPositions[channel].layer);
}
 
void TwoDFieldMultisliderComponent::setInputPositionLayer(std::uint16_t channel, const ChannelLayer& layer, juce::NotificationType notification)
{
    jassert(m_inputPositions.size() == m_inputPositionStackingOrder.size());
    m_inputPositions[channel].layer = layer;
 
    repaint();
 
    DBG(juce::String(__FUNCTION__) << " new pos: " << int(channel) << " " << m_inputPositions[channel].value.relXPos << "," << m_inputPositions[channel].value.relYPos << "(" << m_inputPositions[channel].sharpness << "/" << layer << ")");
 
    if (juce::dontSendNotification != notification && onInputPositionChanged)
        onInputPositionChanged(channel, m_inputPositions[channel].value, m_inputPositions[channel].sharpness, layer);
}
 
void TwoDFieldMultisliderComponent::triggerInputPositionsDump()
{
    jassert(m_inputPositions.size() == m_inputPositionStackingOrder.size());
    for (auto const& inputNumber : m_inputPositionStackingOrder)
    {
        auto& inputPosition = m_inputPositions[inputNumber];
        if (onInputPositionChanged)
            onInputPositionChanged(inputNumber, inputPosition.value, inputPosition.sharpness, inputPosition.layer);
    }
}
 
void TwoDFieldMultisliderComponent::selectInput(std::uint16_t channel, bool selectOn, juce::NotificationType notification)
{
    jassert(0 != m_inputPositions.count(channel));
    if (0 == m_inputPositions.count(channel))
        return;
 
    if (selectOn)
    {
        auto posIter = std::find(m_inputPositionStackingOrder.begin(), m_inputPositionStackingOrder.end(), channel);
        if (posIter != m_inputPositionStackingOrder.end() && posIter != m_inputPositionStackingOrder.begin())
        {
            m_inputPositionStackingOrder.erase(posIter);
            m_inputPositionStackingOrder.insert(m_inputPositionStackingOrder.begin(), channel);
        }
    }
 
    m_inputPositions[channel].isSliding = selectOn;
    if (m_currentlySelectedInput == channel && !selectOn)
        m_currentlySelectedInput = 0;
    else if (m_currentlySelectedInput != channel && selectOn)
        m_currentlySelectedInput = channel;
 
    repaint();
 
    if (!m_directionslessChannelSliders.empty() && !m_inputToOutputVals.empty())
    {
        for (auto const& slider : m_directionslessChannelSliders)
        {
            if (slider.second)
            {
                if (0 == m_currentlySelectedInput && slider.second)
                {
                    configureDirectionlessSliderToRelativeCtrl(slider.first, *slider.second);
                }
                else if (selectOn && 0 < m_inputToOutputVals.count(channel))
                {
                    auto output = slider.first;
                    jassert(0 < m_inputToOutputVals.at(channel).count(output));
                    if(0 < m_inputToOutputVals.at(channel).count(output))
                    {
                        slider.second->setTitle(juce::String(channel));
                        slider.second->setRange(0.0, 1.0, 0.01);
                        slider.second->displayValueConverter = [](double val) { return juce::String(juce::Decibels::gainToDecibels(val, static_cast<double>(ProcessorDataAnalyzer::getGlobalMindB())), 1) + " dB"; };
                        slider.second->setValue(m_inputToOutputVals.at(channel).at(output).second);
                        slider.second->setToggleState(m_inputToOutputVals.at(channel).at(output).first, juce::dontSendNotification);
                    }
                }
            }
        }
    }
 
    if (m_sharpnessEdit)
    {
        if (0 != m_currentlySelectedInput)
        {
            m_sharpnessLabel->setText("In" + juce::String(m_currentlySelectedInput) + " sharpness", juce::dontSendNotification);
            m_sharpnessEdit->setText(juce::String(m_inputPositions[m_currentlySelectedInput].sharpness), juce::dontSendNotification);
        }
        else
        {
            m_sharpnessLabel->setText("All sharpness", juce::dontSendNotification);
            m_sharpnessEdit->setTextToShowWhenEmpty("0.5", getLookAndFeel().findColour(juce::TextButton::ColourIds::textColourOffId));
            m_sharpnessEdit->setText("", juce::dontSendNotification);
        }
    }
 
    if (juce::dontSendNotification != notification && onInputSelected && selectOn)
        onInputSelected(channel);
}
 
void TwoDFieldMultisliderComponent::setIOCount(const std::pair<int, int>& ioCount)
{
    auto channelsToRemove = std::vector<std::uint16_t>();
    auto channelsToAdd = std::vector<std::uint16_t>();
    for (auto const& inputPositionKV : m_inputPositions)
    {
        if (inputPositionKV.first > ioCount.first)
            channelsToRemove.push_back(inputPositionKV.first);
    }
    for (auto i = std::uint16_t(1); i <= ioCount.first; i++)
    {
        if (0 == m_inputPositions.count(i))
            channelsToAdd.push_back(i);
    }
 
    for (auto const& channelToRemove : channelsToRemove)
    {
        m_inputPositions.erase(channelToRemove);
        auto iterToRemove = std::find(m_inputPositionStackingOrder.begin(), m_inputPositionStackingOrder.end(), channelToRemove);
        if (iterToRemove != m_inputPositionStackingOrder.end())
            m_inputPositionStackingOrder.erase(iterToRemove);
    }
 
    auto angleRadDistributionSegment = channelsToAdd.empty() ? 1.0f : juce::degreesToRadians(360.0f / channelsToAdd.size());
    auto defaultPosAngleRad = 0.0f;
    for (auto const& channelToAdd : channelsToAdd)
    {
        m_inputPositionStackingOrder.push_back(channelToAdd);
 
        auto defaultXPos = 0.5f * sinf(defaultPosAngleRad);
        auto defaultYPos = 0.5f * cosf(defaultPosAngleRad);
        m_inputPositions[channelToAdd] = { ChannelLayer::Positioned, { defaultXPos, defaultYPos }, 0.5f, false, false };
        defaultPosAngleRad -= angleRadDistributionSegment;
    }
 
    m_currentOutputCount = ioCount.second;
 
    repaint();
}
 
void TwoDFieldMultisliderComponent::setControlsSize(int ctrlsSize)
{
    m_ctrlsSize = ctrlsSize;
    m_thumbWidth = int(float(4 * ctrlsSize) / 7.0f);
    m_trackWidth = float(8 * ctrlsSize) / 35.0f;
 
    resized();
    repaint();
}
 
void TwoDFieldMultisliderComponent::setInputToOutputStates(const std::map<std::uint16_t, std::map<std::uint16_t, bool>>& inputToOutputStates)
{
    for (auto const& iKV : inputToOutputStates)
    {
        for (auto const& oKV : iKV.second)
        {
            jassert(0 < iKV.first);
            auto output = getChannelTypeForChannelNumberInCurrentConfiguration(oKV.first);
            if (juce::AudioChannelSet::ChannelType::unknown != output)
                m_inputToOutputVals[iKV.first][output].first = oKV.second;
            if (m_directionLessChannelTypes.contains(output) && m_directionslessChannelSliders.at(output) && m_currentlySelectedInput == iKV.first)
                m_directionslessChannelSliders.at(output)->setValue(oKV.second, juce::dontSendNotification);
        }
    }
 
    repaint();
}
 
void TwoDFieldMultisliderComponent::setInputToOutputLevels(const std::map<std::uint16_t, std::map<std::uint16_t, float>>& inputToOutputLevels)
{
    for (auto const& iKV : inputToOutputLevels)
    {
        for (auto const& oKV : iKV.second)
        {
            jassert(0 < iKV.first);
            auto output = getChannelTypeForChannelNumberInCurrentConfiguration(oKV.first);
            if (juce::AudioChannelSet::ChannelType::unknown != output)
                m_inputToOutputVals[iKV.first][output].second = oKV.second;
            if (m_directionLessChannelTypes.contains(output) && m_directionslessChannelSliders.at(output) && m_currentlySelectedInput == iKV.first)
                m_directionslessChannelSliders.at(output)->setValue(oKV.second, juce::dontSendNotification);
        }
    }
 
    if (0 == m_currentlySelectedInput)
        for (auto const& sliderKV : m_directionslessChannelSliders)
            if (sliderKV.second && sliderKV.second->displayValueConverter) // hacky: use the presence of the valueconverter as indicator if we need to switch to relctrl or not
                configureDirectionlessSliderToRelativeCtrl(sliderKV.first, *sliderKV.second);
 
    repaint();
}
 
bool TwoDFieldMultisliderComponent::setChannelConfiguration(const juce::AudioChannelSet& channelLayout)
{
    auto wasUpdated = TwoDFieldBase::setChannelConfiguration(channelLayout);
    if (wasUpdated)
        rebuildDirectionslessChannelSliders();
 
    return wasUpdated;
}
 
void TwoDFieldMultisliderComponent::rebuildDirectionslessChannelSliders()
{
    m_directionslessChannelSliders.clear();
    for (auto const& channelType : m_directionLessChannelTypes)
    {
        m_directionslessChannelSliders[channelType] = std::make_unique<JUCEAppBasics::ToggleStateSlider>(juce::Slider::LinearVertical, juce::Slider::NoTextBox);
        m_directionslessChannelSliders[channelType]->setColour(juce::Slider::ColourIds::trackColourId, getLookAndFeel().findColour(JUCEAppBasics::CustomLookAndFeel::ColourIds::MeteringRmsColourId));
        m_directionslessChannelSliders[channelType]->setRange(0.0, 1.0, 0.01);
        m_directionslessChannelSliders[channelType]->setToggleState(false, juce::dontSendNotification);
        m_directionslessChannelSliders[channelType]->displayValueConverter = [](double val) { return juce::String(juce::Decibels::gainToDecibels(val, static_cast<double>(ProcessorDataAnalyzer::getGlobalMindB())), 1) + " dB"; };
        m_directionslessChannelSliders[channelType]->onToggleStateChange = [this, channelType]() {
            std::map<std::uint16_t, std::map<std::uint16_t, bool >> states;
            if (0 != m_currentlySelectedInput)
            {
                m_inputToOutputVals[m_currentlySelectedInput][channelType].first = m_directionslessChannelSliders[channelType]->getToggleState();
                states[m_currentlySelectedInput][std::uint16_t(getChannelNumberForChannelTypeInCurrentConfiguration(channelType))] = m_directionslessChannelSliders[channelType]->getToggleState();
            }
            else
            {
                for (auto& ioValKV : m_inputToOutputVals)
                {
                    ioValKV.second[channelType].first = m_directionslessChannelSliders[channelType]->getToggleState();
                    auto outputChannel = getChannelNumberForChannelTypeInCurrentConfiguration(channelType);
                    if (outputChannel <= m_currentOutputCount)
                        states[ioValKV.first][std::uint16_t(outputChannel)] = m_directionslessChannelSliders[channelType]->getToggleState();
                }
            }
 
            if (onInputToOutputStatesChanged)
                onInputToOutputStatesChanged(states);
        };
        m_directionslessChannelSliders[channelType]->onValueChange = [this, channelType]() {
            std::map<std::uint16_t, std::map<std::uint16_t, float >> values;
            if (0 != m_currentlySelectedInput)
            {
                auto value = float(m_directionslessChannelSliders[channelType]->getValue());
                m_inputToOutputVals[m_currentlySelectedInput][channelType].second = value;
                values[m_currentlySelectedInput][std::uint16_t(getChannelNumberForChannelTypeInCurrentConfiguration(channelType))] = value;
            }
            else
            {
                auto latestValue = m_directionslessChannelSliders[channelType]->getValue();
                auto latestDelta = latestValue - m_directionlessSliderRelRef[channelType];
                for (auto& ioValKV : m_inputToOutputVals)
                {
                    ioValKV.second[channelType].second = jlimit(0.0f, 1.0f, ioValKV.second[channelType].second + float(latestDelta));
                    auto outputChannel = getChannelNumberForChannelTypeInCurrentConfiguration(channelType);
                    if (outputChannel <= m_currentOutputCount)
                        values[ioValKV.first][std::uint16_t(outputChannel)] = ioValKV.second[channelType].second;
                    //DBG(juce::String(ioValKV.first) << ">" << juce::AudioChannelSet::getAbbreviatedChannelTypeName(channelType) << " val:" << ioValKV.second[channelType].second);
                }
                m_directionlessSliderRelRef[channelType] = latestValue;
            }
 
            if (onInputToOutputValuesChanged)
                onInputToOutputValuesChanged(values);
        };
        addAndMakeVisible(m_directionslessChannelSliders[channelType].get());
 
        m_directionslessChannelLabels[channelType] = std::make_unique<juce::Label>();
        m_directionslessChannelLabels[channelType]->setText(juce::AudioChannelSet::getAbbreviatedChannelTypeName(channelType), juce::dontSendNotification);
        m_directionslessChannelLabels[channelType]->setJustificationType(juce::Justification::centred);
        addAndMakeVisible(m_directionslessChannelLabels[channelType].get());
    }
}
 
void TwoDFieldMultisliderComponent::configureDirectionlessSliderToRelativeCtrl(const juce::AudioChannelSet::ChannelType& channelType, JUCEAppBasics::ToggleStateSlider& slider)
{
    auto anyInputToDirectionLessOff = false;
    for (auto const& iKV : m_inputToOutputVals)
    {
        if (0 < iKV.second.count(channelType) && !iKV.second.at(channelType).first)
        {
            anyInputToDirectionLessOff = true;
            break;
        }
    }
 
    slider.setTitle("");
    slider.setRange(0.0, 1.0, 0.01);
    slider.setValue(0.5); // relative starting
    slider.displayValueConverter = {};
    slider.setToggleState(!anyInputToDirectionLessOff, juce::dontSendNotification);
    m_directionlessSliderRelRef[channelType] = 0.5;
}
 
 
}