WaveformViewerAndEditor.cpp

Go to the documentation of this file.

namespace krotos
{
    WaveformViewerAndEditor::WaveformViewerAndEditor(Colour waveformColour, bool minimumSelectionAreaOn,
                                                     bool enableAreaSelection)
        : m_minimumSelectionAreaOn(minimumSelectionAreaOn),
          m_waveformView(std::make_unique<WaveformViewer>(waveformColour)),
          m_grainDisplay(std::make_unique<GrainDisplay>())
    {
 
        addAndMakeVisible(m_waveformView.get());
        m_waveformView->setBounds(0, 30, 400, 140);
        m_waveformView->setInterceptsMouseClicks(false, false);
        m_waveformView->toBack();
        m_waveformView->setUseExtendedFilePaths(true);
        m_waveformView->setLimitToSingleDroppedItem(false);
 
        addAndMakeVisible(m_grainDisplay.get());
        m_grainDisplay->toFront(false);
 
        addMouseListener(this, /*andChildComponents*/ true);
        m_sampleChooser = std::make_unique<FileChooser>(m_fileChooserWindowTitle,
                                                        (File::getSpecialLocation(File::userDocumentsDirectory)),
                                                        m_chooserAllowedFileTypes);
        startTimer(30);
    }
 
    void WaveformViewerAndEditor::timerCallback()
    {
        // Check for active grains before updating display to reduce idle CPU usage
        auto sampleEngine = m_grainDisplay->getDisplayedSampleEngine();
        if (sampleEngine != nullptr)
        {
            if (sampleEngine->isPlaying())
            {
                m_grainDisplay->update();
                m_frameCooldownCounter = 0;
            }
            // Draw a few frames after grains stop playing
            else if (m_frameCooldownCounter < FRAME_COOLDOWN)
            {
                m_frameCooldownCounter++;
                m_grainDisplay->update();
            }
        }
    }
 
    void WaveformViewerAndEditor::paintOverChildren(juce::Graphics& g)
    {
        if (!isEnabled()) // Only draw stuff if this component is enabled
            return;
 
        if (m_scrollManager.isSelectionEnabled())
        {
            // Draw in segment boundaries
            for (auto& selector : m_selectors)
            {
                float width = static_cast<float>(getWidth());
 
                // Draw in selection highlight
                float segmentPercentOfWaveformStart = static_cast<float>(selector.segment.getStart()) /
                                                      static_cast<float>(m_scrollManager.getLength());
                float segmentPercentOfWaveformEnd =
                        static_cast<float>(selector.segment.getEnd()) / static_cast<float>(m_scrollManager.getLength());
                float selectionPercentOfWaveformStart = static_cast<float>(selector.selection.getStart()) /
                                                        static_cast<float>(m_scrollManager.getLength());
                float selectionPercentOfWaveformEnd = static_cast<float>(selector.selection.getEnd()) /
                                                      static_cast<float>(m_scrollManager.getLength());
 
                // Draw in selected area shading
                g.setColour(m_colourDefinitions.selectedAreaShading);
                drawNormalisedZoomedRect(
                        g, Rectangle<float>(segmentPercentOfWaveformStart, 0.0f,
                                            selectionPercentOfWaveformStart - segmentPercentOfWaveformStart, 1.0f));
                drawNormalisedZoomedRect(
                        g, Rectangle<float>(selectionPercentOfWaveformEnd, 0.0f,
                                            segmentPercentOfWaveformEnd - selectionPercentOfWaveformEnd, 1.0f));
 
                // Draw in selection drag highlight
                if (selector.selectionHover.getVal() && !(selector.leftHover.getVal() || selector.rightHover.getVal()))
                {
                    g.setColour(m_colourDefinitions.draggedHighlight);
                    drawNormalisedZoomedRect(
                            g, Rectangle<float>(selectionPercentOfWaveformStart, m_layout.dragSelectAreaBoundary,
                                                selectionPercentOfWaveformEnd - selectionPercentOfWaveformStart, 1.0f));
                }
 
                // Draw in selection start - brighter when hovering
                g.setColour(selector.leftHover.getVal() ? m_colourDefinitions.selectionStartHover
                                                        : m_colourDefinitions.selectionStart);
                drawNormalisedZoomedLine(
                        g, Line<float>(selectionPercentOfWaveformStart, 0.f, selectionPercentOfWaveformStart, 1.f),
                        2.f);
 
                // Draw in selection end - brighter when hovering
                g.setColour(selector.rightHover.getVal() ? m_colourDefinitions.selectionEndHover
                                                         : m_colourDefinitions.selectionEnd);
                drawNormalisedZoomedLine(
                        g, Line<float>(selectionPercentOfWaveformEnd, 0.f, selectionPercentOfWaveformEnd, 1.f), 2.f);
            }
        }
    }
 
