KwidgetGUI_Reformer.cpp

Go to the documentation of this file.

namespace krotos
{
    const String KwidgetGUI_Reformer::ComponentIds::ComboboxSegmentationId{"Segmentation"};
    const String KwidgetGUI_Reformer::ComponentIds::ComboboxFeatureExtrId{"FeatureExtr"};
    const String KwidgetGUI_Reformer::ComponentIds::SliderLevelId("Level");
    // This had to be renamed from LevelRND to differentiate it from the KwidgetGUI_CoreEngine equivalent
    const String KwidgetGUI_Reformer::ComponentIds::SliderLevelRandId("ReformerLevelRND");
    const String KwidgetGUI_Reformer::ComponentIds::SliderPanId("Pan");
    // This had to be renamed from PanRND to differentiate it from the KwidgetGUI_CoreEngine equivalent
    const String KwidgetGUI_Reformer::ComponentIds::SliderPanRandId("ReformerPanRND");
    const String KwidgetGUI_Reformer::ComponentIds::SliderGrainPitchId("Pitch");
    const String KwidgetGUI_Reformer::ComponentIds::SliderGrainStartId("GrainStart");
    const String KwidgetGUI_Reformer::ComponentIds::SliderGrainSizeId("GrainSize");
    const String KwidgetGUI_Reformer::ComponentIds::SliderGrainRateId("GrainRate");
    const String KwidgetGUI_Reformer::ComponentIds::SliderGrainWidthId("GrainWidth");
    const String KwidgetGUI_Reformer::ComponentIds::SliderGrainMaxId("GrainMax");
    const String KwidgetGUI_Reformer::ComponentIds::SliderGrainShapeId("GrainShape");
    const String KwidgetGUI_Reformer::ComponentIds::SliderNearestId("Nearest");
    const String KwidgetGUI_Reformer::ComponentIds::SliderPuckXId("PuckX");
    const String KwidgetGUI_Reformer::ComponentIds::SliderPuckYId("PuckY");
    const String KwidgetGUI_Reformer::ComponentIds::SliderGrainPitchRNDId("PitchRND");
    const String KwidgetGUI_Reformer::ComponentIds::SliderGrainStartRNDId("GrainStartRND");
    const String KwidgetGUI_Reformer::ComponentIds::SliderGrainSizeRNDId("GrainSizeRND");
    const String KwidgetGUI_Reformer::ComponentIds::SliderGrainRateRNDId("GrainRateRND");
    const String KwidgetGUI_Reformer::ComponentIds::SliderGrainWidthRNDId("GrainWidthRND");
    const String KwidgetGUI_Reformer::ComponentIds::ButtonMuteId("Mute");
    const String KwidgetGUI_Reformer::ComponentIds::ButtonSoloId("Solo");
    const String KwidgetGUI_Reformer::ComponentIds::ButtonAutoplayId("Autoplay");
    const String KwidgetGUI_Reformer::ComponentIds::ButtonLoopToggleId("Loop");
    const String KwidgetGUI_Reformer::ComponentIds::ButtonNormaliseToggleId("Normalise");
    const String KwidgetGUI_Reformer::ComponentIds::ButtonSampleBrowserId("SampleSelectDropdown");
    const String KwidgetGUI_Reformer::ComponentIds::WaveformViewerId("Waveform");
    const String KwidgetGUI_Reformer::ComponentIds::ButtonZoomInId("ZoomIn");
    const String KwidgetGUI_Reformer::ComponentIds::ButtonZoomOutId("ZoomOut");
    const String KwidgetGUI_Reformer::ComponentIds::ScrollBarWaveformViewId("WaveformMove");
    const String KwidgetGUI_Reformer::ComponentIds::ButtonClearEngineId("ClearReformer");
    const String KwidgetGUI_Reformer::ComponentIds::ButtonOneShotToggleId("OneShot");
    const String KwidgetGUI_Reformer::ComponentIds::ButtonProximityToggleId("Proximity");
 
    const std::string KwidgetGUI_Reformer::analyticsEventClearedEngine{"analyticsEventClearedEngine"};
    const std::string KwidgetGUI_Reformer::analyticsEventAddedSamplesEngine{"analyticsEventAddedSamplesEngine"};
    const std::string KwidgetGUI_Reformer::analyticsEventRemovedEngine{"analyticsEventRemovedEngine"};
 
