KwidgetGUI_CoreEngine.cpp

Go to the documentation of this file.

namespace krotos
{
    const String KwidgetGUI_CoreEngine::ComponentIds::ComboboxTriggerId("Trigger");
    const String KwidgetGUI_CoreEngine::ComponentIds::ComboboxModeId("Mode");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderLevelGranularId("GranularLevel");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderLevelSamplerId("SamplerLevel");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderLevelRandId("LevelRND");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderPanId("Pan");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderPanRandId("PanRND");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderPitchSamplerId("SamplerPitch");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderPitchGranularId("GranularPitch");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderGrainMaxId("GrainMax");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderGrainShapeId("GrainShape");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderGrainStartId("GrainStart");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderGrainSizeId("GrainSize");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderGrainRateId("GrainRate");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderGrainWidthId("GrainWidth");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderGrainStartRNDId("GrainStartRND");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderGrainSizeRNDId("GrainSizeRND");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderGrainRateRNDId("GrainRateRND");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderGrainWidthRNDId("GrainWidthRND");
    const String KwidgetGUI_CoreEngine::ComponentIds::SliderPitchGranularRNDId("GranularPitchRND");
    const String KwidgetGUI_CoreEngine::ComponentIds::ButtonMuteId("Mute");
    const String KwidgetGUI_CoreEngine::ComponentIds::ButtonSoloId("Solo");
    const String KwidgetGUI_CoreEngine::ComponentIds::ButtonRoundRobinId("RoundRobin");
    const String KwidgetGUI_CoreEngine::ComponentIds::ButtonAutoplayId("Autoplay");
    const String KwidgetGUI_CoreEngine::ComponentIds::ButtonReleaseTriggerId("ReleaseTrigger");
    const String KwidgetGUI_CoreEngine::ComponentIds::ButtonLoopToggleSamplerId("LoopSampler");
    const String KwidgetGUI_CoreEngine::ComponentIds::ButtonLoopToggleGranularId("LoopGranular");
    const String KwidgetGUI_CoreEngine::ComponentIds::ButtonNormaliseToggleId("Normalise");
    const String KwidgetGUI_CoreEngine::ComponentIds::ButtonSampleBrowserId("SampleSelectDropdown");
    const String KwidgetGUI_CoreEngine::ComponentIds::ButtonZoomInId("WaveformZoomIn");
    const String KwidgetGUI_CoreEngine::ComponentIds::ButtonZoomOutId("WaveformZoomOut");
    const String KwidgetGUI_CoreEngine::ComponentIds::ScrollBarWaveformViewId("Zoom");
    const String KwidgetGUI_CoreEngine::ComponentIds::WaveformViewerId("Waveform");
    const String KwidgetGUI_CoreEngine::ComponentIds::ButtonClearEngineId("ClearEngine");
    const std::string KwidgetGUI_CoreEngine::analyticsEventClearedEngine{"analyticsEventClearedEngine"};
    const std::string KwidgetGUI_CoreEngine::analyticsEventAddedSamplesEngine{"analyticsEventAddedSamplesEngine"};
    const std::string KwidgetGUI_CoreEngine::analyticsEventChangedMidiTriggerEngine{
            "analyticsEventChangedMidiTriggerEngine"};
    const std::string KwidgetGUI_CoreEngine::analyticsEventRemovedEngine{"analyticsEventRemovedEngine"};
    using Parameters = Kwidget_CoreEngine::Parameters;
 
