macro_knob_section.cpp

Go to the documentation of this file.

#include "macro_knob_section.h"
 
#include "fonts.h"
#include "modulation_button.h"
#include "synth_slider.h"
#include "synth_gui_interface.h"
 
class MacroLabel : public OpenGlImageComponent {
  public:
    MacroLabel(String name, String text) : OpenGlImageComponent(name), text_(std::move(text)), text_size_(1.0f) {
      setInterceptsMouseClicks(false, false);
    }
 
    void setText(String text) { text_ = text; redrawImage(true); }
 
    void setTextSize(float size) { text_size_ = size; redrawImage(true); }
 
    String getText() { return text_; }
 
    void paint(Graphics& g) override {
      g.setColour(findColour(Skin::kBodyText, true));
      g.setFont(Fonts::instance()->proportional_regular().withPointHeight(text_size_));
      g.drawText(text_, 0, 0, getWidth(), getHeight(), Justification::centred, false);
    }
 
  private:
    String text_;      
    float text_size_;  
};
 
class SingleMacroSection : public SynthSection, public TextEditor::Listener {
  public:
    SingleMacroSection(String name, int index) : SynthSection(name), index_(index) {
      std::string number = std::to_string(index_ + 1);
      std::string control_name = "macro_control_" + number;
 
      macro_knob_ = std::make_unique<SynthSlider>(control_name);
      addSlider(macro_knob_.get());
      macro_knob_->setSliderStyle(Slider::RotaryHorizontalVerticalDrag);
      macro_knob_->setPopupPlacement(BubbleComponent::right);
 
      macro_source_ = std::make_unique<ModulationButton>(control_name);
      addModulationButton(macro_source_.get());
      macro_source_->overrideText("");
 
      macro_label_ = std::make_unique<MacroLabel>("Macro Label " + number, "MACRO " + number);
      addOpenGlComponent(macro_label_.get());
 
      edit_label_ = std::make_unique<OpenGlShapeButton>("Edit " + number);
      addAndMakeVisible(edit_label_.get());
      addOpenGlComponent(edit_label_->getGlComponent());
      edit_label_->addListener(this);
      edit_label_->setShape(Paths::pencil());
      edit_label_->setTriggeredOnMouseDown(true);
 
      setSkinOverride(Skin::kMacro);
 
#if !defined(NO_TEXT_ENTRY)
      macro_label_editor_ = std::make_unique<OpenGlTextEditor>("Search");
      macro_label_editor_->addListener(this);
      macro_label_editor_->setSelectAllWhenFocused(true);
      macro_label_editor_->setMultiLine(false, false);
      macro_label_editor_->setJustification(Justification::centred);
      addChildComponent(macro_label_editor_.get());
      addOpenGlComponent(macro_label_editor_->getImageComponent());
#endif
    }
 
    void resized() override {
      int knob_height = getHeight() / 2;
      int button_height = getHeight() - knob_height;
      int width = getWidth();
 
      macro_knob_->setBounds(0, 0, width, knob_height);
      placeRotaryOption(edit_label_.get(), macro_knob_.get());
 
      macro_source_->setBounds(0, knob_height, width, button_height);
      macro_source_->setFontSize(0);
 
      macro_label_->setBounds(getLabelBackgroundBounds(macro_knob_.get()));
      macro_label_->setTextSize(findValue(Skin::kLabelHeight));
    }
 
    void paintBackground(Graphics& g) override {
      paintBody(g);
      paintMacroSourceBackground(g);
      setLabelFont(g);
 
      drawLabelBackgroundForComponent(g, macro_knob_.get());
      paintKnobShadows(g);
      paintChildrenBackgrounds(g);
      paintBorder(g);
    }
 
    void paintBackgroundShadow(Graphics& g) override { paintTabShadow(g); }
 
    void paintMacroSourceBackground(Graphics& g) {
      g.saveState();
      Rectangle<int> bounds = getLocalArea(macro_source_.get(), macro_source_->getLocalBounds());
      g.reduceClipRegion(bounds);
      g.setOrigin(bounds.getTopLeft());
      macro_source_->paintBackground(g);
      g.restoreState();
    }
 
    void buttonClicked(Button* clicked_button) override {
      if (macro_label_editor_) {
        if (macro_label_editor_->isVisible()) {
          saveMacroLabel();
          return;
        }
 
        Rectangle<int> bounds = macro_label_->getBounds();
        float text_height = findValue(Skin::kLabelHeight);
        macro_label_editor_->setFont(Fonts::instance()->proportional_regular().withPointHeight(text_height));
        macro_label_editor_->setText(macro_label_->getText());
        macro_label_editor_->setBounds(bounds.translated(0, -1));
        macro_label_editor_->setVisible(true);
        macro_label_editor_->grabKeyboardFocus();
      }
    }
 
    void saveMacroLabel() {
      macro_label_editor_->setVisible(false);
      String text = macro_label_editor_->getText().trim().toUpperCase();
      if (text.isEmpty())
        return;
 
      macro_label_->setText(text);
 
      SynthGuiInterface* synth_gui_interface = findParentComponentOfClass<SynthGuiInterface>();
      if (synth_gui_interface)
        synth_gui_interface->getSynth()->setMacroName(index_, text);
    }
 
    void textEditorReturnKeyPressed(TextEditor& text_editor) override {
      saveMacroLabel();
    }
 
    void textEditorFocusLost(TextEditor& text_editor) override {
      saveMacroLabel();
    }
 
    void textEditorEscapeKeyPressed(TextEditor& editor) override {
      macro_label_editor_->setVisible(false);
    }
 
    void reset() override {
      SynthGuiInterface* synth_gui_interface = findParentComponentOfClass<SynthGuiInterface>();
      if (synth_gui_interface == nullptr)
        return;
 
      macro_label_->setText(synth_gui_interface->getSynth()->getMacroName(index_));
    }
 
  private:
    int index_;  
    std::unique_ptr<SynthSlider> macro_knob_;         
    std::unique_ptr<ModulationButton> macro_source_;  
    std::unique_ptr<MacroLabel> macro_label_;         
    std::unique_ptr<OpenGlTextEditor> macro_label_editor_; 
    std::unique_ptr<OpenGlShapeButton> edit_label_;   
};
 
MacroKnobSection::MacroKnobSection(String name) : SynthSection(name) {
  setWantsKeyboardFocus(true);
  for (int i = 0; i < vital::kNumMacros; ++i) {
    macros_[i] = std::make_unique<SingleMacroSection>(name + String(i), i);
    addSubSection(macros_[i].get());
  }
 
  setSkinOverride(Skin::kMacro);
}
 
MacroKnobSection::~MacroKnobSection() { }
 
void MacroKnobSection::paintBackground(Graphics& g) {
  paintChildrenBackgrounds(g);
}
 
void MacroKnobSection::resized() {
  int padding = getPadding();
  int knob_section_height = getKnobSectionHeight();
  int widget_margin = getWidgetMargin();
  int width = getWidth();
  int y = 0;
  for (int i = 0; i < vital::kNumMacros; ++i) {
    float next_y = (i + 1) * (2 * knob_section_height - widget_margin + padding);
    macros_[i]->setBounds(0, y, width, next_y - y - padding);
    y = next_y;
  }
 
  int last_y = macros_[vital::kNumMacros - 2]->getBottom() + padding;
  macros_[vital::kNumMacros - 1]->setBounds(0, last_y, width, getHeight() - last_y);
 
  reset();
  SynthSection::resized();
}