    void WaveformViewerAndEditor::addListener(Listener* Listener) { m_listeners.add(Listener); }
 
    void WaveformViewerAndEditor::removeListener(Listener* Listener) { m_listeners.remove(Listener); }
 
    void WaveformViewerAndEditor::resized()
    {
        auto bounds = getLocalBounds();
        m_waveformView->setBounds(bounds);
        m_grainDisplay->setBounds(bounds);
        zoomToSegment(m_nextSampleEngineSegment);
    }
 
    String WaveformViewerAndEditor::getFileName() { return m_fileName; }
 
    String WaveformViewerAndEditor::getLoadedFilePathsAsCSV()
    {
        if (m_grainDisplay == nullptr || m_grainDisplay->getDisplayedSampleEngine() == nullptr)
            return String();
 
        return m_grainDisplay->getDisplayedSampleEngine()->getGetLoadedFilePathsAsCSV();
    }
 
    void WaveformViewerAndEditor::update(AudioBuffer<float>* newAudio, int sampleRate)
    {
        m_waveformView->updateWaveformView(*newAudio);
        m_totalSampleLength = int(newAudio->getNumSamples());
        m_sampleRate = static_cast<float>(sampleRate);
        // Move and resize the scrollbar thumb
        m_listeners.call(&Listener::resizeScrollBarFromRange, m_scrollManager.getZoomWindowNormalisedToRange());
    }
 
    void WaveformViewerAndEditor::update(KrotosSampleOscillatorSound& sound)
    {
        auto sampleEngine = sound.getSampleEngine();
        update(dynamic_cast<AudioBuffer<float>*>(sampleEngine),
               static_cast<int>(sampleEngine->getSampleRate())); // Load newly assembled waveform into viewer
        setGrainData(sampleEngine->getGrainArray(), sampleEngine->getNumSamples(), sampleEngine->getNumChannels());
        setSampleEngineToDisplay(&sound);
    }
 
    void WaveformViewerAndEditor::setViewerDropText(String newText) { m_waveformView->setDropText(newText); }
 
    void WaveformViewerAndEditor::setViewCentre(float newRangeStart)
    {
        m_scrollManager.repositionZoomWindow(newRangeStart);
        setZooms(m_scrollManager.getZoomWindowNormalisedToLimits());
        repaint();
    }
 
    WaveformViewer* WaveformViewerAndEditor::getWaveformViewer() { return m_waveformView.get(); }
 
    void WaveformViewerAndEditor::clear()
    {
        if (m_waveformView)
        {
            m_waveformView->clear();
        }
        if (m_grainDisplay)
        {
            m_grainDisplay->setGrainData(nullptr, 0, 0);
            m_grainDisplay->setSampleEngineToDisplay(nullptr);
        }
    }
 
    void WaveformViewerAndEditor::setSelectionEnabled(bool newState) { m_scrollManager.setSelectionEnabled(newState); }
 
    void WaveformViewerAndEditor::setGrainData(Grain* grains, int numSamples, int numChannels)
    {
        m_grainDisplay->setGrainData(grains, numSamples, numChannels);
    }
 
    void WaveformViewerAndEditor::copySampleEngineSegmentToSelector(Selector& selector, int segmentIndex)
    {
        selector.selection.setStart(m_sampleEngine->getAudioSelectionStartPosition(segmentIndex));
        selector.selection.setLength(m_sampleEngine->getAudioSelectionLengthInSamples(segmentIndex));
        selector.segment.setStart(m_sampleEngine->getAudioSegmentStartPosition(segmentIndex));
        selector.segment.setLength(m_sampleEngine->getAudioSegmentLengthInSamples(segmentIndex));
    }
 
