wavetable_component_overlay.h

Go to the documentation of this file.

#pragma once
 
#include "JuceHeader.h"
 
#include "open_gl_component.h"
#include "open_gl_multi_quad.h"
#include "synth_section.h"
#include "wavetable_playhead.h"
#include "wavetable_organizer.h"
 
class WavetableComponentOverlay : public SynthSection,
                                  public WavetablePlayhead::Listener,
                                  public WavetableOrganizer::Listener {
  public:
    static constexpr int kMaxGrid = 16;
 
    static constexpr float kTitleHeightForWidth = 0.1f;
    static constexpr float kWidgetHeightForWidth = 0.08f;
    static constexpr float kShadowPercent = 0.1f;
    static constexpr float kDividerPoint = 0.44f;
    static constexpr float kTitleHeightRatio = 0.4f;
 
    class ControlsBackground : public SynthSection {
      public:
        static constexpr int kMaxLines = 16;
 
        ControlsBackground() : SynthSection("background"), background_(Shaders::kRoundedRectangleFragment),
                               border_(Shaders::kRoundedRectangleBorderFragment),
                               lines_(kMaxLines, Shaders::kColorFragment),
                               title_backgrounds_(kMaxLines + 1, Shaders::kColorFragment) {
          addOpenGlComponent(&background_);
          addOpenGlComponent(&border_);
          addOpenGlComponent(&lines_);
          addOpenGlComponent(&title_backgrounds_);
 
          background_.setTargetComponent(this);
          border_.setTargetComponent(this);
          lines_.setTargetComponent(this);
          title_backgrounds_.setTargetComponent(this);
 
          for (int i = 0; i <= kMaxLines; ++i) {
            title_texts_[i] = std::make_unique<PlainTextComponent>("text", "");
            addOpenGlComponent(title_texts_[i].get());
            title_texts_[i]->setActive(false);
            title_texts_[i]->setFontType(PlainTextComponent::kLight);
          }
        }
 
        void clearLines() { line_positions_.clear(); setPositions(); }
 
        void clearTitles() { titles_.clear(); setPositions(); }
 
        void addLine(int position) { line_positions_.push_back(position); setPositions(); }
 
        void addTitle(const std::string& title) { titles_.push_back(title); setPositions(); }
 
        void setPositions();
 
      private:
        OpenGlQuad background_;
        OpenGlQuad border_;
        OpenGlMultiQuad lines_;
        OpenGlMultiQuad title_backgrounds_;
        std::unique_ptr<PlainTextComponent> title_texts_[kMaxLines + 1];
        std::vector<int> line_positions_;
        std::vector<std::string> titles_;
    };
 
    class Listener {
      public:
        virtual ~Listener() { }
 
        virtual void frameDoneEditing() = 0;
 
        virtual void frameChanged() = 0;
    };
 
    WavetableComponentOverlay(String name) : SynthSection(name), current_component_(nullptr),
                                             controls_width_(0), initialized_(false), padding_(0) {
      setInterceptsMouseClicks(false, true);
      addSubSection(&controls_background_);
      controls_background_.setAlwaysOnTop(true);
    }
 
    WavetableComponentOverlay() = delete;
 
    void paintBackground(Graphics& g) override { paintChildrenBackgrounds(g); }
 
    void playheadMoved(int position) override { }
 
    virtual void setEditBounds(Rectangle<int> bounds);
 
    virtual bool setTimeDomainBounds(Rectangle<int> bounds) { return false; }
 
    virtual bool setFrequencyAmplitudeBounds(Rectangle<int> bounds) { return false; }
 
    virtual bool setPhaseBounds(Rectangle<int> bounds) { return false; }
 
    void resetOverlay();
 
    void initOpenGlComponents(OpenGlWrapper& open_gl) override {
      SynthSection::initOpenGlComponents(open_gl);
      initialized_ = true;
    }
 
    bool initialized() { return initialized_; }
 
    void addFrameListener(Listener* listener) {
      listeners_.push_back(listener);
    }
 
    void removeListener(Listener* listener) {
      listeners_.erase(std::find(listeners_.begin(), listeners_.end(), listener));
    }
 
    virtual void setPowerScale(bool scale) { }
 
    virtual void setFrequencyZoom(float zoom) { }
 
    void setPadding(int padding) { padding_ = padding; repaint(); }
 
    int getPadding() { return padding_; }
 
    void setComponent(WavetableComponent* component);
 
    WavetableComponent* getComponent() { return current_component_; }
 
  protected:
    void setControlsWidth(int width) { controls_width_ = width; repaint(); }
 
    void notifyChanged(bool mouse_up);
 
    float getTitleHeight();
 
    int getDividerX();
 
    int getWidgetHeight();
 
    int getWidgetPadding();
 
    WavetableComponent* current_component_;
    ControlsBackground controls_background_;
    std::vector<Listener*> listeners_;
    Rectangle<int> edit_bounds_;
    int controls_width_;
    bool initialized_;
    int padding_;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(WavetableComponentOverlay)
};