modulation_interface.cpp

Go to the documentation of this file.

#include "modulation_interface.h"
 
#include "envelope_section.h"
#include "extra_mod_section.h"
#include "lfo_section.h"
#include "random_section.h"
#include "synth_gui_interface.h"
 
namespace {
  // Strings representing keyboard modulation sources for top and bottom rows.
  const char* kKeyboardTopModulationStrings[] = {
    "note",
    "velocity",
    "lift",
    "note_in_octave"
  };
 
  const char* kKeyboardBottomModulationStrings[] = {
   "aftertouch",
   "slide",
   "stereo",
   "random",
  };
}
 
ModulationInterface::ModulationInterface(SynthGuiData* synth_data) : SynthSection("modulation") {
  // Create envelope sections
  for (int i = 0; i < vital::kNumEnvelopes; ++i) {
    std::string string_num = std::to_string(i + 1);
    std::string prefix = "env_" + string_num;
    envelopes_[i] = std::make_unique<EnvelopeSection>("ENVELOPE " + string_num, prefix,
                                                      synth_data->mono_modulations, synth_data->poly_modulations);
    addSubSection(envelopes_[i].get());
    envelopes_[i]->setVisible(i == 0);
  }
 
  // Create and configure envelope tab selector
  envelope_tab_selector_ = std::make_unique<ModulationTabSelector>("env", vital::kNumEnvelopes);
  addSubSection(envelope_tab_selector_.get());
  envelope_tab_selector_->addListener(this);
  envelope_tab_selector_->registerModulationButtons(this);
  envelope_tab_selector_->enableSelections();
  envelope_tab_selector_->setMinModulationsShown(kMinEnvelopeModulationsToShow);
  envelope_tab_selector_->connectRight(true);
  envelope_tab_selector_->drawBorders(true);
 
  // Create LFO sections
  for (int i = 0; i < vital::kNumLfos; ++i) {
    std::string string_num = std::to_string(i + 1);
    std::string prefix = "lfo_" + string_num;
    lfos_[i] = std::make_unique<LfoSection>("LFO " + string_num, prefix, synth_data->synth->getLfoSource(i),
                                            synth_data->mono_modulations, synth_data->poly_modulations);
    addSubSection(lfos_[i].get());
    lfos_[i]->setVisible(i == 0);
  }
 
  // Create and configure LFO tab selector
  lfo_tab_selector_ = std::make_unique<ModulationTabSelector>("lfo", vital::kNumLfos);
  addSubSection(lfo_tab_selector_.get());
  lfo_tab_selector_->addListener(this);
  lfo_tab_selector_->registerModulationButtons(this);
  lfo_tab_selector_->enableSelections();
  lfo_tab_selector_->setMinModulationsShown(kMinLfoModulationsToShow);
  lfo_tab_selector_->connectRight(true);
  lfo_tab_selector_->drawBorders(true);
 
  // Create random modulation sections
  for (int i = 0; i < vital::kNumRandomLfos; ++i) {
    std::string string_num = std::to_string(i + 1);
    std::string prefix = "random_" + string_num;
    random_lfos_[i] = std::make_unique<RandomSection>("RANDOM " + string_num, prefix,
                                                      synth_data->mono_modulations, synth_data->poly_modulations);
    addSubSection(random_lfos_[i].get());
    random_lfos_[i]->setVisible(i == 0);
  }
 
  // Create and configure random tab selector
  random_tab_selector_ = std::make_unique<ModulationTabSelector>("random", vital::kNumRandomLfos);
  addSubSection(random_tab_selector_.get());
  random_tab_selector_->addListener(this);
  random_tab_selector_->registerModulationButtons(this);
  random_tab_selector_->enableSelections();
  random_tab_selector_->setMinModulationsShown(kMinRandomModulationsToShow);
  random_tab_selector_->connectRight(true);
  random_tab_selector_->drawBorders(true);
 
  // Keyboard modulation selectors (top and bottom rows)
  keyboard_modulations_top_ = std::make_unique<ModulationTabSelector>("top", 4, kKeyboardTopModulationStrings);
  addSubSection(keyboard_modulations_top_.get());
  keyboard_modulations_top_->registerModulationButtons(this);
  keyboard_modulations_top_->setVertical(false);
  keyboard_modulations_top_->getButton(3)->overrideText("OCT NOTE"); // Special label
  keyboard_modulations_top_->drawBorders(true);
 
  keyboard_modulations_bottom_ = std::make_unique<ModulationTabSelector>("bottom", 4, kKeyboardBottomModulationStrings);
  addSubSection(keyboard_modulations_bottom_.get());
  keyboard_modulations_bottom_->registerModulationButtons(this);
  keyboard_modulations_bottom_->setVertical(false);
  keyboard_modulations_bottom_->getButton(0)->overrideText("PRESSURE"); // Special label
  keyboard_modulations_bottom_->drawBorders(true);
 
  setOpaque(false);
}
 
