DISTRHO
/
DISTRHO-Ports
mirror of https://github.com/DISTRHO/DISTRHO-Ports
1
0
Fork 0
Code Releases 5 Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
585 Commits
6 Branches
144MB
Tree: f9c2656797
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f9c2656797'
${ noResults }
DISTRHO-Ports/ports/vitalium/source/interface/editor_sections/full_interface.cpp

874 lines
30KB
Raw Blame History 

  1. /* Copyright 2013-2019 Matt Tytel

  2.  *

  3.  * vital is free software: you can redistribute it and/or modify

  4.  * it under the terms of the GNU General Public License as published by

  5.  * the Free Software Foundation, either version 3 of the License, or

  6.  * (at your option) any later version.

  7.  *

  8.  * vital is distributed in the hope that it will be useful,

  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  11.  * GNU General Public License for more details.

  12.  *

  13.  * You should have received a copy of the GNU General Public License

  14.  * along with vital.  If not, see <http://www.gnu.org/licenses/>.

  15.  */

  16. 

  17. #include "full_interface.h"

  18. 

  19. #include "about_section.h"

  20. #include "bank_exporter.h"

  21. #include "bend_section.h"

  22. #include "delete_section.h"

  23. #include "extra_mod_section.h"

  24. #include "skin.h"

  25. #include "effects_interface.h"

  26. #include "fonts.h"

  27. #include "sound_engine.h"

  28. #include "keyboard_interface.h"

  29. #include "load_save.h"

  30. #include "master_controls_interface.h"

  31. #include "modulation_interface.h"

  32. #include "modulation_manager.h"

  33. #include "modulation_matrix.h"

  34. #include "modulation_meter.h"

  35. #include "wavetable_edit_section.h"

  36. #include "overlay.h"

  37. #include "portamento_section.h"

  38. #include "preset_browser.h"

  39. #include "synthesis_interface.h"

  40. #include "synth_gui_interface.h"

  41. #include "text_look_and_feel.h"

  42. #include "voice_section.h"

  43. 

  44. FullInterface::FullInterface(SynthGuiData* synth_data) : SynthSection("full_interface"), width_(0), resized_width_(0),

  45.                                                          last_render_scale_(0.0f), display_scale_(1.0f),

  46.                                                          pixel_multiple_(1), setting_all_values_(false),

  47.                                                          unsupported_(false), animate_(true),

  48.                                                          enable_redo_background_(true),

  49.                                                          open_gl_(open_gl_context_) {

  50.   full_screen_section_ = nullptr;

  51.   Skin default_skin;

  52.   setSkinValues(default_skin, true);

  53.   default_skin.copyValuesToLookAndFeel(DefaultLookAndFeel::instance());

  54. 

  55.   bool synth = synth_data->wavetable_creators[0];

  56.   if (synth) {

  57.     synthesis_interface_ = std::make_unique<SynthesisInterface>(synth_data->mono_modulations,

  58.                                                                 synth_data->poly_modulations);

  59. 

  60.     for (int i = 0; i < vital::kNumOscillators; ++i) {

  61.       wavetable_edits_[i] = std::make_unique<WavetableEditSection>(i, synth_data->wavetable_creators[i]);

  62.       addSubSection(wavetable_edits_[i].get());

  63.       wavetable_edits_[i]->setVisible(false);

  64.       wavetable_edits_[i]->setWaveFrameSlider(synthesis_interface_->getWaveFrameSlider(i));

  65.     }

  66. 

  67.     addSubSection(synthesis_interface_.get());

  68.   }

  69. 

  70.   effects_interface_ = std::make_unique<EffectsInterface>(synth_data->mono_modulations);

  71.   addSubSection(effects_interface_.get());

  72.   effects_interface_->setVisible(false);

  73.   effects_interface_->addListener(this);

  74. 

  75.   master_controls_interface_ = std::make_unique<MasterControlsInterface>(synth_data->mono_modulations,

  76.                                                                          synth_data->poly_modulations,

  77.                                                                          synth);

  78.   addSubSection(master_controls_interface_.get());

  79.   master_controls_interface_->setVisible(false);

  80. 

  81.   if (synthesis_interface_) {

  82.     for (int i = 0; i < vital::kNumOscillators; ++i)

  83.       master_controls_interface_->passOscillatorSection(i, synthesis_interface_->getOscillatorSection(i));

  84.   }

  85. 

  86.   header_ = std::make_unique<HeaderSection>();

  87.   addSubSection(header_.get());

  88.   header_->addListener(this);

  89. 

  90.   modulation_interface_ = std::make_unique<ModulationInterface>(synth_data);

  91.   addSubSection(modulation_interface_.get());

  92. 

  93.   extra_mod_section_ = std::make_unique<ExtraModSection>("extra_mod_section", synth_data);

  94.   addSubSection(extra_mod_section_.get());

  95. 

  96.   keyboard_interface_ = std::make_unique<KeyboardInterface>(synth_data->synth->getKeyboardState());

  97.   addSubSection(keyboard_interface_.get());

  98. 

  99.   bend_section_ = std::make_unique<BendSection>("BEND");

  100.   addSubSection(bend_section_.get());

  101. 

  102.   portamento_section_ = std::make_unique<PortamentoSection>("PORTAMENTO");

  103.   addSubSection(portamento_section_.get());

  104. 

  105.   voice_section_ = std::make_unique<VoiceSection>("VOICE");

  106.   addSubSection(voice_section_.get());

  107. 

  108.   modulation_matrix_ = std::make_unique<ModulationMatrix>(synth_data->modulation_sources, synth_data->mono_modulations);

  109.   addSubSection(modulation_matrix_.get());

  110.   modulation_matrix_->setVisible(false);

  111.   modulation_matrix_->addListener(this);

  112.   createModulationSliders(synth_data->mono_modulations, synth_data->poly_modulations);

  113. 

  114.   preset_browser_ = std::make_unique<PresetBrowser>();

  115.   addSubSection(preset_browser_.get());

  116.   preset_browser_->setVisible(false);

  117. 

  118.   popup_browser_ = std::make_unique<PopupBrowser>();

  119.   addSubSection(popup_browser_.get());

  120.   popup_browser_->setVisible(false);

  121. 

  122.   popup_selector_ = std::make_unique<SinglePopupSelector>();

  123.   addSubSection(popup_selector_.get());

  124.   popup_selector_->setVisible(false);

  125.   popup_selector_->setAlwaysOnTop(true);

  126.   popup_selector_->setWantsKeyboardFocus(true);

  127. 

  128.   dual_popup_selector_ = std::make_unique<DualPopupSelector>();

  129.   addSubSection(dual_popup_selector_.get());

  130.   dual_popup_selector_->setVisible(false);

  131.   dual_popup_selector_->setAlwaysOnTop(true);

  132.   dual_popup_selector_->setWantsKeyboardFocus(true);

  133. 

  134.   popup_display_1_ = std::make_unique<PopupDisplay>();

  135.   addSubSection(popup_display_1_.get());

  136.   popup_display_1_->setVisible(false);

  137.   popup_display_1_->setAlwaysOnTop(true);

  138.   popup_display_1_->setWantsKeyboardFocus(false);

  139. 

  140.   popup_display_2_ = std::make_unique<PopupDisplay>();

  141.   addSubSection(popup_display_2_.get());

  142.   popup_display_2_->setVisible(false);

  143.   popup_display_2_->setAlwaysOnTop(true);

  144.   popup_display_2_->setWantsKeyboardFocus(false);

  145. 

  146.   bank_exporter_ = std::make_unique<BankExporter>();

  147.   addSubSection(bank_exporter_.get());

  148.   bank_exporter_->setVisible(false);

  149.   header_->setBankExporter(bank_exporter_.get());

  150. 

  151.   save_section_ = std::make_unique<SaveSection>("save_section");

  152.   addSubSection(save_section_.get(), false);

  153.   addChildComponent(save_section_.get());

  154.   preset_browser_->setSaveSection(save_section_.get());

  155.   header_->setSaveSection(save_section_.get());

  156.   header_->setBrowser(preset_browser_.get());

  157. 

  158.   delete_section_ = std::make_unique<DeleteSection>("delete_section");

  159.   addSubSection(delete_section_.get(), false);

  160.   addChildComponent(delete_section_.get());

  161.   preset_browser_->setDeleteSection(delete_section_.get());

  162. 

  163.   about_section_ = std::make_unique<AboutSection>("about");

  164.   addSubSection(about_section_.get(), false);

  165.   addChildComponent(about_section_.get());

  166. 

  167.   if (synthesis_interface_)

  168.     synthesis_interface_->toFront(true);

  169. 

  170.   master_controls_interface_->toFront(true);

  171.   effects_interface_->toFront(true);

  172.   modulation_interface_->toFront(true);

  173.   extra_mod_section_->toFront(true);

  174.   keyboard_interface_->toFront(true);

  175.   bend_section_->toFront(true);

  176.   portamento_section_->toFront(true);

  177.   voice_section_->toFront(true);

  178.   modulation_manager_->toFront(false);

  179.   preset_browser_->toFront(false);

  180.   bank_exporter_->toFront(false);

  181.   about_section_->toFront(true);

  182.   save_section_->toFront(true);

  183.   delete_section_->toFront(true);

  184.   popup_browser_->toFront(true);

  185.   popup_selector_->toFront(true);

  186.   dual_popup_selector_->toFront(true);

  187.   popup_display_1_->toFront(true);

  188.   popup_display_2_->toFront(true);

  189. 

  190.   setAllValues(synth_data->controls);

  191.   setOpaque(true);

  192.   setSkinValues(default_skin, true);

  193. 

  194.   open_gl_context_.setContinuousRepainting(true);

  195.   open_gl_context_.setOpenGLVersionRequired(OpenGLContext::openGL3_2);

  196.   open_gl_context_.setSwapInterval(0);

  197.   open_gl_context_.setRenderer(this);

  198.   open_gl_context_.setComponentPaintingEnabled(false);

  199.   open_gl_context_.attachTo(*this);

  200. }

  201. 

  202. FullInterface::FullInterface() : SynthSection("EMPTY"), open_gl_(open_gl_context_) {

  203.   Skin default_skin;

  204.   setSkinValues(default_skin, true);

  205. 

  206.   open_gl_context_.setContinuousRepainting(true);

  207.   open_gl_context_.setOpenGLVersionRequired(OpenGLContext::openGL3_2);

  208.   open_gl_context_.setSwapInterval(0);

  209.   open_gl_context_.setRenderer(this);

  210.   open_gl_context_.setComponentPaintingEnabled(false);

  211.   open_gl_context_.attachTo(*this);

  212. 

  213.   reset();

  214.   setOpaque(true);

  215. }

  216. 

  217. FullInterface::~FullInterface() {

  218.   open_gl_context_.detach();

  219.   open_gl_context_.setRenderer(nullptr);

  220. }

  221. 

  222. void FullInterface::paintBackground(Graphics& g) {

  223.   g.fillAll(findColour(Skin::kBackground, true));

  224.   paintChildrenShadows(g);

  225. 

  226.   if (effects_interface_ == nullptr)

  227.     return;

  228. 

  229.   int padding = getPadding();

  230.   int bar_width = 6 * padding;

  231.   g.setColour(header_->findColour(Skin::kBody, true));

  232.   int y = header_->getBottom();

  233.   int height = keyboard_interface_->getY() - y;

  234.   int x1 = extra_mod_section_->getRight() + padding;

  235.   g.fillRect(x1, y, bar_width, height);

  236. 

  237.   if (synthesis_interface_) {

  238.     int x2 = synthesis_interface_->getRight() + padding;

  239.     g.fillRect(x2, y, bar_width, height);

  240.   }

  241. 

  242.   paintKnobShadows(g);

  243.   paintChildrenBackgrounds(g);

  244. }

  245. 

  246. void FullInterface::copySkinValues(const Skin& skin) {

  247.   ScopedLock open_gl_lock(open_gl_critical_section_);

  248.   skin.copyValuesToLookAndFeel(DefaultLookAndFeel::instance());

  249.   setSkinValues(skin, true);

  250. }

  251. 

  252. void FullInterface::reloadSkin(const Skin& skin) {

  253.   copySkinValues(skin);

  254.   Rectangle<int> bounds = getBounds();

  255.   setBounds(0, 0, bounds.getWidth() / 4, bounds.getHeight() / 4);

  256.   setBounds(bounds);

  257. }

  258. 

  259. void FullInterface::repaintChildBackground(SynthSection* child) {

  260.   if (!background_image_.isValid() || setting_all_values_)

  261.     return; 

  262. 

  263.   if (child->getParentComponent() == synthesis_interface_.get()) {

  264.     repaintSynthesisSection();

  265.     return;

  266.   }

  267. 

  268.   if (effects_interface_ != nullptr && effects_interface_->isParentOf(child))

  269.     child = effects_interface_.get();

  270. 

  271.   background_.lock();

  272.   Graphics g(background_image_);

  273.   paintChildBackground(g, child);

  274.   background_.updateBackgroundImage(background_image_);

  275.   background_.unlock();

  276. }

  277. 

  278. void FullInterface::repaintSynthesisSection() {

  279.   if (synthesis_interface_ == nullptr || !synthesis_interface_->isVisible() || !background_image_.isValid())

  280.     return;

  281. 

  282.   background_.lock();

  283.   Graphics g(background_image_);

  284.   int padding = findValue(Skin::kPadding);

  285.   g.setColour(findColour(Skin::kBackground, true));

  286.   g.fillRect(synthesis_interface_->getBounds().expanded(padding));

  287.   paintChildShadow(g, synthesis_interface_.get());

  288.   paintChildBackground(g, synthesis_interface_.get());

  289. 

  290.   background_.updateBackgroundImage(background_image_);

  291.   background_.unlock();

  292. }

  293. 

  294. void FullInterface::repaintOpenGlBackground(OpenGlComponent* component) {

  295.   if (!background_image_.isValid())

  296.     return;

  297. 

  298.   background_.lock();

  299.   Graphics g(background_image_);

  300.   paintOpenGlBackground(g, component);

  301.   background_.updateBackgroundImage(background_image_);

  302.   background_.unlock();

  303. }

  304. 

  305. void FullInterface::redoBackground() {

  306.   int width = std::ceil(display_scale_ * getWidth());

  307.   int height = std::ceil(display_scale_ * getHeight());

  308.   if (width < vital::kMinWindowWidth || height < vital::kMinWindowHeight)

  309.     return;

  310. 

  311.   ScopedLock open_gl_lock(open_gl_critical_section_);

  312. 

  313.   background_.lock();

  314.   background_image_ = Image(Image::RGB, width, height, true);

  315.   Graphics g(background_image_);

  316.   paintBackground(g);

  317.   background_.updateBackgroundImage(background_image_);

  318.   background_.unlock();

  319. }

  320. 

  321. void FullInterface::checkShouldReposition(bool resize) {

  322.   float old_scale = display_scale_;

  323.   int old_pixel_multiple = pixel_multiple_;

  324.   display_scale_ = getDisplayScale();

  325.   pixel_multiple_ = std::max<int>(1, display_scale_);

  326. 

  327.   if (resize && (old_scale != display_scale_ || old_pixel_multiple != pixel_multiple_))

  328.     resized();

  329. }

  330. 

  331. void FullInterface::resized() {

  332.   checkShouldReposition(false);

  333. 

  334.   width_ = getWidth();

  335.   if (!enable_redo_background_)

  336.     return;

  337. 

  338.   resized_width_ = width_;

  339. 

  340.   ScopedLock lock(open_gl_critical_section_);

  341.   static constexpr int kTopHeight = 48;

  342. 

  343.   if (effects_interface_ == nullptr)

  344.     return;

  345. 

  346.   int left = 0;

  347.   int top = 0;

  348.   int width = std::ceil(getWidth() * display_scale_);

  349.   int height = std::ceil(getHeight() * display_scale_);

  350.   Rectangle<int> bounds(0, 0, width, height);

  351. 

  352.   float width_ratio = getWidth() / (1.0f * vital::kDefaultWindowWidth);

  353.   float ratio = width_ratio * display_scale_;

  354.   float height_ratio = getHeight() / (1.0f * vital::kDefaultWindowHeight);

  355.   if (width_ratio > height_ratio + 1.0f / vital::kDefaultWindowHeight) {

  356.     ratio = height_ratio;

  357.     width = height_ratio * vital::kDefaultWindowWidth * display_scale_;

  358.     left = (getWidth() - width) / 2;

  359.   }

  360.   if (height_ratio > width_ratio + 1.0f / vital::kDefaultWindowHeight) {

  361.     ratio = width_ratio;

  362.     height = ratio * vital::kDefaultWindowHeight * display_scale_;

  363.     top = (getHeight() - height) / 2;

  364.   }

  365. 

  366.   setSizeRatio(ratio);

  367. 

  368.   popup_browser_->setBounds(bounds);

  369. 

  370.   int padding = getPadding();

  371.   int voice_padding = findValue(Skin::kLargePadding);

  372.   int extra_mod_width = findValue(Skin::kModulationButtonWidth);

  373.   int main_x = left + extra_mod_width + 2 * voice_padding;

  374.   int top_height = kTopHeight * ratio;

  375. 

  376.   int knob_section_height = getKnobSectionHeight();

  377.   int keyboard_section_height = knob_section_height * 0.7f;

  378.   int voice_height = height - top_height - keyboard_section_height;

  379. 

  380.   int section_one_width = 350 * ratio;

  381.   int section_two_width = section_one_width;

  382.   int audio_width = section_one_width + section_two_width + padding;

  383.   int modulation_width = width - audio_width - extra_mod_width - 4 * voice_padding;

  384. 

  385.   header_->setTabOffset(extra_mod_width + 2 * voice_padding);

  386.   header_->setBounds(left, top, width, top_height);

  387.   Rectangle<int> main_bounds(main_x, top + top_height, audio_width, voice_height);

  388. 

  389.   if (synthesis_interface_)

  390.     synthesis_interface_->setBounds(main_bounds);

  391.   effects_interface_->setBounds(main_bounds.withRight(main_bounds.getRight() + voice_padding));

  392.   modulation_matrix_->setBounds(main_bounds);

  393.   int modulation_height = voice_height - knob_section_height - padding;

  394.   modulation_interface_->setBounds(main_bounds.getRight() + voice_padding,

  395.                                    main_bounds.getY(), modulation_width, modulation_height);

  396. 

  397.   int voice_y = top + height - knob_section_height - keyboard_section_height;

  398. 

  399.   int portamento_width = 4 * (int)findValue(Skin::kModulationButtonWidth);

  400.   int portamento_x = modulation_interface_->getRight() - portamento_width;

  401.   portamento_section_->setBounds(portamento_x, voice_y, portamento_width, knob_section_height);

  402. 

  403.   int voice_width = modulation_interface_->getWidth() - portamento_width - padding;

  404.   voice_section_->setBounds(modulation_interface_->getX(), voice_y, voice_width, knob_section_height);

  405. 

  406.   bend_section_->setBounds(left + voice_padding, top + height - knob_section_height - padding,

  407.                            extra_mod_width, knob_section_height);

  408. 

  409.   int extra_mod_height = height - top_height - knob_section_height - padding - 1;

  410.   extra_mod_section_->setBounds(left + voice_padding, top + top_height, extra_mod_width, extra_mod_height);

  411. 

  412.   int keyboard_height = keyboard_section_height - voice_padding - padding;

  413.   int keyboard_x = extra_mod_section_->getRight() + voice_padding;

  414.   int keyboard_width = modulation_interface_->getRight() - keyboard_x;

  415.   keyboard_interface_->setBounds(keyboard_x, top + height - keyboard_height - padding, keyboard_width, keyboard_height);

  416. 

  417.   about_section_->setBounds(bounds);

  418.   save_section_->setBounds(bounds);

  419.   delete_section_->setBounds(bounds);

  420. 

  421.   Rectangle<int> browse_bounds(main_bounds.getX(), main_bounds.getY(),

  422.                                width - main_bounds.getX(), main_bounds.getHeight());

  423.   preset_browser_->setBounds(browse_bounds);

  424.   bank_exporter_->setBounds(browse_bounds);

  425.   SynthSection::resized();

  426. 

  427.   modulation_manager_->setBounds(bounds);

  428.   

  429.   for (int i = 0; i < vital::kNumOscillators; ++i) {

  430.     if (wavetable_edits_[i])

  431.       wavetable_edits_[i]->setBounds(left, 0, width, height);

  432.   }

  433. 

  434.   if (synthesis_interface_) {

  435.     for (int i = 0; i < vital::kNumOscillators; ++i)

  436.       master_controls_interface_->setOscillatorBounds(i, synthesis_interface_->getOscillatorBounds(i));

  437.   }

  438.   master_controls_interface_->setBounds(main_bounds);

  439. 

  440.   if (full_screen_section_) {

  441.     Rectangle<float> relative = synthesis_interface_->getOscillatorSection(0)->getWavetableRelativeBounds();

  442.     int total_width = getWidth() / relative.getWidth();

  443.     full_screen_section_->setBounds(-total_width * relative.getX(), 0, total_width, getHeight());

  444.   }

  445. 

  446.   if (getWidth() && getHeight())

  447.     redoBackground();

  448. }

  449. 

  450. void FullInterface::setOscilloscopeMemory(const vital::poly_float* memory) {

  451.   if (header_)

  452.     header_->setOscilloscopeMemory(memory);

  453.   if (master_controls_interface_)

  454.     master_controls_interface_->setOscilloscopeMemory(memory);

  455. }

  456. 

  457. void FullInterface::setAudioMemory(const vital::StereoMemory* memory) {

  458.   if (header_)

  459.     header_->setAudioMemory(memory);

  460.   if (master_controls_interface_)

  461.     master_controls_interface_->setAudioMemory(memory);

  462. }

  463. 

  464. void FullInterface::createModulationSliders(const vital::output_map& mono_modulations,

  465.                                             const vital::output_map& poly_modulations) {

  466.   std::map<std::string, SynthSlider*> all_sliders = getAllSliders();

  467.   std::map<std::string, SynthSlider*> modulatable_sliders;

  468. 

  469.   for (auto& destination : mono_modulations) {

  470.     if (all_sliders.count(destination.first))

  471.       modulatable_sliders[destination.first] = all_sliders[destination.first];

  472.   }

  473. 

  474.   modulation_manager_ = std::make_unique<ModulationManager>(getAllModulationButtons(),

  475.                                                             modulatable_sliders, mono_modulations, poly_modulations);

  476.   modulation_manager_->setOpaque(false);

  477.   addSubSection(modulation_manager_.get());

  478. }

  479. 

  480. void FullInterface::animate(bool animate) {

  481.   if (animate_ != animate)

  482.     open_gl_context_.setContinuousRepainting(animate);

  483. 

  484.   animate_ = animate;

  485.   SynthSection::animate(animate);

  486. }

  487. 

  488. void FullInterface::reset() {

  489.   ScopedLock lock(open_gl_critical_section_);

  490. 

  491.   if (modulation_interface_)

  492.     modulation_interface_->reset();

  493. 

  494.   setting_all_values_ = true;

  495.   SynthSection::reset();

  496.   modulationChanged();

  497.   if (effects_interface_ && effects_interface_->isVisible())

  498.     effects_interface_->redoBackgroundImage();

  499. 

  500.   setWavetableNames();

  501.   setting_all_values_ = false;

  502.   repaintSynthesisSection();

  503. }

  504. 

  505. void FullInterface::setAllValues(vital::control_map& controls) {

  506.   ScopedLock lock(open_gl_critical_section_);

  507.   setting_all_values_ = true;

  508.   SynthSection::setAllValues(controls);

  509.   setting_all_values_ = false;

  510. }

  511. 

  512. void FullInterface::setWavetableNames() {

  513.   for (int i = 0; i < vital::kNumOscillators; ++i) {

  514.     if (wavetable_edits_[i])

  515.       synthesis_interface_->setWavetableName(i, wavetable_edits_[i]->getName());

  516.   }

  517. }

  518. 

  519. void FullInterface::newOpenGLContextCreated() {

  520.   double version_supported = OpenGLShaderProgram::getLanguageVersion();

  521.   unsupported_ = version_supported < kMinOpenGlVersion;

  522.   if (unsupported_) {

  523.     NativeMessageBox::showMessageBoxAsync(AlertWindow::WarningIcon, "Unsupported OpenGl Version",

  524.                                           String("Vitalium requires OpenGL version: ") + String(kMinOpenGlVersion) +

  525.                                           String("\nSupported version: ") + String(version_supported));

  526.     return;

  527.   }

  528. 

  529.   shaders_ = std::make_unique<Shaders>(open_gl_context_);

  530.   open_gl_.shaders = shaders_.get();

  531.   open_gl_.display_scale = display_scale_;

  532.   last_render_scale_ = display_scale_;

  533. 

  534.   background_.init(open_gl_);

  535.   initOpenGlComponents(open_gl_);

  536. }

  537. 

  538. void FullInterface::renderOpenGL() {

  539.   if (unsupported_)

  540.     return;

  541. 

  542.   float render_scale = open_gl_.context.getRenderingScale();

  543.   if (render_scale != last_render_scale_) {

  544.     last_render_scale_ = render_scale;

  545.     MessageManager::callAsync([=] { checkShouldReposition(true); });

  546.   }

  547. 

  548.   ScopedLock lock(open_gl_critical_section_);

  549.   open_gl_.display_scale = display_scale_;

  550.   background_.render(open_gl_);

  551.   modulation_manager_->renderMeters(open_gl_, animate_);

  552.   renderOpenGlComponents(open_gl_, animate_);

  553. }

  554. 

  555. void FullInterface::openGLContextClosing() {

  556.   if (unsupported_)

  557.     return;

  558. 

  559.   background_.destroy(open_gl_);

  560.   destroyOpenGlComponents(open_gl_);

  561.   open_gl_.shaders = nullptr;

  562.   shaders_ = nullptr;

  563. }

  564. 

  565. void FullInterface::showAboutSection() {

  566.   ScopedLock lock(open_gl_critical_section_);

  567.   about_section_->setVisible(true);

  568. }

  569. 

  570. void FullInterface::deleteRequested(File preset) {

  571.   delete_section_->setFileToDelete(preset);

  572.   delete_section_->setVisible(true);

  573. }

  574. 

  575. void FullInterface::tabSelected(int index) {

  576.   ScopedLock lock(open_gl_critical_section_);

  577.   bool make_visible = !preset_browser_->isVisible() && !bank_exporter_->isVisible();

  578. 

  579.   if (synthesis_interface_)

  580.     synthesis_interface_->setVisible(index == 0 && make_visible);

  581. 

  582.   effects_interface_->setVisible(index == 1 && make_visible);

  583.   modulation_matrix_->setVisible(index == 2 && make_visible);

  584.   master_controls_interface_->setVisible(index == 3 && make_visible);

  585.   modulation_manager_->setModulationAmounts();

  586.   modulation_manager_->resized();

  587.   modulation_manager_->setVisibleMeterBounds();

  588.   modulation_manager_->hideUnusedHoverModulations();

  589.   redoBackground();

  590. }

  591. 

  592. void FullInterface::clearTemporaryTab(int current_tab) {

  593.   ScopedLock lock(open_gl_critical_section_);

  594.   preset_browser_->setVisible(false);

  595.   bank_exporter_->setVisible(false);

  596.   modulation_interface_->setVisible(true);

  597.   portamento_section_->setVisible(true);

  598.   voice_section_->setVisible(true);

  599.   tabSelected(current_tab);

  600. }

  601. 

  602. void FullInterface::setPresetBrowserVisibility(bool visible, int current_tab) {

  603.   ScopedLock lock(open_gl_critical_section_);

  604.   preset_browser_->setVisible(visible);

  605.   modulation_interface_->setVisible(!visible);

  606.   portamento_section_->setVisible(!visible);

  607.   voice_section_->setVisible(!visible);

  608.   synthesis_interface_->setVisible(!visible);

  609. 

  610.   if (visible) {

  611.     tabSelected(-1);

  612.     bank_exporter_->setVisible(false);

  613.     preset_browser_->repaintBackground();

  614.     preset_browser_->grabKeyboardFocus();

  615.     header_->setTemporaryTab("PRESET BROWSER");

  616.   }

  617.   else {

  618.     tabSelected(current_tab);

  619.     header_->setTemporaryTab("");

  620.   }

  621. }

  622. 

  623. void FullInterface::setBankExporterVisibility(bool visible, int current_tab) {

  624.   ScopedLock lock(open_gl_critical_section_);

  625.   bank_exporter_->setVisible(visible);

  626.   modulation_interface_->setVisible(!visible);

  627.   portamento_section_->setVisible(!visible);

  628.   voice_section_->setVisible(!visible);

  629.   synthesis_interface_->setVisible(!visible);

  630. 

  631.   if (visible) {

  632.     tabSelected(-1);

  633.     preset_browser_->setVisible(false);

  634.     bank_exporter_->repaintBackground();

  635.     header_->setTemporaryTab("EXPORT BANK");

  636.   }

  637.   else {

  638.     tabSelected(current_tab);

  639.     header_->setTemporaryTab("");

  640.   }

  641. }

  642. 

  643. void FullInterface::bankImported() {

  644.   preset_browser_->loadPresets();

  645. }

  646. 

  647. void FullInterface::effectsMoved() {

  648.   modulation_manager_->setVisibleMeterBounds();

  649. }

  650. 

  651. void FullInterface::modulationsScrolled() {

  652.   modulation_manager_->setVisibleMeterBounds();

  653. }

  654. 

  655. void FullInterface::setFocus() {

  656.   if (synthesis_interface_ && synthesis_interface_->isShowing())

  657.     synthesis_interface_->setFocus();

  658. }

  659. 

  660. void FullInterface::notifyChange() {

  661.   if (header_)

  662.     header_->notifyChange();

  663. }

  664. 

  665. void FullInterface::notifyFresh() {

  666.   if (header_)

  667.     header_->notifyFresh();

  668. }

  669. 

  670. void FullInterface::externalPresetLoaded(const File& preset) {

  671.   if (preset_browser_)

  672.     preset_browser_->externalPresetLoaded(preset);

  673. }

  674. 

  675. void FullInterface::showFullScreenSection(SynthSection* full_screen) {

  676.   ScopedLock lock(open_gl_critical_section_);

  677.   full_screen_section_ = full_screen;

  678. 

  679.   if (full_screen_section_) {

  680.     addSubSection(full_screen_section_);

  681.     full_screen_section_->setBounds(getLocalBounds());

  682.   }

  683. 

  684.   for (int i = 0; i < vital::kNumOscillators; ++i)

  685.     wavetable_edits_[i]->setVisible(false);

  686. 

  687.   bool show_rest = full_screen == nullptr;

  688.   header_->setVisible(show_rest);

  689.   synthesis_interface_->setVisible(show_rest);

  690.   modulation_interface_->setVisible(show_rest);

  691.   keyboard_interface_->setVisible(show_rest);

  692.   extra_mod_section_->setVisible(show_rest);

  693.   modulation_manager_->setVisible(show_rest);

  694.   voice_section_->setVisible(show_rest);

  695.   bend_section_->setVisible(show_rest);

  696.   portamento_section_->setVisible(show_rest);

  697.   redoBackground();

  698. }

  699. 

  700. void FullInterface::showWavetableEditSection(int index) {

  701.   if (!wavetableEditorsInitialized())

  702.     return;

  703. 

  704.   ScopedLock lock(open_gl_critical_section_);

  705.   for (int i = 0; i < vital::kNumOscillators; ++i)

  706.     wavetable_edits_[i]->setVisible(i == index);

  707. 

  708.   bool show_rest = index < 0;

  709.   header_->setVisible(show_rest);

  710.   synthesis_interface_->setVisible(show_rest);

  711.   modulation_interface_->setVisible(show_rest);

  712.   keyboard_interface_->setVisible(show_rest);

  713.   extra_mod_section_->setVisible(show_rest);

  714.   modulation_manager_->setVisible(show_rest);

  715.   voice_section_->setVisible(show_rest);

  716.   bend_section_->setVisible(show_rest);

  717.   portamento_section_->setVisible(show_rest);

  718.   redoBackground();

  719. }

  720. 

  721. std::string FullInterface::getLastBrowsedWavetable(int index) {

  722.   return wavetable_edits_[index]->getLastBrowsedWavetable();

  723. }

  724. 

  725. std::string FullInterface::getWavetableName(int index) {

  726.   return wavetable_edits_[index]->getName();

  727. }

  728. 

  729. void FullInterface::hideWavetableEditSection() {

  730.   showWavetableEditSection(-1);

  731. }

  732. 

  733. void FullInterface::loadWavetableFile(int index, const File& wavetable) {

  734.   if (wavetable_edits_[index])

  735.     wavetable_edits_[index]->loadFile(wavetable);

  736. }

  737. 

  738. void FullInterface::loadWavetable(int index, json& wavetable_data) {

  739.   if (wavetable_edits_[index])

  740.     wavetable_edits_[index]->loadWavetable(wavetable_data);

  741. }

  742. 

  743. void FullInterface::loadDefaultWavetable(int index) {

  744.   if (wavetable_edits_[index])

  745.     wavetable_edits_[index]->loadDefaultWavetable();

  746. }

  747. 

  748. void FullInterface::resynthesizeToWavetable(int index) {

  749.   if (wavetable_edits_[index])

  750.     wavetable_edits_[index]->resynthesizeToWavetable();

  751. }

  752. 

  753. void FullInterface::saveWavetable(int index) {

  754.   save_section_->setIsPreset(false);

  755.   save_section_->setSaveBounds();

  756.   save_section_->setFileExtension(vital::kWavetableExtension);

  757.   save_section_->setFileType("Wavetable");

  758.   File destination = LoadSave::getUserWavetableDirectory();

  759.   if (!destination.exists())

  760.     destination.createDirectory();

  761.   save_section_->setDirectory(destination);

  762.   save_section_->setFileData(getWavetableJson(index));

  763.   save_section_->setVisible(true);

  764. }

  765. 

  766. void FullInterface::saveLfo(const json& data) {

  767.   save_section_->setIsPreset(false);

  768.   save_section_->setFileExtension(vital::kLfoExtension);

  769.   save_section_->setFileType("LFO");

  770.   save_section_->setDirectory(LoadSave::getUserLfoDirectory());

  771.   save_section_->setFileData(data);

  772.   save_section_->setVisible(true);

  773. }

  774. 

  775. json FullInterface::getWavetableJson(int index) {

  776.   if (wavetable_edits_[index])

  777.     return wavetable_edits_[index]->getWavetableJson();

  778.   return json();

  779. }

  780. 

  781. bool FullInterface::loadAudioAsWavetable(int index, const String& name, InputStream* audio_stream,

  782.                                          WavetableCreator::AudioFileLoadStyle style) {

  783.   if (wavetable_edits_[index])

  784.     return wavetable_edits_[index]->loadAudioAsWavetable(name, audio_stream, style);

  785. 

  786.   delete audio_stream;

  787.   return true;

  788. }

  789. 

  790. void FullInterface::popupBrowser(SynthSection* owner, Rectangle<int> bounds, std::vector<File> directories,

  791.                                  String extensions, std::string passthrough_name,

  792.                                  std::string additional_folders_name) {

  793.   popup_browser_->setIgnoreBounds(getLocalArea(owner, owner->getLocalBounds()));

  794.   popup_browser_->setBrowserBounds(getLocalArea(owner, bounds));

  795.   popup_browser_->setVisible(true);

  796.   popup_browser_->grabKeyboardFocus();

  797.   popup_browser_->setOwner(owner);

  798.   popup_browser_->loadPresets(directories, extensions, passthrough_name, additional_folders_name);

  799. }

  800. 

  801. void FullInterface::popupBrowserUpdate(SynthSection* owner) {

  802.   if (popup_browser_)

  803.     popup_browser_->setOwner(owner);

  804. }

  805. 

  806. void FullInterface::popupSelector(Component* source, Point<int> position, const PopupItems& options,

  807.                                   std::function<void(int)> callback, std::function<void()> cancel) {

  808.   popup_selector_->setCallback(callback);

  809.   popup_selector_->setCancelCallback(cancel);

  810.   popup_selector_->showSelections(options);

  811.   Rectangle<int> bounds(0, 0, std::ceil(display_scale_ * getWidth()), std::ceil(display_scale_ * getHeight()));

  812.   popup_selector_->setPosition(getLocalPoint(source, position), bounds);

  813.   popup_selector_->setVisible(true);

  814. }

  815. 

  816. void FullInterface::dualPopupSelector(Component* source, Point<int> position, int width,

  817.                                       const PopupItems& options, std::function<void(int)> callback) {

  818.   dual_popup_selector_->setCallback(callback);

  819.   dual_popup_selector_->showSelections(options);

  820.   Rectangle<int> bounds(0, 0, std::ceil(display_scale_ * getWidth()), std::ceil(display_scale_ * getHeight()));

  821.   dual_popup_selector_->setPosition(getLocalPoint(source, position), width, bounds);

  822.   dual_popup_selector_->setVisible(true);

  823. }

  824. 

  825. void FullInterface::popupDisplay(Component* source, const std::string& text,

  826.                                  BubbleComponent::BubblePlacement placement, bool primary) {

  827.   PopupDisplay* display = primary ? popup_display_1_.get() : popup_display_2_.get();

  828.   display->setContent(text, getLocalArea(source, source->getLocalBounds()), placement);

  829.   display->setVisible(true);

  830. }

  831. 

  832. void FullInterface::hideDisplay(bool primary) {

  833.   PopupDisplay* display = primary ? popup_display_1_.get() : popup_display_2_.get();

  834.   if (display)

  835.     display->setVisible(false);

  836. }

  837. 

  838. void FullInterface::modulationChanged() {

  839.   if (modulation_matrix_)

  840.     modulation_matrix_->updateModulations();

  841.   if (modulation_interface_)

  842.     modulation_interface_->checkNumShown();

  843.   if (modulation_manager_)

  844.     modulation_manager_->reset();

  845. }

  846. 

  847. void FullInterface::modulationValueChanged(int index) {

  848.   if (modulation_matrix_)

  849.     modulation_matrix_->updateModulationValue(index);

  850.   if (modulation_manager_)

  851.     modulation_manager_->setModulationAmounts();

  852. }

  853. 

  854. void FullInterface::toggleOscillatorZoom(int index) {

  855.   if (full_screen_section_)

  856.     showFullScreenSection(nullptr);

  857.   else

  858.     showFullScreenSection(synthesis_interface_->getOscillatorSection(index));

  859. }

  860. 

  861. void FullInterface::toggleFilter1Zoom() {

  862.   if (full_screen_section_)

  863.     showFullScreenSection(nullptr);

  864.   else

  865.     showFullScreenSection(synthesis_interface_->getFilterSection1());

  866. }

  867. 

  868. void FullInterface::toggleFilter2Zoom() {

  869.   if (full_screen_section_)

  870.     showFullScreenSection(nullptr);

  871.   else

  872.     showFullScreenSection(synthesis_interface_->getFilterSection2());

  873. }