    void WaveformViewerAndEditor::copySegmentsToSelectors()
    {
        m_selectors.clear();
        if (m_sampleEngine->getNumAudioSegments() > 0)
        {
            for (int segmentIndex = 0; segmentIndex < m_sampleEngine->getNumAudioSegments(); segmentIndex++)
            {
                Selector newSelector;
                copySampleEngineSegmentToSelector(newSelector, segmentIndex);
                m_selectors.push_back(newSelector);
            }
            // The scroll manager needs to know the overall length of the audio buffer
            m_scrollManager.initialise(m_selectors.back().segment.getEnd());
 
            zoomToSegment(m_nextSampleEngineSegment);
        }
        else
        {
            // There are no segments, so initialise to 0
            m_scrollManager.initialise(0);
        }
    }
 
    void WaveformViewerAndEditor::setSampleEngineToDisplay(KrotosSampleOscillatorSound* sound)
    {
        if (sound == nullptr)
        {
            m_sampleEngine = nullptr;
            return;
        }
        m_sampleEngine = sound->getSampleEngine();
        if (m_sampleEngine == nullptr)
        {
            return;
        }
 
        m_grainDisplay->setSampleEngineToDisplay(sound);
 
        int numAudioSegments = m_sampleEngine->getNumAudioSegments();
 
        if (numAudioSegments == 0)
        {
            return;
        }
 
        copySegmentsToSelectors();
    }
 
    inline void WaveformViewerAndEditor::setZooms(const Range<float> newRange)
    {
        m_waveformView->setHorizontalZoomFromRange(newRange);
        m_grainDisplay->setHorizontalZoomFromRange(newRange);
        setHorizontalZoomFromRange(newRange);
    }
 
    Array<File> WaveformViewerAndEditor::getExtendedFilePaths(const StringArray& fileNames)
    {
        return m_waveformView->getExtendedFilePaths(fileNames);
    }
 
    int WaveformViewerAndEditor::mouseXToSampleX(int x)
    {
        // Calculate mousex position as a sample index into the sound buffer
        return m_scrollManager.percentMouseXToSampleXAbsolute(static_cast<float>(x) / static_cast<float>(getWidth()));
    }
 
    void WaveformViewerAndEditor::moveSelectionStart(int segmentIndex, int diff)
    {
        // Check that segmentIndex is within range
        jassert(segmentIndex >= 0 && segmentIndex < m_selectors.size() && m_selectors.size() > 0);
 
        auto newStart = m_selectors[segmentIndex].selection.getStart() + diff;
        // Clamp the new selection start position between the segment start and the selection end
        auto clipRange = Range<int>::between(m_selectors[segmentIndex].segment.getStart(),
                                             m_selectors[segmentIndex].selection.getEnd());
        auto clippedStart = clipRange.clipValue(newStart);
        m_selectors[segmentIndex].selection.setStart(clippedStart);
    }
 
    void WaveformViewerAndEditor::setSelectionStart(int segmentIndex, int newStart)
    {
        // Check that segmentIndex is within range
        jassert(segmentIndex >= 0 && segmentIndex < m_selectors.size() && m_selectors.size() > 0);
 
        // Clamp the new selection start position between the segment start and the selection end
        auto clipRange = Range<int>::between(m_selectors[segmentIndex].segment.getStart(),
                                             m_selectors[segmentIndex].segment.getEnd());
        auto clippedStart = clipRange.clipValue(newStart);
        m_selectors[segmentIndex].selection.setStart(clippedStart);
    }
 
    void WaveformViewerAndEditor::moveSelectionEnd(int segmentIndex, int diff)
    {
        // Check that segmentIndex is within range
        jassert(segmentIndex >= 0 && segmentIndex < m_selectors.size() && m_selectors.size() > 0);
 
        auto newEnd = m_selectors[segmentIndex].selection.getEnd() + diff;
        // Clamp the new selection end position between the segment end and the selection start
        auto clipRange = Range<int>::between(m_selectors[segmentIndex].selection.getStart(),
                                             m_selectors[segmentIndex].segment.getEnd());
        auto clippedEnd = clipRange.clipValue(newEnd);
        m_selectors[segmentIndex].selection.setEnd(clippedEnd);
    }
 