    KwidgetGUI_Reformer::KwidgetGUI_Reformer(Kwidget& owner, KrotosSampleOscillatorSound& sound)
        : KwidgetGUI(owner), m_soSound(sound), m_owner(owner), m_sampleBrowserButton(""),
          m_removeEngineButton("", DrawableButton::ImageStretched), m_zoomInButton("", DrawableButton::ImageStretched),
          m_zoomInButtonImage(
                  Drawable::createFromImageData(KrotosBinaryData::Plus_Icon_svg, KrotosBinaryData::Plus_Icon_svgSize)),
          m_zoomInButtonImageHover(
                  Drawable::createFromImageData(KrotosBinaryData::Plus_Icon_svg, KrotosBinaryData::Plus_Icon_svgSize)),
          m_zoomOutButton("", DrawableButton::ImageStretched),
          m_zoomOutButtonImage(Drawable::createFromImageData(KrotosBinaryData::Minus_Icon_svg,
                                                             KrotosBinaryData::Minus_Icon_svgSize)),
          m_zoomOutButtonImageHover(
                  Drawable::createFromImageData(KrotosBinaryData::Minus_Icon_svg, KrotosBinaryData::Minus_Icon_svgSize))
    {
        setComponentID("Reformer");
        using Params = KwidgetProcessor_Reformer::Parameters;
        addAndMakeVisible(m_reformerNameLabel);
        m_reformerNameLabel.setFont(Font(layout.modeFontSize).withExtraKerningFactor(layout.modeExtraKerning));
        m_controlsTab.setOutline(0);
 
        m_controlsTab.addTab("MAIN", findColour(TabbedComponent::backgroundColourId), &m_SynthesisControls, false);
        m_controlsTab.addTab("RND", findColour(TabbedComponent::backgroundColourId), &m_randTab, false);
        m_controlsTab.addTab("CONTROL", findColour(TabbedComponent::backgroundColourId), &m_controlTab, false);
        m_controlsTab.addTab("ADSR", findColour(TabbedComponent::backgroundColourId), &m_AdsrControls, false);
        m_controlsTab.addTab("ANALYSIS", findColour(TabbedComponent::backgroundColourId), &m_AnalysisControls, false);
#if IS_DEVELOPMENT_BUILD
        m_controlsTab.addTab("DISPLAY", findColour(TabbedComponent::backgroundColourId), &m_DisplayControls, false);
#endif
 
        // Loop through every tab button
        for (int tabIndex = 0; tabIndex < m_controlsTab.getNumTabs(); tabIndex++)
        {
            const auto& tabButton = m_controlsTab.getTabbedButtonBar().getTabButton(tabIndex);
            // Construct and set a unique ID for each button
            tabButton->setComponentID("ReformerTab" + tabButton->getName());
        }
 
        addAndMakeVisible(m_controlsTab);
 
        m_segmentationLabel.setText("Segmentation", dontSendNotification);
        m_segmentationLabel.setJustificationType(Justification::left);
        m_schemeLabel.setText("Scheme", dontSendNotification);
        m_schemeLabel.setJustificationType(Justification::left);
 
        m_AnalysisControls.addAndMakeVisible(m_segmentationLabel);
        m_AnalysisControls.addAndMakeVisible(m_schemeLabel);
 
        // Left panel
        addAttachedComponent(m_Pan, Params::Pan);
        addAttachedComponent(m_Level, Params::Level);
        addAttachedComponent(m_PanRand, Params::PanRand);
        addAttachedComponent(m_LevelRand, Params::LevelRand);
 
        // Slider specific layout
        m_Pan.getSlider().setSliderStyle(Slider::SliderStyle::LinearHorizontal);
        m_Pan.getSlider().setComponentID(ComponentIds::SliderPanId);
        m_Pan.getLabel().setComponentID(ComponentIds::SliderPanId);
        m_Pan.setLabelPosition(AttachedSlider::LabelPosition::Above);
        m_Pan.setValueFormat("%.1f");
 
        m_Level.getSlider().setSliderStyle(Slider::SliderStyle::LinearHorizontal);
        m_Level.getSlider().setComponentID(ComponentIds::SliderLevelId);
        m_Level.getLabel().setComponentID(ComponentIds::SliderLevelId);
        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_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");
 
        // Sliders
        m_Start.getSlider().setTextValueSuffix(" % ");
 
        addAttachedComponent(m_SynthesisControls, m_Start, Params::Start);
        m_Start.getSlider().setComponentID(ComponentIds::SliderGrainStartId);
        addAttachedComponent(m_controlTab, m_PuckX, Params::PuckX);
        m_PuckX.getSlider().setComponentID(ComponentIds::SliderPuckXId);
        addAttachedComponent(m_controlTab, m_PuckY, Params::PuckY);
        m_PuckY.getSlider().setComponentID(ComponentIds::SliderPuckYId);
        addAttachedComponent(m_controlTab, m_Nearest, Params::Nearest);
        m_Nearest.getSlider().setComponentID(ComponentIds::SliderNearestId);
        addAttachedComponent(m_controlTab, m_Radius, Params::Radius);
 
        addAttachedComponent(m_SynthesisControls, m_LevelMod, Params::LevelMod);
 
        m_Size.getSlider().setTextValueSuffix(" % ");
 
        addAttachedComponent(m_SynthesisControls, m_Size, Params::Size);
        m_Size.getSlider().setComponentID(ComponentIds::SliderGrainSizeId);
        addAttachedComponent(m_SynthesisControls, m_Rate, Params::Rate);
        m_Rate.getSlider().setComponentID(ComponentIds::SliderGrainRateId);
        addAttachedComponent(m_SynthesisControls, m_Detune, Params::Pitch);
        addAttachedComponent(m_SynthesisControls, m_Width, Params::Width);
        m_Width.getSlider().setComponentID(ComponentIds::SliderGrainWidthId);
        addAttachedComponent(m_SynthesisControls, m_GranularLevel, Params::GranularLevel);
        m_Detune.getSlider().setComponentID(ComponentIds::SliderGrainPitchId);
        m_Detune.getLabel().setComponentID(ComponentIds::SliderGrainPitchId);
 
        // Rand Sliders
        addAttachedComponent(m_randTab, m_StartRand, Params::StartRand);
        m_StartRand.getSlider().setComponentID(ComponentIds::SliderGrainStartRNDId);
        addAttachedComponent(m_randTab, m_SizeRand, Params::SizeRand);
        m_SizeRand.getSlider().setComponentID(ComponentIds::SliderGrainSizeRNDId);
        addAttachedComponent(m_randTab, m_RateRand, Params::RateRand);
        m_RateRand.getSlider().setComponentID(ComponentIds::SliderGrainRateRNDId);
        addAttachedComponent(m_randTab, m_DetuneRand, Params::PitchRand);
        m_DetuneRand.getSlider().setComponentID(ComponentIds::SliderGrainPitchRNDId);
        addAttachedComponent(m_randTab, m_WidthRand, Params::WidthRand);
        m_WidthRand.getSlider().setComponentID(ComponentIds::SliderGrainWidthRNDId);
 
        // Extras Sliders
        addAttachedComponent(m_controlTab, m_Shape, Params::Shape);
        m_Shape.getSlider().setComponentID(ComponentIds::SliderGrainShapeId);
        addAttachedComponent(m_controlTab, m_GrainMax, Params::GrainMax);
        m_GrainMax.getSlider().setComponentID(ComponentIds::SliderGrainMaxId);
        addAttachedComponent(m_AnalysisControls, m_Tracking, Params::Tracking);
        addAttachedComponent(m_AnalysisControls, m_Coeff0, Params::Coeff0);
        addAttachedComponent(m_AnalysisControls, m_Coeff1, Params::Coeff1);
        addAttachedComponent(m_AnalysisControls, m_Coeff2, Params::Coeff2);
        addAttachedComponent(m_AnalysisControls, m_Coeff3, Params::Coeff3);
        addAttachedComponent(m_AnalysisControls, m_Coeff4, Params::Coeff4);
        addAttachedComponent(m_DisplayControls, m_Coeff5, Params::Coeff5);
        addAttachedComponent(m_DisplayControls, m_Coeff6, Params::Coeff6);
        addAttachedComponent(m_AnalysisControls, m_Coeff7, Params::Coeff7);
        addAttachedComponent(m_AnalysisControls, m_SelectX, Params::SelectX);
        addAttachedComponent(m_AnalysisControls, m_SelectY, Params::SelectY);
        addAttachedComponent(m_AnalysisControls, m_SelectZ, Params::SelectZ);
 
        // Sliders for adjustung the graphical display
        addAttachedComponent(m_DisplayControls, m_AAlpha, Params::AAlpha);
        addAttachedComponent(m_DisplayControls, m_AH, Params::AH);
        addAttachedComponent(m_DisplayControls, m_AA, Params::AA);
 
        // Mute- Solo Text Buttons
        m_muteButtonAttachment = createParameterAttachment(Params::Mute, m_muteButton);
        m_soloButtonAttachment = createParameterAttachment(Params::Solo, m_soloButton);
 
        // Segmentation select combobox
        m_segmentation.setComponentID(ComponentIds::ComboboxSegmentationId);
        for (const auto& [itemId, itemText] : Kwidget_Reformer::SegmentationMethods)
        {
            jassert(itemId < Kwidget_Reformer::MaxSegmentationMethods);
            m_segmentation.addItem(itemText, itemId + 1);
        }
        auto newValue = m_owner.getParameter(Kwidget_Reformer::Parameters::Segmentation)->getValue();
        auto newItemId = static_cast<int>(newValue * (Kwidget_Reformer::MaxSegmentationMethods - 1));
        m_segmentation.setSelectedId((int)newItemId + 1);
        m_AnalysisControls.addAndMakeVisible(m_segmentation);
        setCoefSliderLabels(newItemId);
 
        m_segmentation.onChange = [this] {
            auto newItemId = m_segmentation.getSelectedId() - 1;
            auto newValue = newItemId / static_cast<float>(Kwidget_Reformer::MaxSegmentationMethods - 1);
            m_owner.getParameter(Kwidget_Reformer::Parameters::Segmentation)->set(newValue);
            setCoefSliderLabels(newItemId);
        };
 
        // Feature Extraction select combobox
        m_featureExtr.setComponentID(ComponentIds::ComboboxFeatureExtrId);
        for (const auto& [itemId, itemText] : Kwidget_Reformer::FeatureExtrMethods)
        {
            jassert(itemId < Kwidget_Reformer::MaxFeatureExtrMethods);
            m_featureExtr.addItem(itemText, itemId + 1);
        }
        newValue = m_owner.getParameter(Kwidget_Reformer::Parameters::FeatureExtr)->getValue();
        newItemId = static_cast<int>(newValue * (Kwidget_Reformer::MaxFeatureExtrMethods - 1));
        m_featureExtr.setSelectedId((int)newItemId + 1);
        m_AnalysisControls.addAndMakeVisible(m_featureExtr);
 
        m_featureExtr.onChange = [this] {
            auto newItemId = m_featureExtr.getSelectedId() - 1;
            auto newValue = newItemId / static_cast<float>(Kwidget_Reformer::MaxFeatureExtrMethods - 1);
            m_owner.getParameter(Kwidget_Reformer::Parameters::FeatureExtr)->set(newValue);
        };
 
        // Trigger select combobox - adds and makes visible
        addAttachedComponent(m_trigger, Params::MIDIMode);
 
        // Vehicle colours
        m_Tracking.setDebugColour(Colours::sandybrown);
 
        // Misc colours
        m_Shape.setDebugColour(Colours::darkred);
        m_GrainMax.setDebugColour(Colours::darkred);
 
        addAndMakeVisible(m_clearButton);
        addAndMakeVisible(m_tweakButton1);
        addAndMakeVisible(m_tweakButton2);
 
        // delete button
        addAndMakeVisible(m_removeEngineButton);
 
        m_removeEngineButton.setButtonText("X");
        m_removeEngineButton.setComponentID(ComponentIds::ButtonClearEngineId);
        m_removeEngineButton.onClick = [&]() {
            if (onDelete)
            {
                onDelete(m_owner.getKwidgetID());
            }
        };
 
        Kwidget_Reformer* owningKwidget = dynamic_cast<Kwidget_Reformer*>(&getOwner());
 
        if (owningKwidget != nullptr)
        {
            if (!owningKwidget->isUCSEnabled())
            {
                m_tweakButton1.setEnabled(false);
                m_tweakButton2.setEnabled(false);
            }
        }
 
        addAndMakeVisible(m_muteButton);
        addAndMakeVisible(m_soloButton);
 
        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.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_PopcornToggle);
        m_PopcornToggle.getButton().setComponentID(ComponentIds::ButtonOneShotToggleId);
        addAndMakeVisible(m_ProximityToggle);
        m_ProximityToggle.getButton().setComponentID(ComponentIds::ButtonProximityToggleId);
        addAndMakeVisible(m_SALoopToggle);
        addAndMakeVisible(m_NormaliseToggle);
        addAndMakeVisible(m_AutoplayToggle);
        addAndMakeVisible(m_QuenchToggle);
 
#ifdef USE_LEGACY_GUI_FEATURES
        addAndMakeVisible(m_RobinToggle);
        addAndMakeVisible(m_AutoRateToggle);
        addAndMakeVisible(m_PhaseLockToggle);
        addAndMakeVisible(m_PhaseSyncToggle);
#endif
 