    KwidgetGUI_CoreEngine::KwidgetGUI_CoreEngine(Kwidget& owner, KrotosSampleOscillatorSound& sound)
        : KwidgetGUI(owner), m_soSound(sound), m_owner(owner),
          m_zoomInButtonImage(
                  Drawable::createFromImageData(KrotosBinaryData::Plus_Icon_svg, KrotosBinaryData::Plus_Icon_svgSize)),
          m_zoomInButtonImageMouseOver(
                  Drawable::createFromImageData(KrotosBinaryData::Plus_Icon_svg, KrotosBinaryData::Plus_Icon_svgSize)),
          m_zoomOutButtonImage(Drawable::createFromImageData(KrotosBinaryData::Minus_Icon_svg,
                                                             KrotosBinaryData::Minus_Icon_svgSize)),
          m_zoomOutButtonImageMouseOver(Drawable::createFromImageData(KrotosBinaryData::Minus_Icon_svg,
                                                                      KrotosBinaryData::Minus_Icon_svgSize)),
          m_sampleBrowserButton(""), m_removeEngineButton("", DrawableButton::ImageStretched)
    {
        // TODO: Fix the these var names, m_size instead of m_Size etc...
 
        // Labels
        addAndMakeVisible(m_coreEngineNameLabel);
        m_coreEngineNameLabel.setFont(Font(m_layout.modeFontSize).withExtraKerningFactor(m_layout.modeExtraKerning));
 
        // Sliders
        m_Start.getSlider().setTextValueSuffix(" % ");
        addAttachedComponent(m_Start, Parameters::Start);
        m_Start.setComponentID(KwidgetGUI_CoreEngine::ComponentIds::SliderGrainStartId);
        m_Size.getSlider().setTextValueSuffix(" % ");
        addAttachedComponent(m_Size, Parameters::Size);
        m_Size.setComponentID(KwidgetGUI_CoreEngine::ComponentIds::SliderGrainSizeId);
        addAttachedComponent(m_Rate, Parameters::Rate);
        m_Rate.setComponentID(KwidgetGUI_CoreEngine::ComponentIds::SliderGrainRateId);
        addAttachedComponent(m_Detune, Parameters::Pitch);
        addAttachedComponent(m_Width, Parameters::Width);
        m_Width.setComponentID(KwidgetGUI_CoreEngine::ComponentIds::SliderGrainWidthId);
        addAttachedComponent(m_Pan, Parameters::Pan);
        addAttachedComponent(m_Level, Parameters::Level);
        addAttachedComponent(m_SamplerLevel, Parameters::SamplerLevel);
        addAttachedComponent(m_GranularLevel, Parameters::GranularLevel);
        addAttachedComponent(m_VehicleLevel, Parameters::VehicleLevel);
 
        // Slider specific layout
        m_Level.getSlider().setSliderStyle(Slider::SliderStyle::LinearHorizontal);
        m_Level.setLabelPosition(AttachedSlider::LabelPosition::Above);
        m_Level.setValueSuffix("dB");
        m_Level.setValueFormat("%.1f");
 
        m_LevelRand.getSlider().setSliderStyle(Slider::SliderStyle::LinearHorizontal);
        m_LevelRand.getSlider().setComponentID(ComponentIds::SliderLevelRandId);
        m_LevelRand.getLabel().setComponentID(ComponentIds::SliderLevelRandId);
        m_LevelRand.setLabelPosition(AttachedSlider::LabelPosition::Left);
        m_LevelRand.setValueFormat("%.1f");
 
        m_Pan.getSlider().setSliderStyle(Slider::SliderStyle::LinearHorizontal);
        m_Pan.setLabelPosition(AttachedSlider::LabelPosition::Above);
        m_Pan.setValueFormat("%.1f");
        m_Pan.getSlider().setComponentID(ComponentIds::SliderPanId);
        m_Pan.getLabel().setComponentID(ComponentIds::SliderPanId);
 
        m_PanRand.getSlider().setSliderStyle(Slider::SliderStyle::LinearHorizontal);
        m_PanRand.getSlider().setComponentID(ComponentIds::SliderPanRandId);
        m_PanRand.getLabel().setComponentID(ComponentIds::SliderPanRandId);
        m_PanRand.setLabelPosition(AttachedSlider::LabelPosition::Left);
        m_PanRand.setValueFormat("%.1f");
 
        m_Start.setLabelPosition(AttachedSlider::LabelPosition::Above);
        m_Size.setLabelPosition(AttachedSlider::LabelPosition::Above);
        m_Rate.setLabelPosition(AttachedSlider::LabelPosition::Above);
        m_Detune.setLabelPosition(AttachedSlider::LabelPosition::Above);
        m_Width.setLabelPosition(AttachedSlider::LabelPosition::Above);
        m_GranularLevel.setLabelPosition(AttachedSlider::LabelPosition::Above);
        m_SamplerLevel.setLabelPosition(AttachedSlider::LabelPosition::Above);
 
        // Rand Sliders
        addAttachedComponent(m_StartRand, Parameters::StartRand);
        m_StartRand.setComponentID(KwidgetGUI_CoreEngine::ComponentIds::SliderGrainStartRNDId);
        addAttachedComponent(m_SizeRand, Parameters::SizeRand);
        m_SizeRand.setComponentID(KwidgetGUI_CoreEngine::ComponentIds::SliderGrainSizeRNDId);
        addAttachedComponent(m_RateRand, Parameters::RateRand);
        m_RateRand.setComponentID(KwidgetGUI_CoreEngine::ComponentIds::SliderGrainRateRNDId);
        addAttachedComponent(m_DetuneRand, Parameters::PitchRand);
        m_DetuneRand.setComponentID(KwidgetGUI_CoreEngine::ComponentIds::SliderPitchGranularRNDId);
        addAttachedComponent(m_WidthRand, Parameters::WidthRand);
        m_WidthRand.setComponentID(KwidgetGUI_CoreEngine::ComponentIds::SliderGrainWidthRNDId);
        addAttachedComponent(m_PanRand, Parameters::PanRand);
        addAttachedComponent(m_LevelRand, Parameters::LevelRand);
 
        // Extras Sliders
        addAttachedComponent(m_Shape, Parameters::Shape);
        m_Shape.setComponentID(KwidgetGUI_CoreEngine::ComponentIds::SliderGrainShapeId);
        addAttachedComponent(m_GrainMax, Parameters::GrainMax);
        m_GrainMax.setComponentID(KwidgetGUI_CoreEngine::ComponentIds::SliderGrainMaxId);
        addAttachedComponent(m_Distance, Parameters::Distance);
        addAttachedComponent(m_Tracking, Parameters::Tracking);
        addAttachedComponent(m_Cycles, Parameters::Cycles);
 
        // Vehicle Sliders
        addAttachedComponent(m_Smoothing, Parameters::Smoothing);
        addAttachedComponent(m_Sensitivity, Parameters::Sensitivity);
        addAttachedComponent(m_ASize, Parameters::ASize);
        addAttachedComponent(m_ARate, Parameters::ARate);
        addAttachedComponent(m_ASpray, Parameters::ASpray);
        addAttachedComponent(m_AMix, Parameters::AMix);
        addAttachedComponent(m_BSize, Parameters::BSize);
        addAttachedComponent(m_BRate, Parameters::BRate);
        addAttachedComponent(m_BSpray, Parameters::BSpray);
        addAttachedComponent(m_BMix, Parameters::BMix);
 
        // Mute- Solo Text Buttons
        m_muteButtonAttachment = createParameterAttachment(Parameters::Mute, m_muteButton);
        m_soloButtonAttachment = createParameterAttachment(Parameters::Solo, m_soloButton);
 
        // Mode select combobox
        addAttachedComponent(m_mode, Parameters::Mode);
 
        // Trigger select combobox - adds and makes visible
        addAndMakeVisible(m_trigger);
        m_trigger.addItemList(Kwidget_CoreEngine::MIDIModeNames, /*itemOffset*/ 1);
        m_trigger.setSelectedId(static_cast<int>(MIDIMode::All) + 1); // add offset
 
        // Vehicle colours
        m_ASize.setDebugColour(Colours::sandybrown);
        m_ARate.setDebugColour(Colours::sandybrown);
        m_ASpray.setDebugColour(Colours::sandybrown);
        m_AMix.setDebugColour(Colours::sandybrown);
        m_BSize.setDebugColour(Colours::sandybrown);
        m_BRate.setDebugColour(Colours::sandybrown);
        m_BSpray.setDebugColour(Colours::sandybrown);
        m_BMix.setDebugColour(Colours::sandybrown);
        m_Tracking.setDebugColour(Colours::sandybrown);
        m_Cycles.setDebugColour(Colours::sandybrown);
        m_Smoothing.setDebugColour(Colours::sandybrown);
        m_Sensitivity.setDebugColour(Colours::sandybrown);
 
        // Misc colours
        m_Shape.setDebugColour(Colours::darkred);
        m_GrainMax.setDebugColour(Colours::darkred);
 
        addAndMakeVisible(m_clearButton);
        addAndMakeVisible(m_tweakButton1);
        addAndMakeVisible(m_tweakButton2);
 
        Kwidget_CoreEngine* owningKwidget = dynamic_cast<Kwidget_CoreEngine*>(&getOwner());
 
        if (owningKwidget != nullptr)
        {
            // init right panel tabbed component
            initialiseTabbedComponent();
            // TODO: Fix the these var names, m_size instead of m_Size etc...!
 
            // Sliders
            m_Start.getSlider().setTextValueSuffix(" % ");
            addAttachedComponent(m_mainTab, m_Start, Parameters::Start);
            m_Size.getSlider().setTextValueSuffix(" % ");
            addAttachedComponent(m_mainTab, m_Size, Parameters::Size);
            addAttachedComponent(m_mainTab, m_Rate, Parameters::Rate);
            addAttachedComponent(m_mainTab, m_Detune, Parameters::Pitch);
            addAttachedComponent(m_mainTab, m_Width, Parameters::Width);
            addAttachedComponent(m_Pan, Parameters::Pan);
            addAttachedComponent(m_PanRand, Parameters::PanRand);
            addAttachedComponent(m_Level, Parameters::Level);
            addAttachedComponent(m_LevelRand, Parameters::LevelRand);
            addAttachedComponent(m_mainTab, m_SamplerLevel, Parameters::SamplerLevel);
            addAttachedComponent(m_mainTab, m_GranularLevel, Parameters::GranularLevel);
            addAttachedComponent(m_VehicleLevel, Parameters::VehicleLevel);
 
            // Slider specific layout
            m_Pan.getSlider().setSliderStyle(Slider::SliderStyle::LinearHorizontal);
            m_Pan.setValueFormat("%.1f");
 
            m_Level.getSlider().setSliderStyle(Slider::SliderStyle::LinearHorizontal);
            m_Level.setValueSuffix("dB");
            m_Level.setValueFormat("%.1f");
 
            // Rand Sliders
            addAttachedComponent(m_randTab, m_StartRand, Parameters::StartRand);
            addAttachedComponent(m_randTab, m_SizeRand, Parameters::SizeRand);
            addAttachedComponent(m_randTab, m_RateRand, Parameters::RateRand);
            addAttachedComponent(m_randTab, m_WidthRand, Parameters::WidthRand);
 
            // Extras Sliders
            addAttachedComponent(m_extrasTab, m_Shape, Parameters::Shape);
            addAttachedComponent(m_extrasTab, m_GrainMax, Parameters::GrainMax);
            addAttachedComponent(m_extrasTab, m_Distance, Parameters::Distance);
            addAttachedComponent(m_Tracking, Parameters::Tracking);
            addAttachedComponent(m_Cycles, Parameters::Cycles);
 
            // Vehicle Sliders
            addAttachedComponent(m_Smoothing, Parameters::Smoothing);
            addAttachedComponent(m_Sensitivity, Parameters::Sensitivity);
            addAttachedComponent(m_ASize, Parameters::ASize);
            addAttachedComponent(m_ARate, Parameters::ARate);
            addAttachedComponent(m_ASpray, Parameters::ASpray);
            addAttachedComponent(m_AMix, Parameters::AMix);
            addAttachedComponent(m_BSize, Parameters::BSize);
            addAttachedComponent(m_BRate, Parameters::BRate);
            addAttachedComponent(m_BSpray, Parameters::BSpray);
            addAttachedComponent(m_BMix, Parameters::BMix);
 
            // Mute- Solo Text Buttons
            m_muteButtonAttachment = createParameterAttachment(Parameters::Mute, m_muteButton);
            m_soloButtonAttachment = createParameterAttachment(Parameters::Solo, m_soloButton);
 
            // Mode select combobox
            m_mode.getControlComponent().setComponentID(ComponentIds::ComboboxModeId);
            addAttachedComponent(m_mode, Parameters::Mode);
 
            // Trigger select combobox - adds and makes visible
            m_trigger.setComponentID(ComponentIds::ComboboxTriggerId);
            // set initial m_trigger selected ID
            CustomParameter* midiParameter(m_owner.getCustomParameter(Kwidget_CoreEngine::Parameters::MIDIMode));
            if (midiParameter != nullptr)
            {
                const String midiName = midiParameter->getValue();
                if (Kwidget_CoreEngine::MIDIModeNames.contains(midiName))
                {
                    m_trigger.setSelectedId(Kwidget_CoreEngine::MIDIModeNames.indexOf(midiName) +
                                            1); //+1 for combobox offset
                }
            }
            m_trigger.onChange = [this] {
                // Send midi note change to the sample engine
                const int newMidiMode = Kwidget_CoreEngine::MIDIModeNames.indexOf(m_trigger.getText());
                Kwidget_CoreEngine& owner = dynamic_cast<Kwidget_CoreEngine&>(m_owner);
                if (&owner != nullptr)
                {
                    owner.setActiveMidiMode(static_cast<MIDIMode>(newMidiMode));
                }
                if (m_notifyMidiTriggerChange)
                {
                    // Mixpanel analytics: Midi note trigger selection
                    sendActionMessage(analyticsEventChangedMidiTriggerEngine);
                }
            };
 
            // Vehicle colours
            m_ASize.setDebugColour(Colours::sandybrown);
            m_ARate.setDebugColour(Colours::sandybrown);
            m_ASpray.setDebugColour(Colours::sandybrown);
            m_AMix.setDebugColour(Colours::sandybrown);
            m_BSize.setDebugColour(Colours::sandybrown);
            m_BRate.setDebugColour(Colours::sandybrown);
            m_BSpray.setDebugColour(Colours::sandybrown);
            m_BMix.setDebugColour(Colours::sandybrown);
            m_Tracking.setDebugColour(Colours::sandybrown);
            m_Cycles.setDebugColour(Colours::sandybrown);
            m_Smoothing.setDebugColour(Colours::sandybrown);
            m_Sensitivity.setDebugColour(Colours::sandybrown);
 
            // Misc colours
            m_Shape.setDebugColour(Colours::darkred);
            m_GrainMax.setDebugColour(Colours::darkred);
 
            addAndMakeVisible(m_clearButton);
            addAndMakeVisible(m_tweakButton1);
            addAndMakeVisible(m_tweakButton2);
 
            m_tweakButton1.setEnabled(false);
            m_tweakButton2.setEnabled(false);
        }
 
        addAndMakeVisible(m_muteButton);
        m_muteButton.setComponentID(ComponentIds::ButtonMuteId);
        addAndMakeVisible(m_soloButton);
        m_soloButton.setComponentID(ComponentIds::ButtonSoloId);
 
        m_defaultDeleteButton = Drawable::createFromImageData(KrotosBinaryData::remove_engine_icon_default_png,
                                                              KrotosBinaryData::remove_engine_icon_default_pngSize);
 
        m_hoverDeleteButton = Drawable::createFromImageData(KrotosBinaryData::remove_engine_icon_hover_png,
                                                            KrotosBinaryData::remove_engine_icon_hover_pngSize);
 
        // delete button
        addAndMakeVisible(m_removeEngineButton);
        m_removeEngineButton.setComponentID(ComponentIds::ButtonClearEngineId);
        m_removeEngineButton.toFront(true);
        m_removeEngineButton.setImages(
                /*normal*/ m_defaultDeleteButton.get(),
                /* hover */ m_hoverDeleteButton.get(),
                /* clicked */ m_hoverDeleteButton.get());
 
        m_removeEngineButton.onClick = [&]() {
            if (onDelete)
            {
                std::function<void(int)> removeEngineCallback = [this](int option) {
                    if (option == 0) // clicked remove
                    {
                        // Mixpanel analytics: removed engine
                        sendActionMessage(analyticsEventRemovedEngine);
 
                        // defer deletion to ensure the action message is sent and processed
                        MessageManager::callAsync([this]() {
                            auto ownerId = m_owner.getKwidgetID();
                            onDelete(ownerId);
                        });
                    }
                };
 
                getProperties().set(Krotos_LookAndFeel::Properties::AlertWindow::AlertWidthID, 440);
                getProperties().set(Krotos_LookAndFeel::Properties::AlertWindow::AlertHeightID, 172);
 
                AlertWindow::showAsync(MessageBoxOptions()
                                               .withIconType(MessageBoxIconType::WarningIcon)
                                               .withTitle("Removing Engine")
                                               .withMessage("Are you sure you want to proceed with the\nremoval? This "
                                                            "action cannot be undone!")
                                               .withButton("Cancel")
                                               .withButton("Remove")
                                               .withAssociatedComponent(this),
                                       removeEngineCallback);
            }
        };
 
        addAndMakeVisible(m_QuenchToggle);
        addAndMakeVisible(m_NORToggle);
        m_NORToggle.getButton().setComponentID(ComponentIds::ButtonReleaseTriggerId);
        addAndMakeVisible(m_AutoRateToggle);
        addAndMakeVisible(m_PhaseLockToggle);
        addAndMakeVisible(m_PhaseSyncToggle);
        addAndMakeVisible(m_NormaliseToggle);
        m_NormaliseToggle.getButton().setComponentID(ComponentIds::ButtonNormaliseToggleId);
        addAndMakeVisible(m_AutoplayToggle);
        addAndMakeVisible(m_EnableMuteUpToggle);
        addAndMakeVisible(m_EnableMuteDownToggle);
        addAndMakeVisible(m_SALoopToggle);
        addAndMakeVisible(m_RobinToggle);
 
        // Lets get a callback when the mode combobox changes, so we can set engine slider defaults
        // we don't want this to happen when the attached parameter changes - only when the user manually changes the
        // mode
        m_mode.onStateChange = [this] {
            Kwidget_CoreEngine::EngineMode mode =
                    static_cast<Kwidget_CoreEngine::EngineMode>(m_mode.getControlComponent().getSelectedItemIndex());
            switch (mode)
            {
            case Kwidget_CoreEngine::EngineMode::modeGranular:
                getOwner().getParameter(Parameters::Rate)->set(11.6f);
                getOwner().getParameter(Parameters::Start)->set(0.f);
                m_waveformViewerAndEditor->setStartPosInPercentage(0.f);
                getOwner().getParameter(Parameters::Size)->set(100.f);
                m_waveformViewerAndEditor->setEndPosInPercentage(1.f);
                getOwner().getParameter(Parameters::Pitch)->set(0.f);
                getOwner().getParameter(Parameters::Width)->set(1.f);
                getOwner().getParameter(Parameters::Level)->set(0.f);
                getOwner().getParameter(Parameters::GrainMax)->set(25.f);
                getOwner().getParameter(Parameters::Shape)->set(0.5f);
                getOwner().getParameter(Parameters::Pan)->set(0.f);
                getOwner().getParameter(Parameters::StartRand)->set(0.1f);
                getOwner().getParameter(Parameters::SizeRand)->set(0.14f);
                getOwner().getParameter(Parameters::RateRand)->set(0.037f);
                getOwner().getParameter(Parameters::PitchRand)->set(0.028f);
                getOwner().getParameter(Parameters::WidthRand)->set(0.f);
                getOwner().getParameter(Parameters::PanRand)->set(0.04f);
                getOwner().getParameter(Parameters::LevelRand)->set(0.053f);
                break;
            case Kwidget_CoreEngine::EngineMode::modeSampler:
                getOwner().getParameter(Parameters::Rate)->set(0.f);
                getOwner().getParameter(Parameters::Start)->set(0.f);
                m_waveformViewerAndEditor->setStartPosInPercentage(0.f);
                getOwner().getParameter(Parameters::Size)->set(100.0f);
                m_waveformViewerAndEditor->setEndPosInPercentage(1.f);
                getOwner().getParameter(Parameters::Pitch)->set(0.f);
                getOwner().getParameter(Parameters::Width)->set(0.f);
                getOwner().getParameter(Parameters::Level)->set(0.f);
                getOwner().getParameter(Parameters::GrainMax)->set(25.f);
                getOwner().getParameter(Parameters::Shape)->set(0.f);
                getOwner().getParameter(Parameters::Pan)->set(0.f);
                getOwner().getParameter(Parameters::StartRand)->set(0.f);
                getOwner().getParameter(Parameters::SizeRand)->set(0.f);
                getOwner().getParameter(Parameters::RateRand)->set(0.f);
                getOwner().getParameter(Parameters::PitchRand)->set(0.f);
                getOwner().getParameter(Parameters::WidthRand)->set(0.f);
                getOwner().getParameter(Parameters::PanRand)->set(0.f);
                getOwner().getParameter(Parameters::LevelRand)->set(0.f);
                break;
            case Kwidget_CoreEngine::EngineMode::modeVehicle:
                getOwner().getParameter(Parameters::Rate)->set(0.f);
                getOwner().getParameter(Parameters::Start)->set(50.f);
                getOwner().getParameter(Parameters::Size)->set(0.f);
                getOwner().getParameter(Parameters::Pitch)->set(0.f);
                getOwner().getParameter(Parameters::Width)->set(0.f);
                getOwner().getParameter(Parameters::Level)->set(0.f);
                getOwner().getParameter(Parameters::GrainMax)->set(25.f);
                getOwner().getParameter(Parameters::Shape)->set(1.f);
                getOwner().getParameter(Parameters::Pan)->set(0.f);
                getOwner().getParameter(Parameters::StartRand)->set(0.f);
                getOwner().getParameter(Parameters::SizeRand)->set(0.f);
                getOwner().getParameter(Parameters::RateRand)->set(0.f);
                getOwner().getParameter(Parameters::PitchRand)->set(0.f);
                getOwner().getParameter(Parameters::WidthRand)->set(0.f);
                getOwner().getParameter(Parameters::PanRand)->set(0.f);
                getOwner().getParameter(Parameters::LevelRand)->set(0.f);
 
                getOwner().getParameter(Parameters::Tracking)->set(0.02f);
                getOwner().getParameter(Parameters::Cycles)->set(1.0f);
                getOwner().getParameter(Parameters::Smoothing)->set(0.5f);
                getOwner().getParameter(Parameters::Sensitivity)->set(0.612f);
 
                getOwner().getParameter(Parameters::ASize)->set(4.4f);
                getOwner().getParameter(Parameters::ARate)->set(1.f);
                getOwner().getParameter(Parameters::ASpray)->set(0.12f);
                getOwner().getParameter(Parameters::AMix)->set(0.2f);
 
                getOwner().getParameter(Parameters::BSize)->set(2.0f);
                getOwner().getParameter(Parameters::BRate)->set(1.f);
                getOwner().getParameter(Parameters::BSpray)->set(0.f);
                getOwner().getParameter(Parameters::BMix)->set(0.8f);
                break;
            }
 
            getOwner().getParameter(Parameters::Normalise)->set(0.f);
            getOwner().getParameter(Parameters::Quench)->set(0.f);
            getOwner().getParameter(Parameters::NOR)->set(0.f);
            getOwner().getParameter(Parameters::Robin)->set(0.f);
            getOwner().getParameter(Parameters::SALoop)->set(0.f);
            getOwner().getParameter(Parameters::Autoplay)->set(0.f);
        };
 
        m_clearButton.setButtonText("CLEAR");
        m_clearButton.onClick = [this] { clearEngine(); };
 
        // Mute Button
        m_muteButton.setClickingTogglesState(true);
        m_muteButton.setButtonText("M");
 
        // Solo Button
        m_soloButton.setClickingTogglesState(true);
        m_soloButton.setButtonText("S");
 
        // Toggle Switches
        m_QuenchToggle.getAttachment() = createParameterAttachment(Parameters::Quench, m_QuenchToggle.getButton());
        m_NORToggle.getAttachment() = createParameterAttachment(Parameters::NOR, m_NORToggle.getButton());
        m_RobinToggle.getAttachment() = createParameterAttachment(Parameters::Robin, m_RobinToggle.getButton());
        m_RobinToggle.getButton().setComponentID(ComponentIds::ButtonRoundRobinId);
        m_SALoopToggle.getAttachment() = createParameterAttachment(Parameters::SALoop, m_SALoopToggle.getButton());
        m_AutoRateToggle.getAttachment() =
                createParameterAttachment(Parameters::AutoRate, m_AutoRateToggle.getButton());
        m_PhaseLockToggle.getAttachment() =
                createParameterAttachment(Parameters::PhaseLock, m_PhaseLockToggle.getButton());
        m_PhaseSyncToggle.getAttachment() =
                createParameterAttachment(Parameters::PhaseSync, m_PhaseSyncToggle.getButton());
        m_NormaliseToggle.getAttachment() =
                createParameterAttachment(Parameters::Normalise, m_NormaliseToggle.getButton());
        m_AutoplayToggle.getAttachment() =
                createParameterAttachment(Parameters::Autoplay, m_AutoplayToggle.getButton());
        m_AutoplayToggle.getButton().setComponentID(ComponentIds::ButtonAutoplayId);
 
        m_EnableMuteUpToggle.getAttachment() =
                createParameterAttachment(Parameters::MuteUp, m_EnableMuteUpToggle.getButton());
        m_EnableMuteDownToggle.getAttachment() =
                createParameterAttachment(Parameters::MuteDown, m_EnableMuteDownToggle.getButton());
        // ---------------
        Range<double> scrollbarRange(0.0, 1.0);
        m_waveformViewScrollbar.setRangeLimits(scrollbarRange, NotificationType::dontSendNotification);
        m_waveformViewScrollbar.setCurrentRange(
                /*starting point*/ 0.0,
                /*size*/ 1.0, NotificationType::dontSendNotification);
        m_waveformViewScrollbar.setColour(ScrollBar::ColourIds::thumbColourId, Colour(74, 74, 74));
        m_waveformViewScrollbar.addListener(this);
 
        m_waveformViewerAndEditor =
                std::make_unique<krotos::WaveformViewerAndEditor>(m_colourDefinitions.waveformColour, false, false);
 
        addAndMakeVisible(m_waveformViewerAndEditor.get());
        m_waveformViewerAndEditor->setChildComponentIds(ComponentIds::WaveformViewerId);
        m_waveformViewerAndEditor->setViewerDropText(m_defaultDropText);
        m_waveformViewerAndEditor->getWaveformViewer()->setDrawGrid(false);
        m_waveformViewerAndEditor->getWaveformViewer()->setShowBorderOnDragHover(true);
        m_waveformViewerAndEditor->getWaveformViewer()->setShowFileName(false);
 
        // - limit the loaded files by name
        m_waveformViewerAndEditor->getWaveformViewer()->setRegexFileFilter(
                String("")); // Empty string - loads everything which is in the dragged folder
        m_waveformViewerAndEditor->addListener(this);
 
        m_samplesTree = *getOwner().getCustomParameter<SamplesTree>(SamplesTree::Type::Samples);
 
        m_waveformViewerAndEditor->update(m_soSound);
        m_soSound.addListener(this);
 
        addParameterCallback(Parameters::Mode, [this](float val) { modeParamChanged(val); });
        auto modeVal = getOwner().getParameter(Parameters::Mode)->get();
        modeParamChanged(modeVal);
 
        // start-point change
        addParameterCallback(Parameters::Start, [this](float val) {
            // if called from marquee
            if (m_calledFromMarqueeStart)
            {
                m_calledFromMarqueeStart = false;
                return;
            }
            else // if changed from slider
            {
                Kwidget_CoreEngine::EngineMode mode = static_cast<Kwidget_CoreEngine::EngineMode>(
                        m_mode.getControlComponent().getSelectedItemIndex());
                if (mode == Kwidget_CoreEngine::EngineMode::modeSampler)
                {
                    auto sizeVal = getOwner().getParameter(Parameters::Size)->get();
                    if (val >= sizeVal)
                        val = sizeVal;
                    // repaint the viewer
                    m_waveformViewerAndEditor->setStartPosInPercentage(val * 0.01f);
                }
                else if (mode == Kwidget_CoreEngine::EngineMode::modeGranular)
                {
                    // repaint the viewer
                    m_waveformViewerAndEditor->setStartPosInPercentage(val * 0.01f);
                }
            }
        });
 
        // end-point change
        addParameterCallback(Parameters::Size, [this](float val) {
            // if called from the marquee
            if (m_calledFromMarqueeEnd)
            {
                m_calledFromMarqueeEnd = false;
                return;
            }
            else // if changed from the slider
            {
                auto startVal = getOwner().getParameter(Parameters::Start)->get();
                if (val <= startVal)
                    val = startVal;
                // repaint the viewer
                m_waveformViewerAndEditor->setEndPosInPercentage(val * 0.01f);
            }
        });
 
        setRenderStyle(RenderStyle::borderless);
 
        initialiseZoomControls();
 
        // Sample Browser Dropdown Menu
        m_sampleBrowserButton.setComponentID(ComponentIds::ButtonSampleBrowserId);
        addAndMakeVisible(m_sampleBrowserButton);
 
        m_sampleBrowserButton.onNextButtonClick = [&] {
            if (auto* sampleEngine = m_soSound.getSampleEngine())
            {
                const bool engineHasAudioSegments = sampleEngine->getNumAudioSegments() > 1;
                if (engineHasAudioSegments)
                {
                    // Wrap around
                    auto nextSegmentIndex = (m_selectedSegment + 1) % sampleEngine->getNumAudioSegments();
 
                    selectSample(nextSegmentIndex);
                }
            }
        };
 
        m_sampleBrowserButton.onPreviousButtonClick = [&] {
            if (auto* sampleEngine = m_soSound.getSampleEngine())
            {
                const bool engineHasAudioSegments = sampleEngine->getNumAudioSegments() > 1;
                if (engineHasAudioSegments)
                {
                    // Inverse wrap around
                    auto nextSegmentIndex = (sampleEngine->getNumAudioSegments() - 1 + m_selectedSegment) %
                                            sampleEngine->getNumAudioSegments();
 
                    selectSample(nextSegmentIndex);
                }
            }
        };
 
        m_samplesTree.sampleAdded = [this](SamplesTree::Sample& newSample) {
            m_sampleBrowserButton.setSampleCount(m_samplesTree.getNumSamples());
        };
 
        m_samplesTree.sampleRemoved = [this](ValueTree& childWhichHasBeenRemoved, int indexFromWhichChildWasRemoved) {
            bool lastSampleDeleted = m_samplesTree.getNumSamples() == 0;
            if (lastSampleDeleted)
            {
                clearEngine();
            }
            else
            {
                selectSample(jmax<int>(indexFromWhichChildWasRemoved - 1, 0));
            }
 
            m_sampleBrowserButton.setSampleCount(m_samplesTree.getNumSamples());
        };
 
        m_sampleBrowserButton.onClick = [&] { showSampleBrowser(); };
 
        // Initialise current waveform / sample display update
        m_sampleBrowserButton.setSampleCount(m_samplesTree.getNumSamples());
        if (m_samplesTree.getNumSamples() == 0)
        {
            clearEngine();
        }
 
        // Setup the callback to update the UI when the sample index has changed from a note on event
        m_samplesTree.sampleIndexChanged = [&](int index) { selectSample(index, false); };
 
        // Setup the callback to update the selected sample
        m_samplesTree.selectedSampleChanged = [&](int index) { selectSample(index, true); };
 
        // Initialise sample select
        selectSample(m_samplesTree.selectedSampleValue, true);
    }
 