    void WaveformViewerAndEditor::setSelectionEnd(int segmentIndex, int newEnd)
    {
        // Check that segmentIndex is within range
        jassert(segmentIndex >= 0 && segmentIndex < m_selectors.size() && m_selectors.size() > 0);
 
        // Clamp the new selection end position between the segment end and the selection start
        auto clipRange = Range<int>::between(m_selectors[segmentIndex].segment.getStart(),
                                             m_selectors[segmentIndex].segment.getEnd());
        auto clippedEnd = clipRange.clipValue(newEnd);
        m_selectors[segmentIndex].selection.setEnd(clippedEnd);
    }
 
    void WaveformViewerAndEditor::moveSelection(int segmentIndex, int diff)
    {
        // Check that segmentIndex is within range
        jassert(segmentIndex >= 0 && segmentIndex < m_selectors.size() && m_selectors.size() > 0);
 
        auto selection = m_selectors[segmentIndex].selection;
        auto newStart = selection.getStart() + diff;
        auto movedSelection = selection.movedToStartAt(newStart);
        auto movedClampedSelection = m_selectors[segmentIndex].segment.constrainRange(movedSelection);
        m_selectors[segmentIndex].selection = movedClampedSelection;
    }
 
    Range<int> WaveformViewerAndEditor::getSelection(int segmentIndex)
    {
        // Check that segmentIndex is within range
        jassert(segmentIndex >= 0 && segmentIndex < m_selectors.size() && m_selectors.size() > 0);
        return m_selectors[segmentIndex].selection;
    }
 
    void WaveformViewerAndEditor::setHoverFromDirection(int segmentIndex, int mouseDeltaX)
    {
        // Check that segmentIndex is within range
        jassert(segmentIndex >= 0 && segmentIndex < m_selectors.size() && m_selectors.size() > 0);
        // If the mouse delta is negative, we know the mouse pointer is travelling from right to left
        // If this is the case we set the left hover true, otherwise we set the right hover true
        bool movingToTheLeft = mouseDeltaX < 0;
        m_selectors[segmentIndex].leftHover = movingToTheLeft;
        m_selectors[segmentIndex].rightHover = !movingToTheLeft;
    }
 
    void WaveformViewerAndEditor::mouseDown(const MouseEvent& e)
    {
        jassert(m_grainDisplay.get() != nullptr);
 
        if (m_selectors.size() <= 0)
        {
            showFileChooser();
            return;
        }
 
        m_middleMouseDown = e.mods.isMiddleButtonDown();
        if (m_middleMouseDown)
        {
            m_grainDisplay.get()->setMouseCursor(hoverModeToMouseCursor(HoverMode::segmentDrag));
        }
 
        // Start of a swipe right or swipe left selection ?
        // If the left mouse button is clicked when no hover is detected then
        // we set the start and end markers to the same position under the mouse pointer
        // Because doing this brings the start and selectors to the same position, both will have hover true
        // and this will be detected as an undecidedDrag - which be resolved when the mouse actually
        // drags and the direction of movement is deduced. The selector to be dragged will be set true
        // at this point, and that will be the start of a swipe selection
        if (m_hoverMode == HoverMode::noHover && e.mods.isLeftButtonDown())
        {
            int mouseX = e.getPosition().getX();
            int sampleMouseX = mouseXToSampleX(mouseX);
            setSelectionStart(m_activeSegmentIndex, sampleMouseX);
            setSelectionEnd(m_activeSegmentIndex, sampleMouseX);
            mouseMove();
            repaint();
        }
    }
 