ModulationInterface::~ModulationInterface() { }
 
void ModulationInterface::paintBackground(Graphics& g) {
  g.fillAll(findColour(Skin::kBackground, true));
  paintBackgroundShadow(g);
 
  // Draw backgrounds behind mod sections
  int mod_x = lfo_tab_selector_->getX();
  int lfo_env_width = lfos_[0]->getRight() - mod_x;
  Rectangle<int> lfo_bounds(mod_x, lfo_tab_selector_->getY(), lfo_env_width, lfo_tab_selector_->getHeight());
  paintBody(g, lfo_bounds);
  Rectangle<int> env_bounds(mod_x, envelope_tab_selector_->getY(), lfo_env_width, envelope_tab_selector_->getHeight());
  paintBody(g, env_bounds);
 
  int random_width = random_lfos_[0]->getRight() - mod_x;
  Rectangle<int> random_bounds(mod_x, random_tab_selector_->getY(), random_width, random_tab_selector_->getHeight());
  paintBody(g, random_bounds);
 
  paintChildrenBackgrounds(g);
  g.saveState();
  int tabs_right = lfo_tab_selector_->getRight();
  g.reduceClipRegion(tabs_right, 0, getWidth() - tabs_right, getHeight());
 
  // Paint borders around sections
  paintBorder(g, lfo_bounds);
  paintBorder(g, env_bounds);
  paintBorder(g, random_bounds);
  g.restoreState();
}
 
void ModulationInterface::paintBackgroundShadow(Graphics& g) {
  paintTabShadow(g, envelope_tab_selector_->getBounds());
  paintTabShadow(g, envelopes_[0]->getBounds());
  paintTabShadow(g, lfo_tab_selector_->getBounds());
  paintTabShadow(g, lfos_[0]->getBounds());
  paintTabShadow(g, random_tab_selector_->getBounds());
  paintTabShadow(g, random_lfos_[0]->getBounds());
  paintTabShadow(g, keyboard_modulations_top_->getBounds());
  paintTabShadow(g, keyboard_modulations_bottom_->getBounds());
}
 