    void KwidgetGUI_CoreEngine::showSampleBrowser()
    {
        OwnedArray<SampleBrowser::Sample> samplesToShow{m_samplesTree.getSampleDataAsBrowserSamples()};
 
        int sampleItemCount = jlimit(0, m_layout.sampleBrowserMaxItemsToShow, samplesToShow.size());
 
        enum item
        {
            Browser = -1,
            Add = 1,
            RemoveAll
        };
 
        auto browser = std::make_unique<SampleBrowser>(m_layout.sampleBrowserWidth,
                                                       m_layout.sampleBrowserItemHeight * sampleItemCount,
                                                       m_layout.sampleBrowserItemHeight, std::move(samplesToShow));
 
        // Use m_cuedSegment for cyan dot to remain next to user cued samples only.
        browser->setCuedSample(m_cuedSegment, true);
 
        browser->onSampleSelected = [this](int sampleIndex) {
            selectSample(sampleIndex);
            PopupMenu::dismissAllActiveMenus();
        };
 
        browser->onSampleDeleted = [this](int sampleIndex) {
            m_samplesTree.removeSample(sampleIndex);
            PopupMenu::dismissAllActiveMenus();
            // refresh the waveformViewerAndEditor to set selector ranges from updated SampleEngine
            m_waveformViewerAndEditor->copySegmentsToSelectors();
        };
 
        browser->onSampleSolo = [this](int sampleIndex, bool soloState) { selectSample(sampleIndex, false); };
 
        PopupMenu menu;
 
        menu.addCustomItem(item::Browser, std::move(browser));
 
        menu.addItem(item::Add, "Add More Samples", true, false,
                     Drawable::createFromImageData(KrotosBinaryData::Add_Sample_Icon_svg,
                                                   KrotosBinaryData::Add_Sample_Icon_svgSize));
        menu.addItem(item::RemoveAll, "Remove All Samples", true, false,
                     Drawable::createFromImageData(KrotosBinaryData::Remove_All_Samples_svg,
                                                   KrotosBinaryData::Remove_All_Samples_svgSize));
 
        std::function<void(int)> menuCallback = [&](int itemResultID) {
            switch (itemResultID)
            {
            case item::Add:
                m_waveformViewerAndEditor->showFileChooser();
                break;
            case item::RemoveAll:
                std::function<void(int)> removeCallback = [this, target = WeakReference<Component>{this}](int option) {
                    if (target && option == 0)
                    {
                        clearEngine();
 
                        // Mixpanel: core engine clear all samples
                        sendActionMessage(analyticsEventClearedEngine);
                    }
                };
                m_sampleBrowserButton.getProperties().set(Krotos_LookAndFeel::Properties::AlertWindow::AlertWidthID,
                                                          440);
                m_sampleBrowserButton.getProperties().set(Krotos_LookAndFeel::Properties::AlertWindow::AlertHeightID,
                                                          172);
                AlertWindow::showAsync(MessageBoxOptions()
                                               .withIconType(MessageBoxIconType::WarningIcon)
                                               .withTitle("Sample Removal")
                                               .withMessage("Are you sure you want to proceed with the\nremoval? This "
                                                            "action cannot be undone!")
                                               .withButton("Cancel")
                                               .withButton("Remove")
                                               .withAssociatedComponent(&m_sampleBrowserButton),
                                       removeCallback);
                break;
            }
        };
 
        menu.showMenuAsync(PopupMenu::Options{}
                                   .withTargetComponent(m_sampleBrowserButton)
                                   .withMinimumNumColumns(1)
                                   .withStandardItemHeight(m_layout.sampleBrowserItemHeight),
                           menuCallback);
    }
 