    void WaveformViewerAndEditor::mouseDrag(const MouseEvent& e)
    {
        int mouseX = e.getPosition().getX();
 
        // Check if the user is dragging with the middle mouse button
        if (m_middleMouseDown && m_scrollManager.isZoomScrollEnabled())
        {
            m_scrollManager.drag(m_scrollManager.percentMouseXToSampleXRelative(static_cast<float>(m_mouseX - mouseX) /
                                                                                static_cast<float>(getWidth())));
            m_mouseX = mouseX;
            setZooms(m_scrollManager.getZoomWindowNormalisedToLimits());
            // Move and resize the scrollbar thumb
            m_listeners.call(&Listener::resizeScrollBarFromRange, m_scrollManager.getZoomWindowNormalisedToRange());
            repaint();
            return;
        }
 
        if (m_scrollManager.isSelectionEnabled())
        {
            // If audio segments count doesn't match the selectors count, we won't drag anything
            if (m_sampleEngine != nullptr && m_sampleEngine->getNumAudioSegments() != m_selectors.size())
            {
                return;
            }
 
            // Check that m_activeSegmentIndex is within range
            if (!(m_activeSegmentIndex >= 0 && m_activeSegmentIndex < m_selectors.size() && m_selectors.size() > 0))
            {
                return; // m_activeSegmentIndex is not within range, so we won't drag anything
            }
 
            int sampleMouseX = mouseXToSampleX(mouseX);
            int sampleMouseDeltaX = sampleMouseX - m_sampleMouseX;
            m_sampleMouseX = sampleMouseX;
 
            /*
                The only method which can change the waveform selections is this method, mouseDrag
                If a selection change is made we set the m_selectionChanged which will be
                picked up in the mouseup method as confirmation to set the Selctions parameter
            */
 
            switch (m_hoverMode)
            {
            // Changes the selection
            case HoverMode::leftEdgeDrag:
                moveSelectionStart(m_activeSegmentIndex, sampleMouseDeltaX);
                m_selectionChanged = true;
                repaint();
                break;
 
            // Changes the selection
            case HoverMode::rightEdgeDrag:
                moveSelectionEnd(m_activeSegmentIndex, sampleMouseDeltaX);
                m_selectionChanged = true;
                repaint();
                break;
 
            // Changes the selection
            case HoverMode::selectionDrag:
                moveSelection(m_activeSegmentIndex, sampleMouseDeltaX);
                m_selectionChanged = true;
                repaint();
                break;
 
            // Start and end markers are so close together that we use
            // the direction of travel of the mouse pointer to decide whether
            // to drag the start or the end marker
            case HoverMode::undecidedDrag:
                setHoverFromDirection(m_activeSegmentIndex, sampleMouseDeltaX);
                m_hoverMode = deduceSegmentHoverMode(m_activeSegmentIndex);
                m_grainDisplay.get()->setMouseCursor(hoverModeToMouseCursor(m_hoverMode));
                repaint();
                break;
            }
 
            if (m_selectionChanged)
            {
                // If the selection was changed, update the sample engine to reflect
                // Done here to give instant result if waveform is playing, rather than wait for mouse up
                auto newSelection = getSelection(m_activeSegmentIndex);
 
                m_sampleEngine->setAudioSelectionStartPositionAbsolute(m_activeSegmentIndex, newSelection.getStart());
                m_sampleEngine->setAudioSelectionLength(m_activeSegmentIndex, newSelection.getLength());
            }
        }
    }
 
    void WaveformViewerAndEditor::mouseUp(const MouseEvent& e)
    {
        m_middleMouseDown = e.mods.isMiddleButtonDown();
        m_grainDisplay.get()->setMouseCursor(hoverModeToMouseCursor(m_hoverMode));
        if (m_selectionChanged)
        {
            // We are not going to call selection changed listeners every time the mouse position increments
            // ... only on mouse up
            m_selectionChanged = false; // Cancel the flag
            // This will call back the listener in the KwidgetGUI_CoreEngine to
            // Update the Selections custom parameter
            m_listeners.call(&Listener::selectionsChanged, this, m_sampleEngine->getSelectionRanges());
        }
    }
 
    void WaveformViewerAndEditor::zoomByDelta(float delta)
    {
        if (m_scrollManager.isZoomScrollEnabled())
        {
            m_scrollManager.zoom(m_sampleMouseX, delta);
            setZooms(m_scrollManager.getZoomWindowNormalisedToLimits());
 
            // Move and resize the scrollbar thumb
            m_listeners.call(&Listener::resizeScrollBarFromRange, m_scrollManager.getZoomWindowNormalisedToRange());
        }
    }
 
    void WaveformViewerAndEditor::mouseWheelMove(const MouseEvent& e, const MouseWheelDetails& wheel)
    {
        if (m_scrollManager.isZoomScrollEnabled())
        {
            zoomByDelta(-wheel.deltaY * 0.1);
        }
    }
 