void ModulationInterface::resized() {
  int padding = getPadding();
  int active_width = getWidth();
  int active_height = getHeight() - 2 * padding;
 
  // Allocate vertical space based on minimum modulations shown
  int envelope_height = (active_height * kMinEnvelopeModulationsToShow * 1.0f) / kMinTotalModulations;
  int lfo_height = (active_height * kMinLfoModulationsToShow * 1.0f) / kMinTotalModulations;
  int mod_width = findValue(Skin::kModulationButtonWidth);
 
  // Envelopes
  envelope_tab_selector_->setBounds(0, 0, mod_width, envelope_height);
  Rectangle<int> envelope_bounds(mod_width, 0, active_width - mod_width, envelope_height);
  for (int i = 0; i < vital::kNumEnvelopes; ++i)
    envelopes_[i]->setBounds(envelope_bounds);
 
  // LFOs
  int lfo_y = envelope_bounds.getBottom() + padding;
  lfo_tab_selector_->setBounds(0, lfo_y, mod_width, lfo_height);
  Rectangle<int> lfo_bounds(mod_width, lfo_y, active_width - mod_width, lfo_height);
  for (int i = 0; i < vital::kNumLfos; ++i)
    lfos_[i]->setBounds(lfo_bounds);
 
  // Random modulations
  int keyboard_width = mod_width * 4;
  int keyboard_x = getWidth() - keyboard_width;
 
  int random_y = lfo_bounds.getBottom() + padding;
  int random_height = getHeight() - random_y;
  random_tab_selector_->setBounds(0, random_y, mod_width, random_height);
  Rectangle<int> random_bounds(mod_width, random_y, keyboard_x - padding - mod_width, random_height);
  for (int i = 0; i < vital::kNumRandomLfos; ++i)
    random_lfos_[i]->setBounds(random_bounds);
 
  // Keyboard modulations
  int keyboard_top_height = random_height / 2;
  keyboard_modulations_top_->setBounds(keyboard_x, random_y, keyboard_width, keyboard_top_height);
 
  int keyboard_bottom_y = random_y + keyboard_top_height + 1;
  int keyboard_bottom_height = getHeight() - keyboard_bottom_y;
  keyboard_modulations_bottom_->setBounds(keyboard_x, keyboard_bottom_y, keyboard_width, keyboard_bottom_height);
 
  // Adjust font sizes for selectors
  envelope_tab_selector_->setFontSize(getModFontSize());
  lfo_tab_selector_->setFontSize(getModFontSize());
  random_tab_selector_->setFontSize(getModFontSize());
  keyboard_modulations_top_->setFontSize(getModFontSize());
  keyboard_modulations_bottom_->setFontSize(getModFontSize());
 
  SynthSection::resized();
}
 
void ModulationInterface::reset() {
  lfo_tab_selector_->reset();
  envelope_tab_selector_->reset();
  random_tab_selector_->reset();
  keyboard_modulations_top_->reset();
  keyboard_modulations_bottom_->reset();
 
  // Reset visible sections
  for (int i = 0; i < vital::kNumEnvelopes; ++i) {
    if (envelopes_[i]->isVisible())
      envelopes_[i]->reset();
  }
  for (int i = 0; i < vital::kNumLfos; ++i) {
    if (lfos_[i]->isVisible())
      lfos_[i]->reset();
  }
  for (int i = 0; i < vital::kNumRandomLfos; ++i) {
    if (random_lfos_[i]->isVisible())
      random_lfos_[i]->reset();
  }
}
 
void ModulationInterface::checkNumShown() {
  lfo_tab_selector_->checkNumShown(true);
  envelope_tab_selector_->checkNumShown(true);
  random_tab_selector_->checkNumShown(true);
  keyboard_modulations_top_->checkNumShown(true);
  keyboard_modulations_bottom_->checkNumShown(true);
}
 
void ModulationInterface::modulationSelected(ModulationTabSelector* selector, int index) {
  Image image(Image::ARGB, 1, 1, false);
  Graphics g(image);
 
  // Handle switching between different modulation tabs
  if (selector == envelope_tab_selector_.get()) {
    for (int i = 0; i < vital::kNumEnvelopes; ++i)
      envelopes_[i]->setVisible(i == index);
    envelopes_[index]->paintOpenGlChildrenBackgrounds(g);
    envelopes_[index]->reset();
  }
  else if (selector == lfo_tab_selector_.get()) {
    for (int i = 0; i < vital::kNumLfos; ++i)
      lfos_[i]->setVisible(i == index);
    lfos_[index]->paintOpenGlChildrenBackgrounds(g);
    lfos_[index]->reset();
  }
  else if (selector == random_tab_selector_.get()) {
    for (int i = 0; i < vital::kNumRandomLfos; ++i)
      random_lfos_[i]->setVisible(i == index);
    random_lfos_[index]->paintOpenGlChildrenBackgrounds(g);
    random_lfos_[index]->reset();
  }
}