    // Assuming you have a TabbedComponent named m_tabbedComponent
    void KwidgetGUI_CoreEngine::initialiseTabbedComponent()
    {
        // Create your TabbedComponent
        m_tabbedComponent = std::make_unique<TabbedComponent>(TabbedButtonBar::TabsAtTop);
 
        switch (m_activeMode)
        {
        case Kwidget_CoreEngine::EngineMode::modeSampler:
            tabSetupSampler();
            break;
        case Kwidget_CoreEngine::EngineMode::modeGranular:
            tabSetupGranular();
            break;
        }
 
        m_tabbedComponent->setOutline(0);
 
        // Add the TabbedComponent to main core enginedGUI component
        addAndMakeVisible(*m_tabbedComponent);
    }
 
    void KwidgetGUI_CoreEngine::finalSetup()
    {
        // initial start value setting
        auto startValue = getOwner().getParameter(Parameters::Start)->get();
        m_waveformViewerAndEditor->setStartPosInPercentage(startValue * 0.01f);
 
        // intial end value setting
        auto sizeValue = getOwner().getParameter(Parameters::Size)->get();
        m_waveformViewerAndEditor->setEndPosInPercentage(sizeValue * 0.01f);
    }
 
    void KwidgetGUI_CoreEngine::modeParamChanged(float val)
    {
        m_activeMode = static_cast<Kwidget_CoreEngine::EngineMode>(
                val * static_cast<float>(Kwidget_CoreEngine::EngineMode::modeNUM_MODES - 1));
        setVisibleControlsSet(m_activeMode);
        // change the waveformViewer according to the active mode
        auto modeVal = static_cast<AreaSelectionComp::WaveformMode>(m_activeMode);
        switch (m_activeMode)
        {
        case Kwidget_CoreEngine::EngineMode::modeSampler:
            m_waveformViewerAndEditor->setZoomStyle(WaveformViewerAndEditor::ZoomStyle::playhead);
            break;
        case Kwidget_CoreEngine::EngineMode::modeGranular:
            m_waveformViewerAndEditor->setZoomStyle(WaveformViewerAndEditor::ZoomStyle::start);
            break;
        case Kwidget_CoreEngine::EngineMode::modeVehicle:
            m_waveformViewerAndEditor->setZoomStyle(WaveformViewerAndEditor::ZoomStyle::centre);
            break;
        }
        repaint();
    }
 