    WaveformViewerAndEditor::HoverMode WaveformViewerAndEditor::deduceSegmentHoverMode(int segmentIndex)
    {
        HoverMode retMode = HoverMode::noHover;
        if (m_selectors[segmentIndex].segmentHover.getVal())
        {
            if (m_selectors[segmentIndex].leftHover.getVal() && m_selectors[segmentIndex].rightHover.getVal())
            {
                retMode = HoverMode::undecidedDrag;
            }
            else if (m_selectors[segmentIndex].leftHover.getVal())
            {
                retMode = HoverMode::leftEdgeDrag;
            }
            else if (m_selectors[segmentIndex].rightHover.getVal())
            {
                retMode = HoverMode::rightEdgeDrag;
            }
            else if (m_selectors[segmentIndex].selectionHover.getVal())
            {
                retMode = HoverMode::selectionDrag;
            }
        }
        else
        {
            retMode = HoverMode::noHover;
        }
 
        return retMode;
    }
 
    MouseCursor WaveformViewerAndEditor::hoverModeToMouseCursor(HoverMode hMode)
    {
        MouseCursor customCursor;
 
        switch (hMode)
        {
        case HoverMode::segmentDrag:
            customCursor = MouseCursor(juce::MouseCursor::StandardCursorType::DraggingHandCursor);
            break;
 
        case HoverMode::selectionDrag:
            customCursor = MouseCursor(juce::MouseCursor::StandardCursorType::LeftEdgeResizeCursor);
            break;
 
        case HoverMode::undecidedDrag:
        case HoverMode::leftEdgeDrag:
        case HoverMode::rightEdgeDrag:
            customCursor = MouseCursor(juce::MouseCursor::StandardCursorType::PointingHandCursor);
            break;
 
        default:
        case HoverMode::noHover:
            customCursor = MouseCursor(juce::MouseCursor::StandardCursorType::NormalCursor);
            break;
        }
        return customCursor;
    }
 
    void WaveformViewerAndEditor::mouseMove(const MouseEvent& e)
    {
        m_mouseX = e.getPosition().getX();
        m_mouseY = e.getPosition().getY();
        mouseMove();
    }
 
    void WaveformViewerAndEditor::mouseMove()
    {
        m_sampleMouseX = mouseXToSampleX(m_mouseX);
 
        if (m_scrollManager.isSelectionEnabled())
        {
 
            bool inLowerZone =
                    m_mouseY > static_cast<int>(static_cast<float>(getHeight()) * m_layout.dragSelectAreaBoundary);
 
            // Loop through all the selectors checking whether we are hovering over any of them
            bool m_changed = false;
            int index = 0;
            for (auto& selector : m_selectors)
            {
                // Set true if hovering over segment
                selector.segmentHover = selector.segment.contains(m_sampleMouseX);
 
                // Set true if hovering over selection
                selector.selectionHover = selector.selection.contains(m_sampleMouseX) && inLowerZone;
 
                // If hovering over segment
                if (selector.segmentHover.getVal())
                {
                    // Convert pixel tolerance into buffer samples for comparison with buffer sample positions
                    int tolerance = m_scrollManager.pixelsToSamples(m_layout.endMarkerPixelTolerance, getWidth());
                    // Set true if near left edge
                    selector.leftHover = abs(selector.selection.getStart() - m_sampleMouseX) < tolerance;
                    // Set true if near right edge
                    selector.rightHover = abs(selector.selection.getEnd() - m_sampleMouseX) < tolerance;
                }
                else
                {
                    selector.leftHover = false;
                    selector.rightHover = false;
                }
 
                // Take note whether there was a change in any of the hover states
                m_changed |= selector.segmentHover.hasChanged();
                m_changed |= selector.selectionHover.hasChanged();
                m_changed |= selector.leftHover.hasChanged();
                m_changed |= selector.rightHover.hasChanged();
 
                if (selector.segmentHover.getVal())
                {
                    m_activeSegmentIndex = index;
                }
 
                index++;
            }
 
            if (m_changed)
            {
                // At this point we should really call setMouseCursor( customCursor );
                // to update the mouse cursor. This has been tested, and does work when this component
                // has no children. However, it stops working when GrainDisplay is added as a child component
                // It was discovered that calling the same method on the grain display component does work
                m_hoverMode = deduceSegmentHoverMode(m_activeSegmentIndex);
                m_grainDisplay.get()->setMouseCursor(hoverModeToMouseCursor(m_hoverMode));
 
                // We only trigger a repaint if something has changed
                repaint();
            }
        }
    }
 
    void WaveformViewerAndEditor::mouseEnter(const MouseEvent& event)
    {
        m_waveformView->setHoverState(true);
        repaint();
    }
 
