// Tabbed component
CtrlrLuaMethodEditorTabs::CtrlrLuaMethodEditorTabs(CtrlrLuaMethodEditor &_owner)
: owner(_owner),
TabbedComponent(TabbedButtonBar::TabsAtTop)
{
lf = new CtrlrLuaMethodEditorTabsLF();
setLookAndFeel (lf);
}
//==============================================================================
TheEarPluginAudioProcessorEditor::TheEarPluginAudioProcessorEditor (TheEarPluginAudioProcessor& owner)
: AudioProcessorEditor (owner),
mainTab(owner.keyboardState, processor)
{
Colour backgroundColour(154, 32, 32);
Colour purpleColour(170, 165, 190);
Colour mainColour(135, 205, 222);
Colour greyOne(55, 69, 72);
Colour greyTwo(28, 31, 36);
// lookAndFeel.setColour(MainTab::ColourIds::backgroundColourId, backgroundColour);
lookAndFeel.setColour(Label::ColourIds::textColourId, mainColour);
lookAndFeel.setColour(TextButton::ColourIds::buttonColourId, mainColour);
lookAndFeel.setColour(TextButton::ColourIds::textColourOffId, greyOne);
lookAndFeel.setColour(TextButton::ColourIds::textColourOnId, greyTwo);
lookAndFeel.setColour(ToggleButton::ColourIds::textColourId, mainColour);
setLookAndFeel(&lookAndFeel);
addAndMakeVisible(mainTab);
setSize(800, 700);
}
CabbageInfoButton::CabbageInfoButton (ValueTree wData, String style)
: widgetData (wData),
TextButton()
{
widgetData.addListener (this); //add listener to valueTree so it gets notified when a widget's property changes
initialiseCommonAttributes (this, wData); //initialise common attributes such as bounds, name, rotation, etc..
setLookAndFeelColours (wData);
setButtonText (getText());
filename = CabbageWidgetData::getStringProp (wData, CabbageIdentifierIds::file);
setImgProperties (*this, wData, "buttonon");
setImgProperties (*this, wData, "buttonoff");
addListener (this);
const String imgOff = CabbageWidgetData::getStringProp(wData, CabbageIdentifierIds::imgbuttonoff);
const String imgOver = CabbageWidgetData::getStringProp(wData, CabbageIdentifierIds::imgbuttonover);
const String imgOn = CabbageWidgetData::getStringProp(wData, CabbageIdentifierIds::imgbuttonon);
if(style == "legacy")
{
return;
}
//if users are passing custom images, use old style look and feel
if (CabbageWidgetData::getStringProp(wData, CabbageIdentifierIds::style) == "flat" &&
imgOff.isEmpty() && imgOn.isEmpty() && imgOver.isEmpty())
{
setLookAndFeel(&flatLookAndFeel);
}
}
//==============================================================================
MidiplugAudioProcessorEditor::MidiplugAudioProcessorEditor (MidiplugAudioProcessor& owner)
: AudioProcessorEditor (owner),
_channelSliderComponent(new PkrSliderPropertyComponent("Channel", 0, 15, 1)),
_programSliderComponent(new PkrSliderPropertyComponent("Program", 0, 127, 1))
{
_channelSliderComponent->getSlider()->addListener(this);
_programSliderComponent->getSlider()->addListener(this);
// This is where our plugin's editor size is set.
setSize (400, 300);
addAndMakeVisible(_panel);
_panel.addSection("MIDI Channel", addItems(_channelSliderComponent));
_panel.addSection("Program Change", addItems(_programSliderComponent));
for (int i=0; i<128; ++i) {
PkrSliderPropertyComponent* sliderComponenet = new PkrSliderPropertyComponent("CC-" + std::to_string(i), 0, 127, 1);
_ccSliders.insert(std::pair<Slider*, int>(sliderComponenet->getSlider(), _ccSliders.size()));
sliderComponenet->getSlider()->addListener(this);
_panel.addSection("Control Change", addControlChangeItems(sliderComponenet));
}
//set up our UI look and feel
SquareLookAndFeel* slaf = new SquareLookAndFeel();
setupSquareLookAndFeelColors(*slaf);
setLookAndFeel(slaf);
//start a timer so we can keep the UI up-to-date
startTimer(50);
}
//==============================================================================
BlankenhainAudioProcessorEditor::BlankenhainAudioProcessorEditor (BlankenhainAudioProcessor* ownerFilter)
: AudioProcessorEditor(ownerFilter)
{
addAndMakeVisible (adsr1Wrapper = new GroupWrapComponent<ADSRComponent> (ownerFilter, 0));
adsr1Wrapper->setName ("ADSR1");
addAndMakeVisible (lfo1Wrapper = new GroupWrapComponent<LFOComponent> (ownerFilter, 0));
lfo1Wrapper->setName ("LFO1");
addAndMakeVisible (adsr2Wrapper = new GroupWrapComponent<ADSRComponent> (ownerFilter, 1));
adsr2Wrapper->setName ("ADSR2");
addAndMakeVisible (lfo2Wrapper = new GroupWrapComponent<LFOComponent> (ownerFilter, 1));
lfo2Wrapper->setName ("LFO2");
addAndMakeVisible (osc1Wrapper = new GroupWrapComponent<OscillatorComponent> (ownerFilter, 0));
osc1Wrapper->setName ("OSC1");
addAndMakeVisible (osc2Wrapper = new GroupWrapComponent<OscillatorComponent> (ownerFilter, 1));
osc2Wrapper->setName ("OSC2");
addAndMakeVisible (filter1Wrapper = new GroupWrapComponent<FilterComponent> (ownerFilter, 0));
filter1Wrapper->setName ("Filter1");
addAndMakeVisible (filter2Wrapper = new GroupWrapComponent<FilterComponent> (ownerFilter, 1));
filter2Wrapper->setName ("Filter2");
addAndMakeVisible (osc3Wrapper = new GroupWrapComponent<OscillatorComponent> (ownerFilter, 2));
osc3Wrapper->setName ("OSC3");
addAndMakeVisible (adsr3Wrapper = new GroupWrapComponent<ADSRComponent> (ownerFilter, 2));
adsr3Wrapper->setName ("ADSR3");
addAndMakeVisible (lfo3Wrapper = new GroupWrapComponent<LFOComponent> (ownerFilter, 2));
lfo3Wrapper->setName ("LFO3");
addAndMakeVisible (filter3Wrapper = new GroupWrapComponent<FilterComponent> (ownerFilter, 2));
filter3Wrapper->setName ("Filter3");
addAndMakeVisible (modMatrix = new GroupWrapComponent<ModulationMatrixComponent> (ownerFilter));
modMatrix->setName ("Modulation");
//[UserPreSize]
//[/UserPreSize]
setSize (800, 600);
//[Constructor] You can add your own custom stuff here..
getProcessor()->requestUiUpdate();
startTimer(200);
setLookAndFeel(&lookAndFeel);
//[/Constructor]
}
//==============================================================================
TestComponent::TestComponent (JucerDocument* const doc,
JucerDocument* const loaded,
const bool alwaysFill)
: ownerDocument (doc),
loadedDocument (loaded),
alwaysFillBackground (alwaysFill)
{
setToInitialSize();
updateContents();
testComponents.add (this);
setLookAndFeel (&lookAndFeel);
}
HelmStandaloneEditor::HelmStandaloneEditor() {
setSynth(&synth_);
setGuiState(&gui_state_);
keyboard_state_ = new MidiKeyboardState();
midi_manager_ = new MidiManager(&synth_, keyboard_state_, &gui_state_, &critical_section_, this);
computer_keyboard_ = new HelmComputerKeyboard(&synth_, keyboard_state_, &critical_section_);
output_memory_ = new mopo::Memory(MAX_OUTPUT_MEMORY);
memory_offset_ = 0;
Startup::doStartupChecks(midi_manager_, computer_keyboard_);
setAudioChannels(0, mopo::NUM_CHANNELS);
AudioDeviceManager::AudioDeviceSetup setup;
deviceManager.getAudioDeviceSetup(setup);
setup.sampleRate = mopo::DEFAULT_SAMPLE_RATE;
deviceManager.initialise(0, mopo::NUM_CHANNELS, nullptr, true, "", &setup);
if (deviceManager.getCurrentAudioDevice() == nullptr) {
const OwnedArray<AudioIODeviceType>& device_types = deviceManager.getAvailableDeviceTypes();
for (AudioIODeviceType* device_type : device_types) {
deviceManager.setCurrentAudioDeviceType(device_type->getTypeName(), true);
if (deviceManager.getCurrentAudioDevice())
break;
}
}
const StringArray all_midi_ins(MidiInput::getDevices());
for (int i = 0; i < all_midi_ins.size(); ++i)
deviceManager.setMidiInputEnabled(all_midi_ins[i], true);
deviceManager.addMidiInputCallback("", midi_manager_);
setLookAndFeel(DefaultLookAndFeel::instance());
gui_ = new FullInterface(synth_.getControls(),
synth_.getModulationSources(),
synth_.getMonoModulations(),
synth_.getPolyModulations(),
keyboard_state_);
gui_->setOutputMemory(output_memory_.get());
addAndMakeVisible(gui_);
setSize(WIDTH, HEIGHT);
grabKeyboardFocus();
setWantsKeyboardFocus(true);
addKeyListener(computer_keyboard_);
postMessage(new Message());
setOpaque(true);
}
MainContentComponent::MainContentComponent()
: slider1(Slider::LinearHorizontal,Slider::TextBoxLeft),
slider2(Slider::LinearHorizontal,Slider::TextBoxLeft),
toggle1("Slider style: Linear Bar")
{
setLookAndFeel(&altLookAndFeel);
toggle1.addListener(this);
addAndMakeVisible(&slider1);
addAndMakeVisible(&slider2);
addAndMakeVisible(&toggle1);
setSize(400, 100);
}
MainContentComponent::MainContentComponent(const var &configJson) {
lookAndFeel = new PokeLookAndFeel();
setLookAndFeel(lookAndFeel);
LookAndFeel::setDefaultLookAndFeel(lookAndFeel);
pageStack = new PageStackComponent();
addAndMakeVisible(pageStack);
launcher = new LauncherComponent(configJson);
pageStack->pushPage(launcher, PageStackComponent::kTransitionNone);
setSize(480, 272);
}
//==============================================================================
DRowAudioEditorComponent::DRowAudioEditorComponent (DRowAudioFilter* const ownerFilter)
: AudioProcessorEditor (ownerFilter),
noButtons(3)
{
customLookAndFeel = new dRowLookAndFeel;
setLookAndFeel(customLookAndFeel);
customLookAndFeel->setColour(Label::textColourId, Colours::white);
for (int i = 0; i < noParams; i++)
{
sliders.add( new Slider(String(T("param")) << String(i)) );
addAndMakeVisible( sliders[i]);
String labelName = ownerFilter->getParameterName(i);
sliderLabels.add(new Label(String(T("Label")) << String(i), labelName));
addAndMakeVisible(sliderLabels[i]);
sliderLabels[i]->setJustificationType(Justification::left);
sliderLabels[i]->attachToComponent(sliders[i], false);
sliders[i]->addListener (this);
ownerFilter->getParameterPointer(i)->setupSlider(*sliders[i]);
sliders[i]->setTextBoxStyle(Slider::TextBoxRight, false, 40, 18);
sliders[i]->setColour (Slider::thumbColourId, Colours::grey);
sliders[i]->setColour (Slider::textBoxTextColourId, Colour (0xff78f4ff));
sliders[i]->setColour (Slider::textBoxBackgroundColourId, Colours::black);
sliders[i]->setColour (Slider::textBoxOutlineColourId, Colour (0xff0D2474));
}
sliders[RATE]->setSliderStyle(Slider::RotaryVerticalDrag);
sliders[RATE]->setColour(Slider::rotarySliderFillColourId, Colours::grey);
sliders[RATE]->setTextBoxStyle(Slider::TextBoxBelow, false, 60, 18);
sliderLabels[RATE]->attachToComponent(sliders[RATE], false);
sliderLabels[RATE]->setJustificationType(Justification::centred);
sliders[DEPTH]->setSliderStyle(Slider::RotaryVerticalDrag);
sliders[DEPTH]->setColour(Slider::rotarySliderFillColourId, Colours::grey);
sliders[DEPTH]->setTextBoxStyle(Slider::TextBoxBelow, false, 60, 18);
sliderLabels[DEPTH]->attachToComponent(sliders[DEPTH], false);
sliderLabels[DEPTH]->setJustificationType(Justification::centred);
// set our component's size
setSize (250, 225);
// register ourselves with the filter - it will use its ChangeBroadcaster base
// class to tell us when something has changed, and this will call our changeListenerCallback()
// method.
ownerFilter->addChangeListener (this);
}
EditorWindow (ValueList& list)
: DocumentWindow ("Live Values", Colours::lightgrey, DocumentWindow::closeButton)
{
setLookAndFeel (&lookAndFeel);
setUsingNativeTitleBar (true);
viewport.setViewedComponent (new ValueListHolderComponent (list), true);
viewport.setSize (700, 600);
viewport.setScrollBarsShown (true, false);
setContentNonOwned (&viewport, true);
setResizable (true, false);
setResizeLimits (500, 400, 10000, 10000);
centreWithSize (getWidth(), getHeight());
setVisible (true);
}
ComponentOverlay::ComponentOverlay (Component* targetChild, ComponentLayoutEditor* owner)
: target (targetChild), layoutEditor (owner), lookAndFeel()
{
resizeContainer = new ComponentBoundsConstrainer();
resizeContainer->setMinimumSize (10, 10); //set minimum size so objects cant be resized too small
resizer = new ResizableBorderComponent (this, resizeContainer);
addAndMakeVisible (resizer);
resizer->addMouseListener (this, false);
constrainer = new ComponentBoundsConstrainer();
interest = "none";
userAdjusting = false;
updateFromTarget ();
setLookAndFeel (&lookAndFeel);
setRepaintsOnMouseActivity (true);
addKeyListener (this);
}
MainContentComponent::~MainContentComponent()
{
previewWindow = nullptr;
stepToCopy.clear();
sequenceToCopy = Sequence();
#if JUCE_MAC
setMacMainMenu( nullptr );
#endif
chaseManager = nullptr;
sliceManager = nullptr;
xmlManager = nullptr;
achievementManager = nullptr;
setLookAndFeel( nullptr );
}
//==============================================================================
MainComponent::MainComponent (PdAudioProcessor& processor)
: AudioProcessorEditor(processor),
TUIOComponent(this),
pdEditor(processor),
pulpConfigUI(&processor)
{
lookNFeel = new LookNFeel();
setLookAndFeel(lookNFeel);
addAndMakeVisible(pulpConfigUI);
// logTimer.startTimer(300);
addAndMakeVisible(pdEditor);
pdEditor.buildCanvas();
pdEditor.updatePatch();
addKeyListener(this);
pulpConsole.setReadOnly(true);
pulpConsole.setMultiLine(true);
pulpConsole.setScrollToShowCursor(true);
pulpConsole.setSize(400, 500);
consoleFont.setHeight(10);
pulpConsole.setFont(consoleFont);
addAndMakeVisible(pulpConsole);
// addAndMakeVisible (resizer = new ResizableCornerComponent (this, &resizeLimits));
// resizeLimits.setSizeLimits (150, 150, 1000, 1000);
// setSize (500, 385);
resized();
addChangeListener(this);
}
HelmStandaloneEditor::HelmStandaloneEditor() : SynthGuiInterface(this) {
computer_keyboard_ = new HelmComputerKeyboard(&engine_, keyboard_state_);
setAudioChannels(0, mopo::NUM_CHANNELS);
AudioDeviceManager::AudioDeviceSetup setup;
deviceManager.getAudioDeviceSetup(setup);
setup.sampleRate = mopo::DEFAULT_SAMPLE_RATE;
deviceManager.initialise(0, mopo::NUM_CHANNELS, nullptr, true, "", &setup);
if (deviceManager.getCurrentAudioDevice() == nullptr) {
const OwnedArray<AudioIODeviceType>& device_types = deviceManager.getAvailableDeviceTypes();
for (AudioIODeviceType* device_type : device_types) {
deviceManager.setCurrentAudioDeviceType(device_type->getTypeName(), true);
if (deviceManager.getCurrentAudioDevice())
break;
}
}
const StringArray all_midi_ins(MidiInput::getDevices());
for (int i = 0; i < all_midi_ins.size(); ++i)
deviceManager.setMidiInputEnabled(all_midi_ins[i], true);
deviceManager.addMidiInputCallback("", midi_manager_);
setLookAndFeel(DefaultLookAndFeel::instance());
addAndMakeVisible(gui_);
gui_->setOutputMemory(getOutputMemory());
gui_->animate(LoadSave::shouldAnimateWidgets());
setSize(WIDTH, HEIGHT);
setWantsKeyboardFocus(true);
grabKeyboardFocus();
addKeyListener(computer_keyboard_);
postMessage(new Message());
setOpaque(true);
}
AboutUsComponent() :
csPlayerLabel(nullptr), csPlayerDetailTE(nullptr), csTeamTE(nullptr), csLicenceTE(nullptr),
csPlayerSource(nullptr), csPlayerSite(nullptr),
csPlayerGroupComponent(nullptr), csTeamgroupComponent(nullptr), csLicencegroupComponent(nullptr)
{
LookAndFeel::getDefaultLookAndFeel().setColour(TextEditor::textColourId, Colours::grey);
setLookAndFeel(&LookAndFeel::getDefaultLookAndFeel());
addAndMakeVisible (csPlayerLabel = new Label ("scPlayer", "Server-Client Audio Player"));
csPlayerLabel->setFont (Font (20.0000f, Font::bold));
csPlayerLabel->setJustificationType (Justification::centredLeft);
csPlayerLabel->setEditable (false, false, false);
csPlayerLabel->setColour (TextEditor::backgroundColourId, Colour (0x0));
addAndMakeVisible (csPlayerGroupComponent = new GroupComponent ("ScPlayer group", "ScPlayer"));
addAndMakeVisible (csPlayerDetailTE = new TextEditor ("scPlayer Details"));
csPlayerDetailTE->setFont (Font (13.30f, Font::plain));
csPlayerDetailTE->setReadOnly (true);
csPlayerDetailTE->setMultiLine(true, true);
csPlayerDetailTE->setText("ScPlayer \"Server Client Audio Player\" is C++ based "
"Music player built using Juce and DrowAudio for Network "
"teams to play their server placed "
"music in the network. ScPlayer is Server "
"Audio Player and Client player Manager kind of application.");
csPlayerDetailTE->setColour (TextEditor::outlineColourId, Colour (0x0));
csPlayerDetailTE->setColour (TextEditor::focusedOutlineColourId, Colour (0x0));
csPlayerDetailTE->setColour (TextEditor::shadowColourId, Colour (0x0));
csPlayerDetailTE->setColour (TextEditor::textColourId, Colours::grey);
csPlayerDetailTE->setColour (TextEditor::backgroundColourId, Colour (0x0));
addAndMakeVisible (csTeamgroupComponent = new GroupComponent ("ScTeam group", "ScTeam"));
addAndMakeVisible (csTeamTE = new TextEditor ("scTeam Details"));
csTeamTE->setFont (Font (13.0000f, Font::plain));
csTeamTE->setMultiLine(true, true);
csTeamTE->setText("ScTeam is group of people willingly developes ScPlayer. "
"CyberCBM Owns most rights (Though GPUV2 Licence) and responsible for work inside ScPlayer. "
"Other helping Members in CsTeam are NREZ, Hammer, PD, Vrushabh.");
csTeamTE->setReadOnly (true);
csTeamTE->setColour (TextEditor::outlineColourId, Colour (0x0));
csTeamTE->setColour (TextEditor::focusedOutlineColourId, Colour (0x0));
csTeamTE->setColour (TextEditor::shadowColourId, Colour (0x0));
csTeamTE->setColour (TextEditor::textColourId, Colours::grey);
csTeamTE->setColour (TextEditor::backgroundColourId, Colour (0x0));
addAndMakeVisible (csLicencegroupComponent = new GroupComponent ("Licence group", "Licence: GPU-V2"));
addAndMakeVisible (csLicenceTE = new TextEditor ("scLicence Details"));
csLicenceTE->setFont (Font (13.0000f, Font::plain));
csLicenceTE->setMultiLine(true, true);
csLicenceTE->setText("This program is free software; you can redistribute it and/or modify "
"it under the terms of the GNU General Public License as published by "
"the Free Software Foundation; either version 2 of the License, or "
"(at your option) any later version.\n\n"
"This program is distributed in the hope that it will be useful, "
"but WITHOUT ANY WARRANTY; without even the implied warranty of "
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. "
"See the GNU General Public License for more details. ");
csLicenceTE->setReadOnly (true);
csLicenceTE->setColour (TextEditor::outlineColourId, Colour (0x0));
csLicenceTE->setColour (TextEditor::focusedOutlineColourId, Colour (0x0));
csLicenceTE->setColour (TextEditor::shadowColourId, Colour (0x0));
csLicenceTE->setColour (TextEditor::outlineColourId, Colour (0x0));
csLicenceTE->setColour (TextEditor::textColourId, Colours::grey);
csLicenceTE->setColour (TextEditor::backgroundColourId, Colour (0x0));
addAndMakeVisible (csPlayerSite = new HyperlinkButton ("ScPlayer", URL ("https://cybercbm.github.com/ScPlayer")));
csPlayerSite->setFont(Font (16.0000f, Font::bold), false, Justification::centred);
addAndMakeVisible (csPlayerSource = new HyperlinkButton ("Get ScPlayer Source Code", URL ("https://github.com/cyberCBM/ScPlayer")));
csPlayerSource->setFont(Font (16.0000f, Font::bold), false, Justification::centred);
}
void LuftikusAudioProcessorEditor::initGui()
{
for (int i=0; i<EqDsp::kNumTypes; ++i)
{
addAndMakeVisible(&guiSliders[i]);
addAndMakeVisible(&labels[i]);
guiSliders[i].addListener(this);
guiSliders[i].setTextBoxStyle(Slider::NoTextBox, false, 60, 20);
guiSliders[i].setSliderStyle(Slider::RotaryVerticalDrag);
labels[i].setText(Proc->getParameterName(i), dontSendNotification);
}
setLookAndFeel(&guiLookAndFeel);
updateSliders();
addAndMakeVisible(&mastering);
mastering.addListener(this);
addAndMakeVisible(&analog);
analog.addListener(this);
addAndMakeVisible(&keepGain);
keepGain.addListener(this);
for (int i=0; i<EqDsp::kNumHighSelves; ++i)
{
addAndMakeVisible(&types[i]);
types[i].addListener(this);
types[i].setRadioGroupId(674);
}
{
types[0].setButtonText("");
types[1].setButtonText("");
types[2].setButtonText("");
types[3].setButtonText("");
types[4].setButtonText("");
types[5].setButtonText("");
mastering.setButtonText("");
analog.setButtonText("");
keepGain.setButtonText("");
}
{
addAndMakeVisible(&guiMasterVol);
guiMasterVol.addListener(this);
guiMasterVol.setTextBoxStyle(Slider::NoTextBox, false, 50, 13);
guiMasterVol.setSliderStyle(Slider::RotaryVerticalDrag);
Range<float> volRange(Proc->getMasterVolume().getRangeDb());
guiMasterVol.setRange(volRange.getStart(), volRange.getEnd(), 0.1);
}
{
guiSliders[EqDsp::kBand10].setTooltip("Gain/cut 10 Hz band");
guiSliders[EqDsp::kBand40].setTooltip("Gain/cut 40 Hz band");
guiSliders[EqDsp::kBand160].setTooltip("Gain/cut 160 Hz band");
guiSliders[EqDsp::kBand640].setTooltip("Gain/cut 640 Hz band");
guiSliders[EqDsp::kShelf2k5].setTooltip("Gain/cut 2.5 kHz high shelf");
guiSliders[EqDsp::kShelfHi].setTooltip("High shelf boost");
guiMasterVol.setTooltip("Output volume trim (in dB)");
types[0].setTooltip("High shelf boost off");
types[1].setTooltip("High shelf boost @ 2.5 kHz");
types[2].setTooltip("High shelf boost @ 5 kHz");
types[3].setTooltip("High shelf boost @ 10 kHz");
types[4].setTooltip("High shelf boost @ 20 kHz");
types[5].setTooltip("High shelf boost @ 40 kHz");
mastering.setTooltip("Enable mastering mode");
analog.setTooltip("Enable analog emulation");
keepGain.setTooltip("Avoid overall gain boosts/cuts when applying EQ gain");
//addAndMakeVisible(&showTooltips);
//showTooltips.addListener(this);
updateTooltipState();
}
background = ImageCache::getFromMemory(BinaryData::luftikus_front_002_png, BinaryData::luftikus_front_002_pngSize);
//bgInfo = ImageCache::getFromMemory(BinaryData::luftikus_back_png, BinaryData::luftikus_back_pngSize);
//luftikus = ImageCache::getFromMemory(BinaryData::Demo_neueKnobs_png, BinaryData::Demo_neueKnobs_pngSize);
setSize (720, 205);
startTimer(100);
}
//==============================================================================
MainContentComponent::MainContentComponent()
{
laf = new ColourLookAndFeel();
setLookAndFeel( laf );
version = ProjectInfo::versionString;
xmlManager = new ChaserXmlManager();
//try to get the last used chaser file
//this will create and return a deafult filename if nothing is found
File lastChaser = FileLess::getLastUsedFileName( FileLess::Chaser );
xmlManager->setSaveFile( lastChaser );
//save the version
XmlElement* versionXml = new XmlElement( "version" );
versionXml->setAttribute( "nr", version );
xmlManager->saveXmlElement( versionXml );
achievementManager = new AchievementManager();
sliceManager = new SliceManager( xmlManager );
chaseManager = new ChaseManager( xmlManager, sliceManager, achievementManager );
previewWindow = new Preview( chaseManager, sliceManager, achievementManager );
addAndMakeVisible( previewWindow );
sequencer = new Sequencer( chaseManager );
addAndMakeVisible( sequencer );
SliceList* sliceList = new SliceList( chaseManager, sliceManager );
//SequenceList* sequenceList = new SequenceList( chaseManager );
listBrowser = new ListBrowser();
listBrowser->addComponentAsTab( sliceList, "Slices" );
//listBrowser->addComponentAsTab( sequenceList, "Sequences" );
addAndMakeVisible( listBrowser );
//chaseManager->addUpdateable( sequenceList );
chaseManager->addUpdateable( sequencer );
chaseManager->addUpdateable( previewWindow );
sliceManager->addUpdateable( sliceList );
sliceManager->addUpdateable( previewWindow );
copier = new Copier( chaseManager );
addAndMakeVisible( copier );
creator = new ChaserCreator( sliceManager, chaseManager, previewWindow, sliceList );
//start checking for ass file updates once per second
autoUpdate = new AutoUpdateTimer( creator );
autoUpdate->start();
//add a menu bar
menuBar = new MenuBarComponent( this );
#if JUCE_WINDOWS
addAndMakeVisible( menuBar );
#elif JUCE_MAC
setMacMainMenu( this );
#endif
addKeyListener( this );
setSize( 1280, 720 );
//start a timer to update the window name
startTimer( 1000 );
}
ComponentOverlay::~ComponentOverlay ()
{
setLookAndFeel (nullptr);
delete resizer;
}
SqueezerAudioProcessorEditor::SqueezerAudioProcessorEditor(
SqueezerAudioProcessor *OwnerFilter,
SqueezerPluginParameters *PluginParameters,
int NumberOfChannels)
: AudioProcessorEditor(OwnerFilter)
{
// load look and feel
currentLookAndFeel_ = new frut::skin::LookAndFeel_Frut_V3;
setLookAndFeel(currentLookAndFeel_);
// the editor window does not have any transparent areas
// (increases performance on redrawing)
setOpaque(true);
// prevent meter updates during initialisation
IsInitialising_ = true;
// The plug-in editor's size as well as the location of buttons
// and labels will be set later on in this constructor.
PluginProcessor_ = OwnerFilter;
PluginProcessor_->addActionListener(this);
NumberOfChannels_ = NumberOfChannels;
SliderThreshold_ = new frut::widgets::SliderCombined(
PluginParameters,
SqueezerPluginParameters::selThreshold,
SqueezerPluginParameters::selThresholdSwitch);
SliderThreshold_->addListener(this);
SliderThreshold_->addButtonListener(this);
addAndMakeVisible(SliderThreshold_);
SliderRatio_ = new frut::widgets::SliderCombined(
PluginParameters,
SqueezerPluginParameters::selRatio,
SqueezerPluginParameters::selRatioSwitch);
SliderRatio_->addListener(this);
SliderRatio_->addButtonListener(this);
addAndMakeVisible(SliderRatio_);
SliderAttackRate_ = new frut::widgets::SliderCombined(
PluginParameters,
SqueezerPluginParameters::selAttackRate,
SqueezerPluginParameters::selAttackRateSwitch);
SliderAttackRate_->addListener(this);
SliderAttackRate_->addButtonListener(this);
addAndMakeVisible(SliderAttackRate_);
SliderReleaseRate_ = new frut::widgets::SliderCombined(
PluginParameters,
SqueezerPluginParameters::selReleaseRate,
SqueezerPluginParameters::selReleaseRateSwitch);
SliderReleaseRate_->addListener(this);
SliderReleaseRate_->addButtonListener(this);
addAndMakeVisible(SliderReleaseRate_);
SliderMakeupGain_ = new frut::widgets::SliderCombined(
PluginParameters,
SqueezerPluginParameters::selMakeupGain,
SqueezerPluginParameters::selMakeupGainSwitch);
SliderMakeupGain_->addListener(this);
SliderMakeupGain_->addButtonListener(this);
addAndMakeVisible(SliderMakeupGain_);
SliderWetMix_ = new frut::widgets::SliderCombined(
PluginParameters,
SqueezerPluginParameters::selWetMix,
SqueezerPluginParameters::selWetMixSwitch);
SliderWetMix_->addListener(this);
SliderWetMix_->addButtonListener(this);
addAndMakeVisible(SliderWetMix_);
SliderSidechainHPFCutoff_ = new frut::widgets::SliderCombined(
PluginParameters,
SqueezerPluginParameters::selSidechainHPFCutoff,
SqueezerPluginParameters::selSidechainHPFCutoffSwitch);
SliderSidechainHPFCutoff_->addListener(this);
SliderSidechainHPFCutoff_->addButtonListener(this);
addAndMakeVisible(SliderSidechainHPFCutoff_);
SliderSidechainLPFCutoff_ = new frut::widgets::SliderCombined(
PluginParameters,
SqueezerPluginParameters::selSidechainLPFCutoff,
SqueezerPluginParameters::selSidechainLPFCutoffSwitch);
SliderSidechainLPFCutoff_->addListener(this);
SliderSidechainLPFCutoff_->addButtonListener(this);
addAndMakeVisible(SliderSidechainLPFCutoff_);
ButtonBypass_.addListener(this);
addAndMakeVisible(&ButtonBypass_);
ButtonDetectorRms_.addListener(this);
addAndMakeVisible(&ButtonDetectorRms_);
ButtonDesignFeedback_.addListener(this);
addAndMakeVisible(&ButtonDesignFeedback_);
ButtonGainStageOptical_.addListener(this);
addAndMakeVisible(&ButtonGainStageOptical_);
ButtonDetectorLinear_.setRadioGroupId(1);
ButtonDetectorLinear_.addListener(this);
addAndMakeVisible(&ButtonDetectorLinear_);
ButtonDetectorSmoothDecoupled_.setRadioGroupId(1);
ButtonDetectorSmoothDecoupled_.addListener(this);
addAndMakeVisible(&ButtonDetectorSmoothDecoupled_);
ButtonDetectorSmoothBranching_.setRadioGroupId(1);
ButtonDetectorSmoothBranching_.addListener(this);
addAndMakeVisible(&ButtonDetectorSmoothBranching_);
ButtonKneeHard_.setRadioGroupId(2);
ButtonKneeHard_.addListener(this);
addAndMakeVisible(&ButtonKneeHard_);
ButtonKneeMedium_.setRadioGroupId(2);
ButtonKneeMedium_.addListener(this);
addAndMakeVisible(&ButtonKneeMedium_);
ButtonKneeSoft_.setRadioGroupId(2);
ButtonKneeSoft_.addListener(this);
addAndMakeVisible(&ButtonKneeSoft_);
ButtonAutoMakeupGain_.addListener(this);
addAndMakeVisible(&ButtonAutoMakeupGain_);
ButtonSidechainInput_.addListener(this);
addAndMakeVisible(&ButtonSidechainInput_);
ButtonSidechainListen_.addListener(this);
addAndMakeVisible(&ButtonSidechainListen_);
ButtonSkin_.addListener(this);
addAndMakeVisible(&ButtonSkin_);
ButtonReset_.addListener(this);
addAndMakeVisible(&ButtonReset_);
ButtonSettings_.addListener(this);
addAndMakeVisible(&ButtonSettings_);
ButtonAbout_.addListener(this);
addAndMakeVisible(&ButtonAbout_);
#ifdef DEBUG
// moves debug label to the back of the editor's z-plane to that
// it doesn't overlay (and thus block) any other components
addAndMakeVisible(LabelDebug_, 0);
#endif
// prevent unnecessary redrawing of plugin editor
BackgroundImage_.setOpaque(true);
// moves background image to the back of the editor's z-plane to
// that it doesn't overlay (and thus block) any other components
addAndMakeVisible(BackgroundImage_, 0);
updateParameter(SqueezerPluginParameters::selBypass);
updateParameter(SqueezerPluginParameters::selThresholdSwitch);
updateParameter(SqueezerPluginParameters::selThreshold);
updateParameter(SqueezerPluginParameters::selRatioSwitch);
updateParameter(SqueezerPluginParameters::selRatio);
updateParameter(SqueezerPluginParameters::selAttackRateSwitch);
updateParameter(SqueezerPluginParameters::selAttackRate);
updateParameter(SqueezerPluginParameters::selReleaseRateSwitch);
updateParameter(SqueezerPluginParameters::selReleaseRate);
updateParameter(SqueezerPluginParameters::selMakeupGainSwitch);
updateParameter(SqueezerPluginParameters::selMakeupGain);
updateParameter(SqueezerPluginParameters::selWetMixSwitch);
updateParameter(SqueezerPluginParameters::selWetMix);
updateParameter(SqueezerPluginParameters::selSidechainHPFCutoffSwitch);
updateParameter(SqueezerPluginParameters::selSidechainHPFCutoff);
updateParameter(SqueezerPluginParameters::selSidechainLPFCutoffSwitch);
updateParameter(SqueezerPluginParameters::selSidechainLPFCutoff);
updateParameter(SqueezerPluginParameters::selDetectorRmsFilter);
updateParameter(SqueezerPluginParameters::selDesign);
updateParameter(SqueezerPluginParameters::selDetector);
updateParameter(SqueezerPluginParameters::selGainStage);
updateParameter(SqueezerPluginParameters::selKneeWidth);
updateParameter(SqueezerPluginParameters::selAutoMakeupGain);
updateParameter(SqueezerPluginParameters::selSidechainInput);
updateParameter(SqueezerPluginParameters::selSidechainListen);
// locate directory containing the skins
SkinDirectory_ = SqueezerPluginParameters::getSkinDirectory();
// apply skin to plug-in editor
CurrentSkinName_ = PluginProcessor_->getParameterSkinName();
loadSkin_();
}
CtrlrLuaMethodEditorTabs::~CtrlrLuaMethodEditorTabs()
{
setLookAndFeel (nullptr);
deleteAndZero (lf);
}