    void KwidgetGUI_CoreEngine::setVisibleControlsSet(Kwidget_CoreEngine::EngineMode mode)
    {
        // Make unwanted controls invisible, per mode
        switch (mode)
        {
        case Kwidget_CoreEngine::EngineMode::modeSampler:
            setVehicleControlsVisibility(false);
            setGranularControlsVisibility(false);
            setSamplerControlsVisibility(true);
 
            tabSetupSampler();
            break;
        case Kwidget_CoreEngine::EngineMode::modeGranular:
            setVehicleControlsVisibility(false);
            setSamplerControlsVisibility(false);
            setGranularControlsVisibility(true);
 
            tabSetupGranular();
            break;
        case Kwidget_CoreEngine::EngineMode::modeVehicle:
            setSamplerControlsVisibility(false);
            setGranularControlsVisibility(false);
            setVehicleControlsVisibility(true);
            break;
        }
 
        resized();
    }
 
    KwidgetGUI_CoreEngine::~KwidgetGUI_CoreEngine()
    {
        m_soSound.removeListener(this);
        m_waveformViewScrollbar.removeListener(this);
 
        m_Start.setLookAndFeel(nullptr);
        m_Size.setLookAndFeel(nullptr);
        m_Rate.setLookAndFeel(nullptr);
        m_Detune.setLookAndFeel(nullptr);
        m_Width.setLookAndFeel(nullptr);
        m_GranularLevel.setLookAndFeel(nullptr);
        m_SamplerLevel.setLookAndFeel(nullptr);
    }
 