    void WaveformViewerAndEditor::mouseExit(const MouseEvent& e)
    {
        m_waveformView->setHoverState(false);
        for (auto& selector : m_selectors)
        {
            selector.segmentHover = false;
            selector.selectionHover = false;
            selector.leftHover = false;
            selector.rightHover = false;
        }
        repaint();
    }
 
    bool WaveformViewerAndEditor::isInterestedInFileDrag(const StringArray& files)
    {
        return m_waveformView->isInterestedInFileDrag(files);
    }
 
    void WaveformViewerAndEditor::filesDropped(const StringArray& files, int /* x */, int /* y */)
    {
        if (!isEnabled())
            return;
 
        reportAnyInvalidFiles(files);
 
        if (isInterestedInFileDrag(files))
        {
            m_listeners.call(&Listener::fileHasBeenDropped, this, files);
            copySegmentsToSelectors(); // Update the selectors
            m_waveformView->fileDragExit(files);
        }
    }
 
    void WaveformViewerAndEditor::fileDragEnter(const StringArray& files, int x, int y)
    {
        m_waveformView->fileDragEnter(files, x, y);
    }
 
    void WaveformViewerAndEditor::fileDragExit(const StringArray& files) { m_waveformView->fileDragExit(files); }
 
    void WaveformViewerAndEditor::reportAnyInvalidFiles(const StringArray& filelist)
    {
        int invalidFiles(0);
        for (auto filepath : filelist)
        {
            File f(filepath);
            if (f.hasFileExtension(m_validFileExtensions) == false)
            {
                invalidFiles++;
            }
        }
        if (invalidFiles == 0)
        {
            m_waveformView->setDropText("");
        }
        else
        {
            invalidFiles == 1 ? m_waveformView->setDropText("Sample Failed to Import")
                              : m_waveformView->setDropText(String(invalidFiles) + " Samples Failed to Import");
        }
    }
 
    void WaveformViewerAndEditor::showFileChooser()
    {
        const int fileFlags = FileBrowserComponent::canSelectFiles | FileBrowserComponent::canSelectMultipleItems;
        m_sampleChooser->launchAsync(fileFlags, [this](const FileChooser& fileChooser) {
            if (fileChooser.getResults().isEmpty() == false)
            {
                StringArray filePaths;
                for (auto file : fileChooser.getResults())
                {
                    filePaths.add(file.getFullPathName());
                }
                if (!filePaths.isEmpty())
                {
                    // If a file/files have/has been chosen, we just carry on exactly as if file/s had
                    // been dropped into the waveform area
                    filesDropped(filePaths, 0, 0);
                }
            }
        });
    }
 
    void WaveformViewerAndEditor::zoomIn()
    {
        if (m_zoomStyle == ZoomStyle::centre)
        {
            m_sampleMouseX = mouseXToSampleX(getWidth() * 0.5f);
        }
        zoomByDelta(-0.1f);
    }
 
    void WaveformViewerAndEditor::zoomOut()
    {
        if (m_zoomStyle == ZoomStyle::centre)
        {
            m_sampleMouseX = mouseXToSampleX(getWidth() * 0.5f);
        }
        zoomByDelta(0.1f);
    }
 
    void WaveformViewerAndEditor::setZoomStyle(ZoomStyle zoomStyle) { m_zoomStyle = zoomStyle; }
 
    void WaveformViewerAndEditor::setChildComponentIds(String newId)
    {
        m_grainDisplay->setComponentID(newId);
        m_waveformView->setComponentID(newId);
    }
 
    void WaveformViewerAndEditor::zoomToSegment(size_t segmentIndex)
    {
        m_nextSampleEngineSegment = segmentIndex;
 
        if (m_scrollManager.isZoomScrollEnabled())
        {
            auto segment = m_sampleEngine->getAudioSegments()[segmentIndex];
 
            m_scrollManager.setZoomRange(
                    Range<int>(segment.segmentStartPosition, segment.segmentStartPosition + segment.segmentLength));
 
            setZooms(m_scrollManager.getZoomWindowNormalisedToLimits());
 
            // Move and resize the scrollbar thumb
            m_listeners.call(&Listener::resizeScrollBarFromRange, m_scrollManager.getZoomWindowNormalisedToRange());
        }
    };
 
} // namespace krotos