        m_clearButton.setButtonText("CLEAR");
        m_clearButton.onClick = [this] { clearEngine(); };
 
        // Mute Button
        m_muteButton.setClickingTogglesState(true);
        m_muteButton.setButtonText("M");
        m_muteButton.setComponentID(ComponentIds::ButtonMuteId);
 
        // Solo Button
        m_soloButton.setClickingTogglesState(true);
        m_soloButton.setButtonText("S");
        m_soloButton.setComponentID(ComponentIds::ButtonSoloId);
 
        // Toggle Switches
        m_PopcornToggle.getAttachment() = createParameterAttachment(Params::Popcorn, m_PopcornToggle.getButton());
        m_ProximityToggle.getAttachment() = createParameterAttachment(Params::Proximity, m_ProximityToggle.getButton());
        m_QuenchToggle.getAttachment() = createParameterAttachment(Params::Quench, m_QuenchToggle.getButton());
        m_RobinToggle.getAttachment() = createParameterAttachment(Params::Robin, m_RobinToggle.getButton());
        m_SALoopToggle.getAttachment() = createParameterAttachment(Params::SALoop, m_SALoopToggle.getButton());
        m_NormaliseToggle.getAttachment() = createParameterAttachment(Params::Normalise, m_NormaliseToggle.getButton());
        m_AutoplayToggle.getAttachment() = createParameterAttachment(Params::Autoplay, m_AutoplayToggle.getButton());
        m_SALoopToggle.getButton().setComponentID(ComponentIds::ButtonLoopToggleId);
        m_NormaliseToggle.getButton().setComponentID(ComponentIds::ButtonNormaliseToggleId);
        m_AutoplayToggle.getButton().setComponentID(ComponentIds::ButtonAutoplayId);
 