    void KwidgetGUI_CoreEngine::paint(Graphics& g)
    {
        Colour bgColour(31, 37, 46);
        g.setColour(bgColour);
        g.fillRoundedRectangle(getLocalBounds().reduced(2).toFloat(), /*corner*/ 3.0f);
 
        g.setColour(Colours::black);
        g.drawRoundedRectangle(getLocalBounds().reduced(1).toFloat(), /*corner*/ 5.0f, /*thickness*/ 2.0f);
    }
 
    void KwidgetGUI_CoreEngine::resized()
    {
        KwidgetGUI::resized();
 
        // shared left panel
        m_coreEngineNameLabel.setBounds(m_layout.leftPanel.modeLabel);
        m_coreEngineNameLabel.setText(Kwidget_CoreEngine::ModeNames[m_activeMode],
                                      NotificationType::dontSendNotification);
 
        m_Level.setBounds(m_layout.leftPanel.levelSlider);
        m_LevelRand.setBounds(m_layout.leftPanel.randLevelSlider);
 
        m_Pan.setBounds(m_layout.leftPanel.panSlider);
        m_PanRand.setBounds(m_layout.leftPanel.panRandSlider);
 
        m_trigger.setBounds(m_layout.leftPanel.triggerCombobox);
 
        m_muteButton.setBounds(m_layout.leftPanel.muteButton);
        m_soloButton.setBounds(m_layout.leftPanel.soloButton);
 
        // wavefrom area bounds
        m_waveformViewerAndEditor->setBounds(m_layout.waveformArea);
 
        m_removeEngineButton.setBounds(m_layout.removeEngineButton);
 
        m_zoomOutButton.setBounds(m_layout.waveformZoomOutButton);
        m_zoomInButton.setBounds(m_layout.waveformZoomInButton);
        m_waveformViewScrollbar.setBounds(m_layout.waveformZoomScrollbar);
 
        // right panel tabbed component bounds
        if (m_tabbedComponent != nullptr)
            m_tabbedComponent->setBounds(m_layout.controlsTabs.tabbedComponentBounds);
 
        auto kwidgetID = getKwidgetID();
 
        // amp env
        auto adsr0 = m_ampEnvTab.findChildWithID(kwidgetID + ":Adsr0");
        if (adsr0 != nullptr)
        {
            adsr0->setBounds(m_layout.controlsTabs.ampEnvBounds);
        }
 
        // pitch env
        auto adsr1 = m_pitchEnvTab.findChildWithID(kwidgetID + ":Adsr1");
        if (adsr1 != nullptr)
        {
            adsr1->setBounds(m_layout.controlsTabs.pitchEnvBounds);
        }
 
        // toggle group bounds
        Rectangle<int> playbackControls(m_layout.toggleGroupAreaSampler);
        m_SALoopToggle.setBounds(playbackControls.removeFromLeft(m_layout.loopToggleWidth));
        m_NormaliseToggle.setBounds(playbackControls.removeFromLeft(m_layout.normalizeToggleWidth));
        m_AutoplayToggle.setBounds(playbackControls.removeFromLeft(m_layout.autoplayToggleWidth));
        m_NORToggle.setBounds(playbackControls.removeFromLeft(m_layout.releaseTrigToggleWidth));
        m_RobinToggle.setBounds(playbackControls.removeFromLeft(m_layout.randomToggleWidth));
 
        m_sampleBrowserButton.setBounds(m_layout.sampleBrowserButton);
 
        switch (m_activeMode)
        {
        case Kwidget_CoreEngine::EngineMode::modeSampler:
            resizeSampler();
            break;
        case Kwidget_CoreEngine::EngineMode::modeGranular:
            resizeGranular();
            break;
        case Kwidget_CoreEngine::EngineMode::modeVehicle:
            resizeVehicle();
            break;
        }
    }
 
