SampleBrowser.cpp

Go to the documentation of this file.

namespace krotos
{
    const String SampleBrowser::ComponentIds::VerticalViewportScrollbar("SamplerBrowserVertical");
 
    SampleBrowser::SampleBrowser(int width, int height, int itemHeight, OwnedArray<Sample> samplesToShow)
        : PopupMenu::CustomComponent(false), m_idealWidth(width), m_idealHeight(height), m_itemHeight(itemHeight),
          m_samples(std::move(samplesToShow))
    {
        for (int i = 0; i < m_samples.size(); ++i)
        {
            // Create sample item component
            auto* sampleItem = m_sampleItems.add(std::make_unique<SampleItem>(m_samples[i]->name));
            // Set up mute / solo buttons
            int sampleIndex = m_samples[i]->index;
 
            // Attach buttons to sample mute / solo Value references
            sampleItem->muteButton.getToggleStateValue().referTo(m_samples[i]->muted);
            sampleItem->soloButton.getToggleStateValue().referTo(m_samples[i]->solo);
 
            // Initialise mute active state
            sampleItem->sampleSelectButton.setEnabled(!static_cast<bool>(m_samples[i]->muted.getValue()));
 
            // Solo handling, mute others
            sampleItem->soloButton.onClick = [this, sampleItem, sampleIndex]() {
                bool isSolo = sampleItem->soloButton.getToggleState();
 
                for (int i = 0; i < m_sampleItems.size(); i++)
                {
                    m_sampleItems[i]->muteButton.setToggleState(isSolo && (i != sampleIndex), dontSendNotification);
 
                    m_sampleItems[i]->sampleSelectButton.setEnabled(!m_sampleItems[i]->muteButton.getToggleState());
 
                    // Unsolo other samples if activated
                    if (i != sampleIndex && isSolo)
                    {
                        m_sampleItems[i]->soloButton.setToggleState(false, dontSendNotification);
                    }
                }
 
                if (onSampleSolo)
                {
                    onSampleSolo(sampleIndex, isSolo);
                }
 
                // Retain cue on solo deactivated
                if (isSolo)
                {
                    setCuedSample(sampleIndex, true);
                }
            };
 
            // Prevent all samples from being muted (limitation with sample engine)
            sampleItem->muteButton.onClick = [this, sampleItem, sampleIndex]() {
                if (allMuteButtonsOn())
                {
                    sampleItem->muteButton.setToggleState(false, dontSendNotification);
                }
                sampleItem->sampleSelectButton.setEnabled(!sampleItem->muteButton.getToggleState());
 
                if (onSampleMuted)
                {
                    onSampleMuted(sampleIndex, sampleItem->muteButton.getToggleState());
                }
            };
 
            // Sample select button
            sampleItem->sampleSelectButton.onClick = [this, sampleIndex] {
                if (onSampleSelected)
                {
                    onSampleSelected(sampleIndex);
                }
            };
 
            sampleItem->deleteButton.onClick = [this, sampleIndex] {
                if (onSampleDeleted)
                {
                    onSampleDeleted(sampleIndex);
                }
 
                m_samples.remove(sampleIndex);
                m_sampleItems.remove(sampleIndex);
            };
 
            // Initialise component
            sampleItem->setLookAndFeel(&m_textButtonLAF);
            m_itemsParent.addAndMakeVisible(sampleItem);
        }
 
        addAndMakeVisible(m_scrollableArea);
        m_scrollableArea.setScrollBarThickness(7);
        m_scrollableArea.getVerticalScrollBar().setComponentID(ComponentIds::VerticalViewportScrollbar);
        m_scrollableArea.setViewedComponent(&m_itemsParent);
    }
 
    SampleBrowser::~SampleBrowser()
    {
        for (auto& item : m_sampleItems)
        {
            item->setLookAndFeel(nullptr);
        }
    }
 
    bool SampleBrowser::allMuteButtonsOn()
    {
        for (auto& sample : m_sampleItems)
        {
            if (!sample->muteButton.getToggleState())
            {
                return false;
            }
        }
        return true;
    }
 
    void SampleBrowser::getIdealSize(int& width, int& height)
    {
        width = m_idealWidth;
        height = m_idealHeight;
    }
 
    void SampleBrowser::resized()
    {
        m_scrollableArea.setBounds(0, 0, m_idealWidth, m_idealHeight);
 
        m_itemsParent.setBounds(0, 0, m_idealWidth - m_scrollableArea.getScrollBarThickness(),
                                m_itemHeight * m_samples.size());
 
        int i = 0;
        for (auto btn : m_sampleItems)
        {
            btn->setBounds(0, i * m_itemHeight, m_idealWidth - m_scrollableArea.getScrollBarThickness(), m_itemHeight);
            i++;
        }
    }
 
    void SampleBrowser::setCuedSample(int sampleIndex, bool isCued)
    {
        const int itemCount = std::distance(m_sampleItems.begin(), m_sampleItems.end());
 
        if (sampleIndex >= 0 && sampleIndex < itemCount)
        {
            for (auto& item : m_sampleItems)
            {
                item->setCued(false);
            }
            m_sampleItems[sampleIndex]->setCued(isCued);
        }
    }
 
    // ===============================================================
    SampleBrowser::Sample::Sample(const String& otherName, const String& otherPath, int otherIndex,
                                  const Value& otherMuted, const Value& otherSolo)
        : name(otherName), path(otherPath), index(otherIndex)
    {
        muted.referTo(otherMuted);
        solo.referTo(otherSolo);
    }
 
    SampleBrowser::Sample::Sample(const Sample& other) : name(other.name), path(other.path), index(other.index)
    {
        muted.referTo(other.muted);
        solo.referTo(other.solo);
    }
 
    SampleBrowser::Sample& SampleBrowser::Sample::operator=(const Sample& other)
    {
        name = other.name;
        path = other.path;
        index = other.index;
        muted.referTo(other.muted);
        solo.referTo(other.solo);
        return *this;
    }
 
    void SampleBrowser::ButtonLAF::drawButtonText(Graphics& g, TextButton& button, bool shouldDrawButtonAsHighlighted,
                                                  bool shouldDrawButtonAsDown)
    {
        Font font(button.getHeight());
        g.setFont(font);
 
        auto isHighlighted = button.getProperties()[SampleItem::CuedId];
        auto defaultOpacity = button.getComponentID().contains("Icon") ? 0.1f : isHighlighted ? 1.0f : 0.5f;
        auto opacity = button.isEnabled()
                               ? (button.isMouseButtonDown() ? 1.0f : (button.isMouseOver() ? 0.7f : defaultOpacity))
                               : 0.1f;
 
        g.setColour(
                button.findColour(button.getToggleState() ? TextButton::textColourOnId : TextButton::textColourOffId)
                        .withMultipliedAlpha(opacity));
 
        auto justification =
                button.getComponentID() == "SampleSelectButton" ? Justification::centredLeft : Justification::centred;
 
        g.drawFittedText(utils::ellipsizeStringToWidth(font, button.getButtonText(), button.getWidth()), 0, 0,
                         button.getWidth(), button.getHeight(), justification, 1, 1.0f);
    }
 
    void SampleBrowser::setSampleFunctionButtonsVisibility(bool isVisible)
    {
        for (SampleItem* sample : m_sampleItems)
        {
            sample->muteButton.setVisible(isVisible);
            sample->soloButton.setVisible(isVisible);
            sample->deleteButton.setVisible(isVisible);
        }
    }
 
} // namespace krotos