        m_PopcornToggle.getButton().onClick = [this] {
            auto toggleState = m_PopcornToggle.getButton().getToggleState();
            if (toggleState)
            {
                m_ProximityToggle.getButton().setToggleState(false, NotificationType::dontSendNotification);
            }
        };
 
        m_ProximityToggle.getButton().onClick = [this] {
            auto toggleState = m_ProximityToggle.getButton().getToggleState();
            if (toggleState)
            {
                m_PopcornToggle.getButton().setToggleState(false, NotificationType::dontSendNotification);
            }
        };
 
        m_waveformViewerAndEditor =
                std::make_unique<krotos::WaveformViewerAndEditor>(Colour(152, 152, 152), false, true);
        addAndMakeVisible(m_waveformViewerAndEditor.get());
        m_waveformViewerAndEditor->setChildComponentIds(ComponentIds::WaveformViewerId);
        m_waveformViewerAndEditor->setViewerDropText("DRAG & DROP HERE");
        m_waveformViewerAndEditor->getWaveformViewer()->setDrawGrid(false);
        m_waveformViewerAndEditor->getWaveformViewer()->setShowBorderOnDragHover(true);
        m_waveformViewerAndEditor->getWaveformViewer()->setShowFileName(false);
        m_waveformViewerAndEditor->getWaveformViewer()->setRegexFileFilter(
                String("")); // Empty string - loads everything which is in the dragged folder
        m_waveformViewerAndEditor->addListener(this);
        // TODO: Implement waveform range selection state [KST-2198]
        // m_waveformViewerAndEditor->getAreaSelectionComp()->setWaveformMode(AreaSelectionComp::WaveformMode::onlyStartLine);
 