    void KwidgetGUI_CoreEngine::soundChanged(KrotosSampleOscillatorSound* sound)
    {
        m_waveformViewerAndEditor->update(*sound);
        // Todo: Fix the edit dropdown and associated states so that updateBrowserButtonStatus() doesn't need to be in
        // paint(), an overridden method which is called asynchronously and unreliably. Probably needs an investigation,
        // but likely that this wont work properly until the work in KST-2269: Custom Parameter Tree is applied to
        // mute / solo state etc.
        auto* sampler = m_soSound.getSampleEngine();
        jassert(sampler);
        if (sampler)
        {
            // Select the last sample in the audio buffer
            // ie the most recently dragged
            selectSample(sampler->getNumAudioSegments() - 1);
            repaint();
        }
 
        MouseCursor::hideWaitCursor();
    }
 
    void KwidgetGUI_CoreEngine::fileHasBeenDropped(WaveformViewerAndEditor*, const StringArray& files)
    {
        MouseCursor::showWaitCursor();
        m_waveformViewerAndEditor->clear(); // switch off the Grain display
 
        // This is is a safety check to ensure sure none of the file paths contain a return char
        for (const auto& s : files)
        {
            if (s.containsChar('\n'))
            {
                jassertfalse;
                return;
            }
 
            // Add new samples to samples tree
            m_samplesTree.addSample(File(s).getFileNameWithoutExtension(), s, false);
        }
 
        if (m_samplesTree.dropCompleted)
        {
            m_samplesTree.dropCompleted();
        }
 
        m_sampleBrowserButton.setSampleCount(m_samplesTree.getNumSamples());
        selectSample(m_samplesTree.getNumSamples() - 1);
 
        // Mixpanel analytics: added samples to core engine
        sendActionMessage(analyticsEventAddedSamplesEngine);
    }
 
    void KwidgetGUI_CoreEngine::selectionsChanged(WaveformViewerAndEditor* /*areaSelectionComp*/,
                                                  std::vector<Range<int>> selections)
    {
        int i = 0;
        for (auto& selection : selections)
        {
            m_samplesTree.setSampleSelection(i++, selection);
        }
    }
 
    String KwidgetGUI_CoreEngine::findSimilarAudioFile(String samplePaths, bool isCommandDown)
    {
        auto files = StringArray::fromLines(samplePaths);
        if (files.size() == 1) // Only do match if we have a single file loaded
        {
            // keep track of current file so we can restore later if needed
            m_samplePathRestore = files[0];
 
            auto query = AssetManager::convertFilePathString(files[0]).toStdString();
 
            // return at most 20 closest matches
            auto pathsAndScores = m_audioDataset->sample(query, 20, true);
 
            // show a popup menu of results
            if (isCommandDown)
            {
                PopupMenu resultsMenu;
                int idx = 0;
                std::reverse(pathsAndScores.begin(), pathsAndScores.end());
                for (const auto& [path, score] : pathsAndScores)
                {
                    auto fileName = AssetManager::convertFilePath(path).getFileName();
                    auto itemText = "[" + String(score, 2) + "] " + fileName;
                    resultsMenu.addItem(++idx, itemText);
                }
                auto item = resultsMenu.showMenu(PopupMenu::Options());
                // return user selection
                return item > 0 ? String(pathsAndScores[item - 1].first) : samplePaths;
            }
            // no menu - just return a random choice from the results
            else
            {
                jassert(!pathsAndScores.empty());
                if (pathsAndScores.size() <= 2)
                {
                    // not enough results to make a random pick
                    return String(pathsAndScores.front().first);
                }
                else
                {
                    // random pick avoiding query (last element)
                    auto n = (int)pathsAndScores.size() - 1;
                    auto randomIndex = Random::getSystemRandom().nextInt(n);
                    return String(pathsAndScores[randomIndex].first);
                }
            }
        }
        return samplePaths;
    }
 
    void KwidgetGUI_CoreEngine::scrollBarMoved(ScrollBar* /*scrollBarThatHasMoved*/, double newRangeStart)
    {
        m_waveformViewerAndEditor->setViewCentre(float(newRangeStart));
    }
 
    void KwidgetGUI_CoreEngine::resizeScrollBar(float newThumbSize)
    {
        const Range currentRange = m_waveformViewScrollbar.getCurrentRange();
        const double newStart = currentRange.getStart() + ((currentRange.getLength() - newThumbSize) / 2);
        m_waveformViewScrollbar.setCurrentRange(/*starting point*/ newStart, /*size*/ double(newThumbSize),
                                                NotificationType::dontSendNotification);
    }
 
    void KwidgetGUI_CoreEngine::resizeScrollBarFromRange(Range<float> newRange)
    {
        if (newRange.isEmpty())
        {
            return;
        }
        m_waveformViewScrollbar.setCurrentRange(static_cast<double>(newRange.getStart()),
                                                static_cast<double>(newRange.getLength()),
                                                NotificationType::dontSendNotification);
    }
 
    void KwidgetGUI_CoreEngine::initialiseZoomControls()
    {
        // Set zoom in/out button images and hover states
        const Colour defaultIconColour(177, 177, 177);
        const Colour hoverIconColour(217, 217, 217);
        m_zoomInButtonImage->replaceColour(Colours::white, Colours::transparentWhite);
        m_zoomOutButtonImage->replaceColour(Colours::white, Colours::transparentWhite);
        m_zoomInButtonImageMouseOver->replaceColour(defaultIconColour, hoverIconColour);
        m_zoomInButtonImageMouseOver->replaceColour(Colours::white, Colours::transparentWhite);
        m_zoomOutButtonImageMouseOver->replaceColour(defaultIconColour, hoverIconColour);
        m_zoomOutButtonImageMouseOver->replaceColour(Colours::white, Colours::transparentWhite);
        m_zoomInButton.setImages(m_zoomInButtonImage.get(), m_zoomInButtonImageMouseOver.get());
        m_zoomOutButton.setImages(m_zoomOutButtonImage.get(), m_zoomOutButtonImageMouseOver.get());
        addAndMakeVisible(m_zoomInButton);
        addAndMakeVisible(m_zoomOutButton);
        m_zoomInButton.setComponentID(ComponentIds::ButtonZoomInId);
        m_zoomOutButton.setComponentID(ComponentIds::ButtonZoomOutId);
        // set zoom in/out button controls
        m_zoomInButton.onClick = [this] { m_waveformViewerAndEditor->zoomIn(); };
        m_zoomOutButton.onClick = [this] { m_waveformViewerAndEditor->zoomOut(); };
 
        // set scroll bar colour and behaviour
        m_waveformViewScrollbar.setComponentID(ComponentIds::ScrollBarWaveformViewId);
        m_waveformViewScrollbar.setAutoHide(false);
        addAndMakeVisible(m_waveformViewScrollbar);
    }
 
    void KwidgetGUI_CoreEngine::clearEngine()
    {
        m_samplesTree.removeAllChildren();
        m_waveformViewerAndEditor->clear(); // stop grain display
        m_waveformViewerAndEditor->setViewerDropText(m_defaultDropText);
        m_soSound.clearAndFreeBuffer();
        m_samplePathRestore = "";
        resetBrowserButtonStatus();
        // Update the waveform selectors
        m_waveformViewerAndEditor->copySegmentsToSelectors();
    }
 
    void KwidgetGUI_CoreEngine::resetBrowserButtonStatus()
    {
        m_sampleBrowserButton.setButtonText("");
        m_sampleBrowserButton.setSampleCount(0);
        m_sampleBrowserButton.setSampleIndex(-1);
    }
 
    void KwidgetGUI_CoreEngine::selectSample(int segmentIndex) { m_samplesTree.selectedSampleValue = segmentIndex; }
 
    void KwidgetGUI_CoreEngine::selectSample(int segmentIndex, bool cueSelected)
    {
        if (m_samplesTree.getNumSamples() == 0)
        {
            return;
        }
        jassert(segmentIndex >= 0);
        jassert(segmentIndex < m_samplesTree.getNumSamples());
 
        // This member is used for the handling forward/back button position
        m_selectedSegment = segmentIndex;
        // This member is used for the cyan dot to remain next to user cued samples only
        m_cuedSegment = cueSelected ? segmentIndex : m_cuedSegment;
 
        // Update sample browser UI
        m_sampleBrowserButton.setSampleIndex(m_selectedSegment);
        auto sample = m_samplesTree.getSamples()[m_selectedSegment];
        auto sampleName = sample ? sample->nameValue : String();
        if (m_sampleBrowserButton.getButtonText() != sampleName)
        {
            m_sampleBrowserButton.setButtonText(sampleName);
        }
 
        // Update waveform viewer
        m_waveformViewerAndEditor->zoomToSegment(m_selectedSegment);
 
        // Cue the user selected sample in the engine
        if (auto* sampler = m_soSound.getSampleEngine();
            sampler && cueSelected && segmentIndex < sampler->getNumSamples())
        {
            sampler->setNextSegmentIndex(segmentIndex);
        }
    }
 
    void KwidgetGUI_CoreEngine::mouseEnter(const MouseEvent& event)
    {
        // Fix for repeated midi note change events being to analytics on preset load.
        // Only send events after the mouse has entered the component for the first time.
        m_notifyMidiTriggerChange = true;
    }
 
} // namespace krotos