        m_samplesTree = getOwner().getCustomParameter<SamplesTree>(SamplesTree::Type::Samples);
        jassert(m_samplesTree); // Must exist for sampler state to function!
 
        m_waveformViewerAndEditor->update(m_soSound);
        m_waveformViewerAndEditor->setSelectionEnabled(false); // Reformer does not require segment selection
        m_soSound.addListener(this);
 
        // 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
            {
                // 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
                // TODO: Implement waveform range selection state [KST-2198]
                // m_waveformViewerAndEditor->setEndPosInPercentage(val * 0.01f);
            }
        });
 
        // Sample Browser Dropdown Menu
        m_sampleBrowserButton.getSampleCounter().setVisible(false);
        m_sampleBrowserButton.getPreviousButton().setVisible(false);
        m_sampleBrowserButton.getNextButton().setVisible(false);
        addAndMakeVisible(m_sampleBrowserButton);
        m_sampleBrowserButton.setComponentID(ComponentIds::ButtonSampleBrowserId);
        m_sampleBrowserButton.onClick = [&] {
            OwnedArray<SampleBrowser::Sample> samplesToShow;
            auto* sampler = m_soSound.getSampleEngine();
            if (sampler)
            {
                samplesToShow = m_samplesTree->getSampleDataAsBrowserSamples();
            }
 
            int sampleItemCount = jlimit(0, layout.sampleBrowserMaxItemsToShow, samplesToShow.size());
 
            enum item
            {
                Browser = -1,
                Add = 1,
                RemoveAll
            };
 
            auto browser = std::make_unique<SampleBrowser>(layout.sampleBrowserWidth,
                                                           layout.sampleBrowserItemHeight * sampleItemCount,
                                                           layout.sampleBrowserItemHeight, std::move(samplesToShow));
 
            // KST-2413 temporarily disable sample mute,solo,delete buttons
            browser->setSampleFunctionButtonsVisibility(/*isVisible*/ 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: reformer 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(layout.sampleBrowserItemHeight),
                               menuCallback);
        };
        initialiseZoomControls();
 
        m_sampleBrowserButton.setSampleCount(m_samplesTree->getSamples().size());
        if (m_samplesTree->getSamples().size() == 0)
        {
            clearEngine();
        }
    }
    /* End Reformer Constructor */
 
    void KwidgetGUI_Reformer::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_zoomInButtonImageHover->replaceColour(defaultIconColour, hoverIconColour);
        m_zoomInButtonImageHover->replaceColour(Colours::white, Colours::transparentWhite);
        m_zoomOutButtonImageHover->replaceColour(defaultIconColour, hoverIconColour);
        m_zoomOutButtonImageHover->replaceColour(Colours::white, Colours::transparentWhite);
        m_zoomInButton.setImages(m_zoomInButtonImage.get(), m_zoomInButtonImageHover.get());
        m_zoomOutButton.setImages(m_zoomOutButtonImage.get(), m_zoomOutButtonImageHover.get());
        m_zoomInButton.setButtonStyle(DrawableButton::ButtonStyle::ImageStretched);
        m_zoomOutButton.setButtonStyle(DrawableButton::ButtonStyle::ImageStretched);
        addAndMakeVisible(m_zoomInButton);
        addAndMakeVisible(m_zoomOutButton);
 
        m_zoomInButton.setComponentID(ComponentIds::ButtonZoomInId);
        m_zoomOutButton.setComponentID(ComponentIds::ButtonZoomOutId);
        m_waveformViewerAndEditor->setZoomStyle(WaveformViewerAndEditor::ZoomStyle::centre);
        m_zoomInButton.onClick = [this] { m_waveformViewerAndEditor->zoomIn(); };
        m_zoomOutButton.onClick = [this] { m_waveformViewerAndEditor->zoomOut(); };
 
        // set scroll bar colour and behaviour
        m_waveformViewScrollbar.setRangeLimits(Range<double>(0.0, 1.0), 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_waveformViewScrollbar.setComponentID(ComponentIds::ScrollBarWaveformViewId);
        m_waveformViewScrollbar.setAutoHide(false);
        addAndMakeVisible(m_waveformViewScrollbar);
    }
 
    void KwidgetGUI_Reformer::clearEngine()
    {
        m_waveformViewerAndEditor->clear(); // stop grain display
        m_soSound.clearAndFreeBuffer();
        m_waveformViewerAndEditor->setViewerDropText("DRAG & DROP HERE");
        m_samplesTree->removeAllChildren();
        m_waveformViewerAndEditor->copySegmentsToSelectors();
    }
 
    void KwidgetGUI_Reformer::setCoefSliderLabels(int segmentationId)
    {
        KrotosAudioBufferDSP::SegmentationMethod segmentation = static_cast<Segmentation>(segmentationId);
 
        switch (segmentation)
        {
        case Segmentation::SegmentationNone:
            m_Coeff0.getLabel().setText("Unused", NotificationType::dontSendNotification);
            m_Coeff1.getLabel().setText("Unused", NotificationType::dontSendNotification);
            m_Coeff2.getLabel().setText("Unused", NotificationType::dontSendNotification);
            m_Coeff3.getLabel().setText("Unused", NotificationType::dontSendNotification);
            m_Coeff4.getLabel().setText("Unused", NotificationType::dontSendNotification);
            m_Coeff7.getLabel().setText("Unused", NotificationType::dontSendNotification);
            break;
        case Segmentation::STFT:
            m_Coeff0.getLabel().setText("FrameSize", NotificationType::dontSendNotification);
            m_Coeff1.getLabel().setText("HopSize", NotificationType::dontSendNotification);
            m_Coeff2.getLabel().setText("Unused", NotificationType::dontSendNotification);
            m_Coeff3.getLabel().setText("Unused", NotificationType::dontSendNotification);
            m_Coeff4.getLabel().setText("Unused", NotificationType::dontSendNotification);
            m_Coeff7.getLabel().setText("Unused", NotificationType::dontSendNotification);
            break;
        case Segmentation::EnvOnset:
            m_Coeff0.getLabel().setText("Thresh", NotificationType::dontSendNotification);
            m_Coeff1.getLabel().setText("Onset", NotificationType::dontSendNotification);
            m_Coeff2.getLabel().setText("Decay", NotificationType::dontSendNotification);
            m_Coeff3.getLabel().setText("Unused", NotificationType::dontSendNotification);
            m_Coeff4.getLabel().setText("Unused", NotificationType::dontSendNotification);
            m_Coeff7.getLabel().setText("Unused", NotificationType::dontSendNotification);
            break;
        case Segmentation::OverlapWindow:
            m_Coeff0.getLabel().setText("Unused", NotificationType::dontSendNotification);
            m_Coeff1.getLabel().setText("Unused", NotificationType::dontSendNotification);
            m_Coeff2.getLabel().setText("Unused", NotificationType::dontSendNotification);
            m_Coeff3.getLabel().setText("Unused", NotificationType::dontSendNotification);
            m_Coeff4.getLabel().setText("Unused", NotificationType::dontSendNotification);
            m_Coeff7.getLabel().setText("Unused", NotificationType::dontSendNotification);
            break;
        case Segmentation::SuperFlux:
            m_Coeff0.getLabel().setText("PreMax", NotificationType::dontSendNotification);
            m_Coeff1.getLabel().setText("PostMax", NotificationType::dontSendNotification);
            m_Coeff2.getLabel().setText("PreAvg", NotificationType::dontSendNotification);
            m_Coeff3.getLabel().setText("PostAvg", NotificationType::dontSendNotification);
            m_Coeff4.getLabel().setText("CombWidth", NotificationType::dontSendNotification);
            m_Coeff7.getLabel().setText("Thresh", NotificationType::dontSendNotification);
            break;
        default:
            jassertfalse;
            break;
        }
    }
 
    void KwidgetGUI_Reformer::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);
    }
 
    KwidgetGUI_Reformer::~KwidgetGUI_Reformer() { m_soSound.removeListener(this); }
 
    void KwidgetGUI_Reformer::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);
 
        updateBrowserButtonStatus();
    }
 
    void KwidgetGUI_Reformer::resized()
    {
        KwidgetGUI::resized();
 
        // left panel bounds
        m_reformerNameLabel.setBounds(layout.leftPanel.modeLabel);
 
        m_removeEngineButton.setBounds(Rectangle<int>(470, 5, 284, 6));
 
        m_Level.setBounds(layout.leftPanel.levelSlider);
        m_LevelRand.setBounds(layout.leftPanel.levelRandSlider);
 
        m_Pan.setBounds(layout.leftPanel.panSlider);
        m_PanRand.setBounds(layout.leftPanel.panRandSlider);
 
        m_muteButton.setBounds(layout.leftPanel.muteButton);
        m_soloButton.setBounds(layout.leftPanel.soloButton);
 
        // wavefrom area bounds
        m_waveformViewerAndEditor->setBounds(layout.waveformArea);
 
        // zoom area
        m_zoomOutButton.setBounds(layout.waveformZoomOutButton);
        m_zoomInButton.setBounds(layout.waveformZoomInButton);
        m_waveformViewScrollbar.setBounds(layout.waveformZoomScrollbar);
 
        // toggle group bounds
        Rectangle<int> buttonRect(layout.toggleGroupArea);
        m_SALoopToggle.setBounds(buttonRect.removeFromLeft(layout.loopToggleWidth));
        m_NormaliseToggle.setBounds(buttonRect.removeFromLeft(layout.normalizeToggleWidth));
        m_AutoplayToggle.setBounds(buttonRect.removeFromLeft(layout.autoplayToggleWidth));
        m_ProximityToggle.setBounds(buttonRect.removeFromLeft(layout.proximityToggleWidth));
        m_PopcornToggle.setBounds(buttonRect.removeFromLeft(layout.oneShotToggleWidth));
 
        m_controlsTab.setBounds(layout.controlsTabs.tabbedComponentBounds);
 
        m_removeEngineButton.setBounds(layout.removeEngineButton);
 
        auto kwidgetID = getKwidgetID();
 
        // amp env
        auto adsr0 = m_AdsrControls.findChildWithID(kwidgetID + ":Adsr0");
        if (adsr0 != nullptr)
        {
            adsr0->setBounds(layout.controlsTabs.ampEnvBounds);
        }
 
        // synth tab
        m_Start.setBounds(layout.controlsTabs.rotSliderTopL);
        m_Size.setBounds(layout.controlsTabs.rotSliderTopM);
        m_Rate.setBounds(layout.controlsTabs.rotSliderTopR);
        m_Detune.setBounds(layout.controlsTabs.rotSliderBottomL);
        m_Width.setBounds(layout.controlsTabs.rotSliderBottomM);
        m_GranularLevel.setBounds(layout.controlsTabs.rotSliderBottomR);
 
        // rand tab
        m_StartRand.setBounds(layout.controlsTabs.rotSliderTopL);
        m_SizeRand.setBounds(layout.controlsTabs.rotSliderTopM);
        m_RateRand.setBounds(layout.controlsTabs.rotSliderTopR);
        m_DetuneRand.setBounds(layout.controlsTabs.rotSliderBottomL);
        m_WidthRand.setBounds(layout.controlsTabs.rotSliderBottomM);
 
        // control tab
        m_PuckX.setBounds(layout.controlsTabs.rotSliderTopL);
        m_PuckY.setBounds(layout.controlsTabs.rotSliderTopM);
        m_GrainMax.setBounds(layout.controlsTabs.rotSliderTopR);
        m_Shape.setBounds(layout.controlsTabs.rotSliderBottomL);
        m_Nearest.setBounds(layout.controlsTabs.rotSliderBottomM);
        m_Radius.setBounds(layout.controlsTabs.rotSliderBottomR);
 
        // analysis tab
        m_segmentationLabel.setBounds(layout.controlsTabs.segmentationLabelBounds);
        m_segmentation.setBounds(layout.controlsTabs.segmentationBounds);
 
        m_schemeLabel.setBounds(layout.controlsTabs.schemeLabelBounds);
        m_featureExtr.setBounds(layout.controlsTabs.schemeBounds);
 
        // display tab
        m_AAlpha.setBounds(layout.controlsTabs.rotSliderTopL); // GAlpha
        m_AH.setBounds(layout.controlsTabs.rotSliderTopM);     // Hue
        m_AA.setBounds(layout.controlsTabs.rotSliderBottomL);  // Alpha
        m_Coeff5.setBounds(layout.controlsTabs.rotSliderBottomM);
        m_Coeff6.setBounds(layout.controlsTabs.rotSliderTopR);
 
        m_sampleBrowserButton.setBounds(layout.sampleBrowserButton);
    }
 
    void KwidgetGUI_Reformer::soundChanged(KrotosSampleOscillatorSound* sound)
    {
        m_waveformViewerAndEditor->update(*sound);
        MouseCursor::hideWaitCursor();
    }
 
    void KwidgetGUI_Reformer::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();
        }
 
        // Mixpanel analytics: added samples to core engine
        sendActionMessage(analyticsEventAddedSamplesEngine);
    }
 
    void KwidgetGUI_Reformer::updateBrowserButtonStatus()
    {
        // Update sample browser button text
        if (auto* sampleEngine = m_soSound.getSampleEngine())
        {
            m_sampleBrowserButton.setButtonText(String(sampleEngine->getNumAudioSegments()) + " Samples Loaded");
        }
    }
 
    void KwidgetGUI_Reformer::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_Reformer::moveScrollBarThumb(float newPosition)
    {
        float scrollBarSize = m_waveformViewScrollbar.getCurrentRangeSize();
        newPosition -= (scrollBarSize * 0.5f);
        m_waveformViewScrollbar.setCurrentRangeStart(newPosition, NotificationType::dontSendNotification);
    }
 
    void KwidgetGUI_Reformer::scrollBarMoved(ScrollBar* /*scrollBarThatHasMoved*/, double newRangeStart)
    {
        m_waveformViewerAndEditor->setViewCentre(float(newRangeStart));
    }
} // namespace krotos