// Super Timecode Converter

// Copyright (c) 2026 Fiverecords -- MIT License

// https://github.com/fiverecords/SuperTimecodeConverter

#include "MainComponent.h"

#include "WaveformCache.h"

using SrcType = TimecodeEngine::InputSource;

//==============================================================================

// Remove " *" or " [Engine N]" markers from combo item text to get the

// underlying device name. Used when saving device names to settings.

//==============================================================================

static juce::String stripComboMarker(const juce::String& text)

{

static const juce::String dotChar = juce::String::charToString(0x25CF);

static const juce::String dotWithSpace = juce::String(" ") + dotChar;

auto s = text;

if (s.endsWith(dotWithSpace))

s = s.dropLastCharacters(dotWithSpace.length());

else if (s.endsWith(dotChar))

s = s.dropLastCharacters(dotChar.length());

int bracket = s.lastIndexOf(" [");

if (bracket >= 0 && s.endsWith("]"))

s = s.substring(0, bracket);

return s.trimEnd();

}

//==============================================================================

// BACKGROUND AUDIO DEVICE SCANNER

//==============================================================================

MainComponent::AudioScanThread::AudioScanThread(MainComponent* owner)

: juce::Thread("AudioScanThread"), safeOwner(owner) {}

void MainComponent::AudioScanThread::run()

{

juce::Array<AudioDeviceEntry> inputs, outputs;

if (!tempManager)

return;

for (auto* type : tempManager->getAvailableDeviceTypes())

{

if (threadShouldExit()) return;

auto typeName = type->getTypeName();

type->scanForDevices();

for (auto& name : type->getDeviceNames(true))

inputs.add({ typeName, name, AudioDeviceEntry::makeDisplayName(typeName, name) });

for (auto& name : type->getDeviceNames(false))

outputs.add({ typeName, name, AudioDeviceEntry::makeDisplayName(typeName, name) });

}

juce::MessageManager::callAsync([safeOwner = this->safeOwner, inputs, outputs]()

{

if (auto* comp = safeOwner.getComponent())

comp->onAudioScanComplete(inputs, outputs);

});

}

//==============================================================================

// SAMPLE RATE / BUFFER SIZE helpers (same as v1.3)

//==============================================================================

static int sampleRateToComboId(double sr)

{

if (sr <= 0) return 1;

if (std::abs(sr - 44100) < 1) return 2;

if (std::abs(sr - 48000) < 1) return 3;

if (std::abs(sr - 88200) < 1) return 4;

if (std::abs(sr - 96000) < 1) return 5;

return 1;

}

static int bufferSizeToComboId(int bs)

{

if (bs <= 0) return 1;

if (bs <= 32) return 2;

if (bs <= 64) return 3;

if (bs <= 128) return 4;

if (bs <= 256) return 5;

if (bs <= 512) return 6;

if (bs <= 1024) return 7;

return 8;

}

//==============================================================================

// CONSTRUCTOR / DESTRUCTOR

//==============================================================================

MainComponent::MainComponent()

{

setLookAndFeel(&customLookAndFeel);

// --- Create initial engine BEFORE setSize, because setSize triggers

// resized() which calls currentEngine() ---

engines.push_back(std::make_unique<TimecodeEngine>(0));

engines[0]->setSharedProDJLinkInput(&sharedProDJLinkInput);

engines[0]->setSharedStageLinQInput(&sharedStageLinQInput);

sharedStageLinQInput.onMetadataRequest = [this](const juce::String& path)

{

sharedStageLinQDb.requestMetadata(path);

};

sharedStageLinQInput.onFileTransferAvailable = [this](const juce::String& ip, uint16_t port, const uint8_t* token)

{

sharedStageLinQDb.start(ip, port, token);

};

sharedProDJLinkInput.onPlayerLost = [this](const juce::String& playerIP)

{

sharedDbClient.invalidatePlayer(playerIP);

};

engines[0]->setDbServerClient(&sharedDbClient);

engines[0]->setTrackMap(&settings.trackMap);

engines[0]->setMixerMap(&sharedMixerMap);

engines[0]->setSlqMixerMap(&sharedSlqMixerMap);

setSize(900, 700);

setWantsKeyboardFocus(true); // enable Ctrl+D diagnostic shortcut

// --- Tab bar ---

addAndMakeVisible(btnAddEngine);

btnAddEngine.setColour(juce::TextButton::buttonColourId, juce::Colour(0xFF1A1D23));

btnAddEngine.setColour(juce::TextButton::textColourOffId, accentBlue);

btnAddEngine.onClick = [this] { if (!isShowLocked()) addEngine(); };

rebuildTabButtons();

// --- Left panel scrollable viewport ---

addAndMakeVisible(leftViewport);

leftViewport.setViewedComponent(&leftContent, false);

leftViewport.setScrollBarsShown(true, false);

// --- Right panel scrollable viewport ---

addAndMakeVisible(rightViewport);

rightViewport.setViewedComponent(&rightContent, false);

rightViewport.setScrollBarsShown(true, false);

// --- Input buttons ---

for (auto* btn : { &btnMtcIn, &btnArtnetIn, &btnSysTime, &btnLtcIn, &btnProDJLinkIn, &btnStageLinQIn })

{ leftContent.addAndMakeVisible(btn); btn->setClickingTogglesState(false); }

// HippoNet input hidden pending hardware validation (code preserved in HippotizerInput.h)

btnHippoIn.setVisible(false);

btnMtcIn.onClick = [this] {

if (syncing || isShowLocked()) return;

auto& eng = currentEngine();

if (eng.getActiveInput() == SrcType::MTC) { inputConfigExpanded = !inputConfigExpanded; updateDeviceSelectorVisibility(); resized(); }

else { inputConfigExpanded = true; eng.setInputSource(SrcType::MTC); startCurrentMtcInput(); updateInputButtonStates(); updateDeviceSelectorVisibility(); resized(); saveSettings(); }

};

btnArtnetIn.onClick = [this] {

if (syncing || isShowLocked()) return;

auto& eng = currentEngine();

if (eng.getActiveInput() == SrcType::ArtNet) { inputConfigExpanded = !inputConfigExpanded; updateDeviceSelectorVisibility(); resized(); }

else { inputConfigExpanded = true; eng.setInputSource(SrcType::ArtNet); startCurrentArtnetInput(); updateInputButtonStates(); updateDeviceSelectorVisibility(); resized(); saveSettings(); }

};

btnSysTime.onClick = [this] {

if (syncing || isShowLocked()) return;

auto& eng = currentEngine();

if (eng.getActiveInput() == SrcType::SystemTime) { inputConfigExpanded = !inputConfigExpanded; updateDeviceSelectorVisibility(); resized(); }

else { inputConfigExpanded = true; eng.setInputSource(SrcType::SystemTime); updateInputButtonStates(); updateDeviceSelectorVisibility(); resized(); saveSettings(); }

};

btnLtcIn.onClick = [this] {

if (syncing || isShowLocked()) return;

auto& eng = currentEngine();

if (eng.getActiveInput() == SrcType::LTC) { inputConfigExpanded = !inputConfigExpanded; updateDeviceSelectorVisibility(); resized(); }

else { inputConfigExpanded = true; eng.setInputSource(SrcType::LTC); if (!scannedAudioInputs.isEmpty()) startCurrentLtcInput(); updateInputButtonStates(); updateDeviceSelectorVisibility(); resized(); saveSettings(); }

};

btnProDJLinkIn.onClick = [this] {

if (syncing || isShowLocked()) return;

auto& eng = currentEngine();

if (eng.getActiveInput() == SrcType::ProDJLink) { inputConfigExpanded = !inputConfigExpanded; updateDeviceSelectorVisibility(); resized(); }

else { inputConfigExpanded = true; eng.setInputSource(SrcType::ProDJLink); startCurrentProDJLinkInput(); updateInputButtonStates(); updateDeviceSelectorVisibility(); resized(); saveSettings(); }

};

btnStageLinQIn.onClick = [this] {

if (syncing || isShowLocked()) return;

auto& eng = currentEngine();

if (eng.getActiveInput() == SrcType::StageLinQ) { inputConfigExpanded = !inputConfigExpanded; updateDeviceSelectorVisibility(); resized(); }

else { inputConfigExpanded = true; eng.setInputSource(SrcType::StageLinQ); startCurrentStageLinQInput(); updateInputButtonStates(); updateDeviceSelectorVisibility(); resized(); saveSettings(); }

};

btnHippoIn.onClick = [this] {

if (syncing || isShowLocked()) return;

auto& eng = currentEngine();

if (eng.getActiveInput() == SrcType::Hippotizer) { inputConfigExpanded = !inputConfigExpanded; updateDeviceSelectorVisibility(); resized(); }

else { inputConfigExpanded = true; eng.setInputSource(SrcType::Hippotizer); startCurrentHippotizerInput(); updateInputButtonStates(); updateDeviceSelectorVisibility(); resized(); saveSettings(); }

};

// --- Output toggles ---

for (auto* btn : { &btnMtcOut, &btnArtnetOut, &btnLtcOut, &btnThruOut, &btnTcnetOut })

rightContent.addAndMakeVisible(btn);

styleOutputToggle(btnMtcOut, accentRed);

styleOutputToggle(btnArtnetOut, accentOrange);

styleOutputToggle(btnLtcOut, accentPurple);

styleOutputToggle(btnThruOut, accentCyan);

styleOutputToggle(btnTcnetOut, juce::Colour(0xFF00CC66));

// On-air gate lives in the ProDJLink input panel (it gates input activity,

// not a particular output). Use the small tick-style toggle like btnLink

// to match the look of the ProDJLink panel controls, not the big output

// toggles on the right side.

leftContent.addAndMakeVisible(btnOnAirGate);

btnOnAirGate.setColour(juce::ToggleButton::textColourId, textMid);

btnOnAirGate.setColour(juce::ToggleButton::tickColourId, juce::Colour(0xFFE040FB));

btnOnAirGate.onClick = [this]

{

if (syncing) return;

if (isShowLockedToggle(btnOnAirGate)) return;

currentEngine().setOnAirGateEnabled(btnOnAirGate.getToggleState());

saveSettings();

};

auto outputToggleHandler = [this]

{

if (syncing) return;

if (isShowLockedRevert()) return;

auto& eng = currentEngine();

eng.setOutputMtcEnabled(btnMtcOut.getToggleState());

eng.setOutputArtnetEnabled(btnArtnetOut.getToggleState());

eng.setOutputLtcEnabled(btnLtcOut.getToggleState());

eng.setOutputThruEnabled(btnThruOut.getToggleState());

eng.setOutputTcnetEnabled(btnTcnetOut.getToggleState());

// Auto-start/stop shared TCNet output based on any engine needing it

bool anyTcnet = false;

for (auto& e : engines)

if (e->isOutputTcnetEnabled()) { anyTcnet = true; break; }

if (anyTcnet && !sharedTcnetOutput.getIsRunning())

{

sharedTcnetOutput.refreshNetworkInterfaces();

sharedTcnetOutput.start(settings.tcnetInterface);

}

else if (!anyTcnet && sharedTcnetOutput.getIsRunning())

{

sharedTcnetOutput.stop();

}

updateCurrentOutputStates();

updateDeviceSelectorVisibility();

resized();

saveSettings();

};

btnMtcOut.onClick = btnArtnetOut.onClick = btnLtcOut.onClick = btnThruOut.onClick = btnTcnetOut.onClick = outputToggleHandler;

// --- Collapse toggle buttons for outputs ---

for (auto* btn : { &btnCollapseMtcOut, &btnCollapseArtnetOut, &btnCollapseLtcOut, &btnCollapseThruOut })

{

rightContent.addAndMakeVisible(btn);

styleCollapseButton(*btn);

}

auto makeCollapseHandler = [this](bool& expandedFlag, juce::TextButton& collapseBtn) {

return [this, &expandedFlag, &collapseBtn] {

expandedFlag = !expandedFlag;

updateCollapseButtonText(collapseBtn, expandedFlag);

updateDeviceSelectorVisibility();

resized();

};

};

btnCollapseMtcOut.onClick = makeCollapseHandler(mtcOutExpanded, btnCollapseMtcOut);

btnCollapseArtnetOut.onClick = makeCollapseHandler(artnetOutExpanded, btnCollapseArtnetOut);

btnCollapseLtcOut.onClick = makeCollapseHandler(ltcOutExpanded, btnCollapseLtcOut);

btnCollapseThruOut.onClick = makeCollapseHandler(thruOutExpanded, btnCollapseThruOut);

updateCollapseButtonText(btnCollapseMtcOut, mtcOutExpanded);

updateCollapseButtonText(btnCollapseArtnetOut, artnetOutExpanded);

updateCollapseButtonText(btnCollapseLtcOut, ltcOutExpanded);

updateCollapseButtonText(btnCollapseThruOut, thruOutExpanded);

// Input collapse button

leftContent.addAndMakeVisible(btnCollapseInput);

styleCollapseButton(btnCollapseInput);

btnCollapseInput.onClick = [this] {

inputConfigExpanded = !inputConfigExpanded;

updateCollapseButtonText(btnCollapseInput, inputConfigExpanded);

updateDeviceSelectorVisibility();

resized();

};

updateCollapseButtonText(btnCollapseInput, inputConfigExpanded);

// --- FPS buttons ---

for (auto* btn : { &btnFps2398, &btnFps24, &btnFps25, &btnFps2997, &btnFps30 })

{ addAndMakeVisible(btn); btn->setClickingTogglesState(false); }

btnFps2398.onClick = [this] {

if (syncing || isShowLocked()) return;

auto& eng = currentEngine();

if (eng.getActiveInput() == SrcType::LTC) eng.setUserOverrodeLtcFps(true);

eng.setFrameRate(FrameRate::FPS_2398); updateFpsButtonStates(); saveSettings();

};

btnFps24.onClick = [this] {

if (syncing || isShowLocked()) return;

currentEngine().setUserOverrodeLtcFps(false);

currentEngine().setFrameRate(FrameRate::FPS_24); updateFpsButtonStates(); saveSettings();

};

btnFps25.onClick = [this] {

if (syncing || isShowLocked()) return;

currentEngine().setUserOverrodeLtcFps(false);

currentEngine().setFrameRate(FrameRate::FPS_25); updateFpsButtonStates(); saveSettings();

};

btnFps2997.onClick = [this] {

if (syncing || isShowLocked()) return;

auto& eng = currentEngine();

if (eng.getActiveInput() == SrcType::LTC) eng.setUserOverrodeLtcFps(true);

eng.setFrameRate(FrameRate::FPS_2997); updateFpsButtonStates(); saveSettings();

};

btnFps30.onClick = [this] {

if (syncing || isShowLocked()) return;

currentEngine().setUserOverrodeLtcFps(false);

currentEngine().setFrameRate(FrameRate::FPS_30); updateFpsButtonStates(); saveSettings();

};

// --- FPS Conversion ---

addAndMakeVisible(btnFpsConvert);

styleOutputToggle(btnFpsConvert, accentGreen);

btnFpsConvert.onClick = [this]

{

if (syncing) return;

if (isShowLockedToggle(btnFpsConvert)) return;

auto& eng = currentEngine();

eng.setFpsConvertEnabled(btnFpsConvert.getToggleState());

updateOutputFpsButtonStates();

resized(); repaint();

saveSettings();

};

for (auto* btn : { &btnOutFps2398, &btnOutFps24, &btnOutFps25, &btnOutFps2997, &btnOutFps30 })

{ addAndMakeVisible(btn); btn->setClickingTogglesState(false); }

btnOutFps2398.onClick = [this] { if (!syncing && !isShowLocked()) { currentEngine().setOutputFrameRate(FrameRate::FPS_2398); updateOutputFpsButtonStates(); saveSettings(); } };

btnOutFps24.onClick = [this] { if (!syncing && !isShowLocked()) { currentEngine().setOutputFrameRate(FrameRate::FPS_24); updateOutputFpsButtonStates(); saveSettings(); } };

btnOutFps25.onClick = [this] { if (!syncing && !isShowLocked()) { currentEngine().setOutputFrameRate(FrameRate::FPS_25); updateOutputFpsButtonStates(); saveSettings(); } };

btnOutFps2997.onClick = [this] { if (!syncing && !isShowLocked()) { currentEngine().setOutputFrameRate(FrameRate::FPS_2997); updateOutputFpsButtonStates(); saveSettings(); } };

btnOutFps30.onClick = [this] { if (!syncing && !isShowLocked()) { currentEngine().setOutputFrameRate(FrameRate::FPS_30); updateOutputFpsButtonStates(); saveSettings(); } };

addAndMakeVisible(timecodeDisplay);

// =====================================================================

// LEFT PANEL -- INPUT SELECTORS

// =====================================================================

auto addLabelAndCombo = [this](juce::Label& lbl, juce::ComboBox& cmb, const juce::String& text)

{

leftContent.addAndMakeVisible(lbl); leftContent.addAndMakeVisible(cmb);

lbl.setText(text, juce::dontSendNotification);

styleLabel(lbl); styleComboBox(cmb);

};

auto addRightLabelAndCombo = [this](juce::Label& lbl, juce::ComboBox& cmb, const juce::String& text)

{

rightContent.addAndMakeVisible(lbl); rightContent.addAndMakeVisible(cmb);

lbl.setText(text, juce::dontSendNotification);

styleLabel(lbl); styleComboBox(cmb);

};

addLabelAndCombo(lblAudioInputTypeFilter, cmbAudioInputTypeFilter, "AUDIO DRIVER:");

cmbAudioInputTypeFilter.onChange = [this]

{

if (syncing) return;

if (isShowLockedRevert()) return;

populateFilteredInputDeviceCombo();

if (currentEngine().getActiveInput() == SrcType::LTC)

startCurrentLtcInput();

saveSettings();

};

addLabelAndCombo(lblSampleRate, cmbSampleRate, "SAMPLE RATE / BUFFER:");

populateSampleRateCombo();

cmbSampleRate.onChange = [this] { if (!syncing && !isShowLockedRevert()) { restartAllAudioDevices(); saveSettings(); } };

addLabelAndCombo(lblBufferSize, cmbBufferSize, "BUFFER SIZE:");

populateBufferSizeCombo();

cmbBufferSize.onChange = [this] { if (!syncing && !isShowLockedRevert()) { restartAllAudioDevices(); saveSettings(); } };

addLabelAndCombo(lblMidiInputDevice, cmbMidiInputDevice, "MIDI INPUT DEVICE:");

cmbMidiInputDevice.onChange = [this]

{

if (syncing) return;

if (isShowLockedRevert()) return;

int sel = cmbMidiInputDevice.getSelectedId() - 1;

if (sel >= 0 && currentEngine().getActiveInput() == SrcType::MTC)

{

currentEngine().stopMtcInput();

currentEngine().getMtcInput().refreshDeviceList();

currentEngine().startMtcInput(sel);

populateMidiAndNetworkCombos(); // refresh markers (auto-restores selections)

saveSettings();

}

};

addLabelAndCombo(lblArtnetInputInterface, cmbArtnetInputInterface, "ART-NET INPUT DEVICE:");

cmbArtnetInputInterface.onChange = [this]

{

if (syncing) return;

if (isShowLockedRevert()) return;

if (currentEngine().getActiveInput() == SrcType::ArtNet)

{

int sel = cmbArtnetInputInterface.getSelectedId() - 1;

currentEngine().stopArtnetInput();

currentEngine().startArtnetInput(sel);

// If bind fell back, update combo to actual interface before repopulate

int actualId = currentEngine().getArtnetInput().getSelectedInterface() + 1;

cmbArtnetInputInterface.setSelectedId(actualId, juce::dontSendNotification);

populateMidiAndNetworkCombos(); // refresh markers (auto-restores all selections)

saveSettings();

}

};

addLabelAndCombo(lblHippoInputInterface, cmbHippoInputInterface, "HIPPONET INPUT DEVICE:");

cmbHippoInputInterface.onChange = [this]

{

if (syncing) return;

if (isShowLockedRevert()) return;

if (currentEngine().getActiveInput() == SrcType::Hippotizer)

{

int sel = cmbHippoInputInterface.getSelectedId() - 1;

currentEngine().stopHippotizerInput();

currentEngine().startHippotizerInput(sel);

int actualId = currentEngine().getHippotizerInput().getSelectedInterface() + 1;

cmbHippoInputInterface.setSelectedId(actualId, juce::dontSendNotification);

populateMidiAndNetworkCombos();

saveSettings();

}

};

addLabelAndCombo(lblHippoTcChannel, cmbHippoTcChannel, "HIPPONET TC CHANNEL:");

cmbHippoTcChannel.addItem("TC 1", 1);

cmbHippoTcChannel.addItem("TC 2", 2);

cmbHippoTcChannel.setSelectedId(1, juce::dontSendNotification);

cmbHippoTcChannel.onChange = [this]

{

if (syncing) return;

int sel = cmbHippoTcChannel.getSelectedId() - 1; // 0-based

currentEngine().getHippotizerInput().setSelectedTcIndex(sel);

saveSettings();

};

// --- Generator controls (play/pause/stop + start/stop TC) ---

{

leftContent.addAndMakeVisible(btnGenClock);

btnGenClock.setVisible(false);

btnGenClock.setColour(juce::ToggleButton::textColourId, juce::Colour(0xFFAAAAAA));

btnGenClock.onClick = [this]

{

if (isShowLocked()) { btnGenClock.setToggleState(!btnGenClock.getToggleState(), juce::dontSendNotification); return; }

auto& eng = currentEngine();

eng.setGeneratorClockMode(btnGenClock.getToggleState());

updateDeviceSelectorVisibility();

resized();

saveSettings();

};

auto genBtnColor = juce::Colour(0xFF444444);

for (auto* btn : { &btnGenPlay, &btnGenPause, &btnGenStop })

{

leftContent.addAndMakeVisible(btn);

btn->setColour(juce::TextButton::buttonColourId, genBtnColor);

btn->setVisible(false);

}

btnGenPlay.onClick = [this] {

auto& eng = currentEngine();

eng.generatorPlay();

};

btnGenPause.onClick = [this] {

auto& eng = currentEngine();

eng.generatorPause();

};

btnGenStop.onClick = [this] {

auto& eng = currentEngine();

eng.generatorStop();

};

auto setupTcEditor = [&](juce::TextEditor& ed, juce::Label& lbl,

const juce::String& labelText)

{

leftContent.addAndMakeVisible(ed);

ed.setFont(juce::Font(juce::FontOptions(11.0f)));

ed.setColour(juce::TextEditor::backgroundColourId, juce::Colour(0xFF222222));

ed.setColour(juce::TextEditor::textColourId, juce::Colours::white);

ed.setJustification(juce::Justification::centred);

ed.setVisible(false);

ed.setText("00:00:00:00", juce::dontSendNotification);

leftContent.addAndMakeVisible(lbl);

styleLabel(lbl, 8.0f);

lbl.setText(labelText, juce::dontSendNotification);

lbl.setVisible(false);

};

setupTcEditor(txtGenStartTC, lblGenStartTC, "START TC:");

setupTcEditor(txtGenStopTC, lblGenStopTC, "STOP TC (0=FREE):");

// Callbacks use member pointers directly (no dangling reference)

auto applyStartTC = [this] {

if (isShowLocked()) return;

auto& eng = currentEngine();

eng.setGeneratorStartMs(parseTimecodeToMs(txtGenStartTC.getText(), eng.getCurrentFps()));

txtGenStartTC.setText(msToTimecodeString(eng.getGeneratorStartMs(), eng.getCurrentFps()), false);

saveSettings();

};

txtGenStartTC.onReturnKey = applyStartTC;

txtGenStartTC.onFocusLost = applyStartTC;

auto applyStopTC = [this] {

if (isShowLocked()) return;

auto& eng = currentEngine();

eng.setGeneratorStopMs(parseTimecodeToMs(txtGenStopTC.getText(), eng.getCurrentFps()));

txtGenStopTC.setText(msToTimecodeString(eng.getGeneratorStopMs(), eng.getCurrentFps()), false);

saveSettings();

};

txtGenStopTC.onReturnKey = applyStopTC;

txtGenStopTC.onFocusLost = applyStopTC;

// Preset selector

leftContent.addAndMakeVisible(lblGenPreset);

styleLabel(lblGenPreset, 8.0f);

lblGenPreset.setText("PRESET:", juce::dontSendNotification);

lblGenPreset.setVisible(false);

leftContent.addAndMakeVisible(cmbGenPreset);

cmbGenPreset.setVisible(false);

cmbGenPreset.setTextWhenNothingSelected("(select preset)");

cmbGenPreset.onChange = [this] {

int sel = cmbGenPreset.getSelectedId();

if (sel > 0)

loadGenPresetToFields(cmbGenPreset.getText());

};

leftContent.addAndMakeVisible(btnGenPrev);

btnGenPrev.setVisible(false);

btnGenPrev.setColour(juce::TextButton::buttonColourId, juce::Colour(0xFF444444));

btnGenPrev.onClick = [this] {

int sel = cmbGenPreset.getSelectedId();

int num = cmbGenPreset.getNumItems();

if (num == 0) return;

int newSel = (sel <= 1) ? num : sel - 1;

cmbGenPreset.setSelectedId(newSel, juce::sendNotificationSync);

};

leftContent.addAndMakeVisible(btnGenNext);

btnGenNext.setVisible(false);

btnGenNext.setColour(juce::TextButton::buttonColourId, juce::Colour(0xFF444444));

btnGenNext.onClick = [this] {

int sel = cmbGenPreset.getSelectedId();

int num = cmbGenPreset.getNumItems();

if (num == 0) return;

int newSel = (sel >= num) ? 1 : sel + 1;

cmbGenPreset.setSelectedId(newSel, juce::sendNotificationSync);

};

leftContent.addAndMakeVisible(btnGenGo);

btnGenGo.setVisible(false);

btnGenGo.setColour(juce::TextButton::buttonColourId, juce::Colour(0xFF22AA44));

btnGenGo.onClick = [this] {

int sel = cmbGenPreset.getSelectedId();

if (sel > 0)

activateGenPreset(cmbGenPreset.getText());

};

leftContent.addAndMakeVisible(btnGenPresetEdit);

btnGenPresetEdit.setVisible(false);

btnGenPresetEdit.setColour(juce::TextButton::buttonColourId, juce::Colour(0xFF444444));

btnGenPresetEdit.onClick = [this] {

if (isShowLocked()) return;

openGeneratorPresetEditor();

};

}

// --- OSC Input (generator remote control) ---

leftContent.addAndMakeVisible(btnOscIn);

styleOutputToggle(btnOscIn, juce::Colour(0xFF8888CC));

btnOscIn.setVisible(false);

btnOscIn.onClick = [this]

{

if (isShowLocked()) { btnOscIn.setToggleState(!btnOscIn.getToggleState(), juce::dontSendNotification); return; }

if (btnOscIn.getToggleState())

startOscInput();

else

stopOscInput();

updateDeviceSelectorVisibility();

resized();

saveSettings();

};

addLabelAndCombo(lblOscInputInterface, cmbOscInputInterface, "OSC NETWORK DEVICE:");

cmbOscInputInterface.onChange = [this]

{

if (isShowLocked()) return;

settings.oscInputInterface = cmbOscInputInterface.getSelectedId() - 1;

if (btnOscIn.getToggleState())

{

stopOscInput();

startOscInput();

}

saveSettings();

};

leftContent.addAndMakeVisible(lblOscInPort);

styleLabel(lblOscInPort, 8.0f);

lblOscInPort.setText("OSC PORT:", juce::dontSendNotification);

lblOscInPort.setVisible(false);

leftContent.addAndMakeVisible(txtOscInPort);

txtOscInPort.setFont(juce::Font(juce::FontOptions(11.0f)));

txtOscInPort.setColour(juce::TextEditor::backgroundColourId, juce::Colour(0xFF222222));

txtOscInPort.setColour(juce::TextEditor::textColourId, juce::Colours::white);

txtOscInPort.setJustification(juce::Justification::centred);

txtOscInPort.setText("9800", juce::dontSendNotification);

txtOscInPort.setVisible(false);

auto applyOscPort = [this]

{

if (isShowLocked()) return;

int port = juce::jlimit(1, 65535, txtOscInPort.getText().getIntValue());

txtOscInPort.setText(juce::String(port), false);

settings.oscInputPort = port;

if (btnOscIn.getToggleState())

{

stopOscInput();

startOscInput();

}

saveSettings();

};

txtOscInPort.onReturnKey = applyOscPort;

txtOscInPort.onFocusLost = applyOscPort;

leftContent.addAndMakeVisible(lblOscInStatus);

styleLabel(lblOscInStatus, 8.0f);

lblOscInStatus.setVisible(false);

setupOscInputServer();

// --- Pro DJ Link controls ---

addLabelAndCombo(lblProDJLinkInterface, cmbProDJLinkInterface, "PRO DJ LINK INTERFACE:");

cmbProDJLinkInterface.onChange = [this]

{

if (syncing) return;

if (isShowLockedRevert()) return;

if (currentEngine().getActiveInput() == SrcType::ProDJLink)

{

startCurrentProDJLinkInput();

populateMidiAndNetworkCombos();

saveSettings();

}

};

addLabelAndCombo(lblStageLinQInterface, cmbStageLinQInterface, "STAGELINQ INTERFACE:");

cmbStageLinQInterface.onChange = [this]

{

if (syncing) return;

if (isShowLockedRevert()) return;

if (currentEngine().getActiveInput() == SrcType::StageLinQ)

{

startCurrentStageLinQInput();

populateMidiAndNetworkCombos();

saveSettings();

}

};

addLabelAndCombo(lblProDJLinkPlayer, cmbProDJLinkPlayer, "PLAYER:");

for (int i = 1; i <= ProDJLink::kMaxPlayers; ++i)

cmbProDJLinkPlayer.addItem("PLAYER " + juce::String(i), i);

cmbProDJLinkPlayer.addItem("XF-A", 7);

cmbProDJLinkPlayer.addItem("XF-B", 8);

cmbProDJLinkPlayer.setSelectedId(1, juce::dontSendNotification);

cmbProDJLinkPlayer.onChange = [this]

{

if (syncing) return;

if (isShowLockedRevert()) return;

auto activeIn = currentEngine().getActiveInput();

if (activeIn == SrcType::ProDJLink || activeIn == SrcType::StageLinQ)

{

int player = cmbProDJLinkPlayer.getSelectedId();

if (player >= 1)

{

currentEngine().setProDJLinkPlayer(player);

// Reset UI display so stale data from previous player doesn't linger

displayedArtworkId = 0;

artworkDisplay.clearImage();

displayedWaveformTrackId = 0;

waveformDisplay.clearWaveform();

lblProDJLinkTrackInfo.setText("", juce::dontSendNotification);

lblProDJLinkMetadata.setText("", juce::dontSendNotification);

lblNextCue.setText("", juce::dontSendNotification);

}

saveSettings();

}

};

leftContent.addAndMakeVisible(lblProDJLinkMetadata);

styleLabel(lblProDJLinkMetadata, 9.0f);

lblProDJLinkMetadata.setVisible(false);

leftContent.addAndMakeVisible(lblNextCue);

lblNextCue.setFont(juce::Font(juce::FontOptions(10.0f)));

lblNextCue.setColour(juce::Label::textColourId, juce::Colour(0xFFFFAA00)); // amber

lblNextCue.setVisible(false);

leftContent.addAndMakeVisible(lblMixerStatus);

lblMixerStatus.setFont(juce::Font(juce::FontOptions(juce::Font::getDefaultMonospacedFontName(), 9.0f, juce::Font::plain)));

lblMixerStatus.setColour(juce::Label::textColourId, juce::Colour(0xFF888888));

lblMixerStatus.setVisible(false);

leftContent.addAndMakeVisible(artworkDisplay);

artworkDisplay.setVisible(false);

leftContent.addAndMakeVisible(waveformDisplay);

waveformDisplay.setVisible(false);

leftContent.addAndMakeVisible(lblProDJLinkTrackInfo);

styleLabel(lblProDJLinkTrackInfo, 8.0f);

lblProDJLinkTrackInfo.setVisible(false);

// --- ProDJLink features: TrackMap, MIDI Clock, OSC BPM, Ableton Link ---

auto pdlAccent = juce::Colour(0xFF00AAFF);

leftContent.addAndMakeVisible(btnTrackMap);

btnTrackMap.setVisible(false);

btnTrackMap.setColour(juce::ToggleButton::textColourId, textMid);

btnTrackMap.setColour(juce::ToggleButton::tickColourId, pdlAccent);

btnTrackMap.onClick = [this]

{

if (syncing) return;

if (isShowLockedToggle(btnTrackMap)) return;

bool enabled = btnTrackMap.getToggleState();

for (auto& eng : engines)

eng->setTrackMapEnabled(enabled);

updateDeviceSelectorVisibility();

saveSettings();

};

leftContent.addAndMakeVisible(btnTrackMapEdit);

btnTrackMapEdit.setVisible(false);

btnTrackMapEdit.setColour(juce::TextButton::buttonColourId, pdlAccent.withAlpha(0.15f));

btnTrackMapEdit.setColour(juce::TextButton::textColourOffId, pdlAccent.brighter(0.3f));

btnTrackMapEdit.onClick = [this] { if (!isShowLocked()) openTrackMapEditor(); };

leftContent.addAndMakeVisible(btnProDJLinkView);

btnProDJLinkView.setVisible(false);

btnProDJLinkView.setColour(juce::TextButton::buttonColourId, pdlAccent.withAlpha(0.15f));

btnProDJLinkView.setColour(juce::TextButton::textColourOffId, pdlAccent.brighter(0.3f));

btnProDJLinkView.onClick = [this] { openProDJLinkView(); };

auto slqAccent = juce::Colour(0xFF00CC66);

leftContent.addAndMakeVisible(btnStageLinQView);

btnStageLinQView.setVisible(false);

btnStageLinQView.setColour(juce::TextButton::buttonColourId, slqAccent.withAlpha(0.15f));

btnStageLinQView.setColour(juce::TextButton::textColourOffId, slqAccent.brighter(0.3f));

btnStageLinQView.onClick = [this] { openStageLinQView(); };

leftContent.addAndMakeVisible(btnMixerMapEdit);

btnMixerMapEdit.setVisible(false);

btnMixerMapEdit.setColour(juce::TextButton::buttonColourId, pdlAccent.withAlpha(0.15f));

btnMixerMapEdit.setColour(juce::TextButton::textColourOffId, pdlAccent.brighter(0.3f));

btnMixerMapEdit.onClick = [this] { openMixerMapEditor(); };

addAndMakeVisible(btnBackup);

btnBackup.setColour(juce::TextButton::buttonColourId, juce::Colour(0xFF1A1D23));

btnBackup.setColour(juce::TextButton::textColourOffId, juce::Colour(0xFF66CC66));

btnBackup.onClick = [this] { if (!isShowLocked()) exportConfig(); };

addAndMakeVisible(btnRestore);

btnRestore.setColour(juce::TextButton::buttonColourId, juce::Colour(0xFF1A1D23));

btnRestore.setColour(juce::TextButton::textColourOffId, juce::Colour(0xFFFF9966));

btnRestore.onClick = [this] { if (!isShowLocked()) importConfig(); };

// --- Show Lock button ---

addAndMakeVisible(btnShowLock);

auto updateShowLockVisuals = [this]()

{

if (settings.showModeLocked)

{

btnShowLock.setButtonText("LOCKED");

btnShowLock.setColour(juce::TextButton::buttonColourId, juce::Colour(0xFFCC2222));

btnShowLock.setColour(juce::TextButton::textColourOffId, juce::Colours::white);

}

else

{

btnShowLock.setButtonText("SHOW LOCK");

btnShowLock.setColour(juce::TextButton::buttonColourId, juce::Colour(0xFF1A1D23));

btnShowLock.setColour(juce::TextButton::textColourOffId, juce::Colour(0xFF888888));

}

};

updateShowLockVisuals();

btnShowLock.onClick = [this, updateShowLockVisuals]

{

if (settings.showModeLocked)

{

// Unlock: confirm dialog to prevent accidental unlock

auto options = juce::MessageBoxOptions()

.withIconType(juce::MessageBoxIconType::WarningIcon)

.withTitle("Unlock Show Mode?")

.withMessage("Show Lock is active. Unlocking allows changes to "

"input sources, devices, frame rates, and engine "

"configuration.\n\nUnlock now?")

.withButton("Unlock")

.withButton("Cancel");

juce::Component::SafePointer<MainComponent> safeThis(this);

juce::AlertWindow::showAsync(options, [safeThis, updateShowLockVisuals](int result)

{

if (safeThis == nullptr) return;

if (result == 1)

{

safeThis->settings.showModeLocked = false;

safeThis->showLockFlashCountdown = 0; // cancel pending flash

updateShowLockVisuals();

safeThis->saveSettings();

}

});

}

else

{

settings.showModeLocked = true;

// Close cue editor (config window -- shouldn't be open during show)

if (cuePointWindow != nullptr) { cuePointWindow.reset(); cuePointTrackKey.clear(); }

updateShowLockVisuals();

saveSettings();

}

};

leftContent.addAndMakeVisible(btnMidiClock);

btnMidiClock.setVisible(false);

btnMidiClock.setColour(juce::ToggleButton::textColourId, textMid);

btnMidiClock.setColour(juce::ToggleButton::tickColourId, pdlAccent);

btnMidiClock.onClick = [this]

{

if (syncing) return;

if (isShowLockedToggle(btnMidiClock)) return;

bool wantClock = btnMidiClock.getToggleState();

currentEngine().setMidiClockEnabled(wantClock); // set flag (clock may not start yet if device not open)

applyTriggerSettings(); // ensure MIDI device is opened/closed based on needs

if (wantClock)

currentEngine().setMidiClockEnabled(true); // re-try now that device is open

propagateGlobalSettings();

updateDeviceSelectorVisibility();

saveSettings();

};

leftContent.addAndMakeVisible(btnOscFwdBpm);

btnOscFwdBpm.setVisible(false);

btnOscFwdBpm.setColour(juce::ToggleButton::textColourId, textMid);

btnOscFwdBpm.setColour(juce::ToggleButton::tickColourId, pdlAccent);

btnOscFwdBpm.onClick = [this]

{

if (syncing) return;

if (isShowLockedToggle(btnOscFwdBpm)) return;

currentEngine().setOscForward(btnOscFwdBpm.getToggleState(), edOscFwdBpmAddr.getText(), edOscFwdBpmCmd.getText());

applyTriggerSettings(); // ensure OSC connection is opened/closed

propagateGlobalSettings();

updateDeviceSelectorVisibility();

saveSettings();

};

leftContent.addAndMakeVisible(lblOscFwdBpmAddr);

lblOscFwdBpmAddr.setText("Addr:", juce::dontSendNotification);

lblOscFwdBpmAddr.setFont(juce::Font(juce::FontOptions(10.0f)));

lblOscFwdBpmAddr.setColour(juce::Label::textColourId, textDim);

lblOscFwdBpmAddr.setVisible(false);

leftContent.addAndMakeVisible(edOscFwdBpmAddr);

edOscFwdBpmAddr.setVisible(false);

edOscFwdBpmAddr.setText("/composition/tempocontroller/tempo");

edOscFwdBpmAddr.setFont(juce::Font(juce::FontOptions(10.0f)));

edOscFwdBpmAddr.setColour(juce::TextEditor::backgroundColourId, juce::Colour(0xFF2A2A2A));

edOscFwdBpmAddr.setColour(juce::TextEditor::textColourId, textLight);

edOscFwdBpmAddr.setColour(juce::TextEditor::outlineColourId, juce::Colour(0xFF444444));

auto applyOscBpmSettings = [this]

{

if (!syncing && !isShowLockedRevert())

{

currentEngine().setOscForward(btnOscFwdBpm.getToggleState(),

edOscFwdBpmAddr.getText(),

edOscFwdBpmCmd.getText());

propagateGlobalSettings();

saveSettings();

}

};

edOscFwdBpmAddr.onReturnKey = applyOscBpmSettings;

edOscFwdBpmAddr.onFocusLost = applyOscBpmSettings;

leftContent.addAndMakeVisible(lblOscFwdBpmCmd);

lblOscFwdBpmCmd.setVisible(false);

lblOscFwdBpmCmd.setText("CMD:", juce::dontSendNotification);

lblOscFwdBpmCmd.setFont(juce::Font(juce::FontOptions(9.0f)));

lblOscFwdBpmCmd.setColour(juce::Label::textColourId, textMid);

lblOscFwdBpmCmd.setJustificationType(juce::Justification::centredRight);

leftContent.addAndMakeVisible(edOscFwdBpmCmd);

edOscFwdBpmCmd.setVisible(false);

edOscFwdBpmCmd.setFont(juce::Font(juce::FontOptions(10.0f)));

edOscFwdBpmCmd.setColour(juce::TextEditor::backgroundColourId, juce::Colour(0xFF2A2A2A));

edOscFwdBpmCmd.setColour(juce::TextEditor::textColourId, textLight);

edOscFwdBpmCmd.setColour(juce::TextEditor::outlineColourId, juce::Colour(0xFF444444));

edOscFwdBpmCmd.setTextToShowWhenEmpty("float (empty=float, %BPM%=string)", juce::Colour(0xFF555555));

edOscFwdBpmCmd.onReturnKey = applyOscBpmSettings;

edOscFwdBpmCmd.onFocusLost = applyOscBpmSettings;

leftContent.addAndMakeVisible(btnOscMixerFwd);

btnOscMixerFwd.setVisible(false);

btnOscMixerFwd.setColour(juce::ToggleButton::textColourId, textMid);

btnOscMixerFwd.setColour(juce::ToggleButton::tickColourId, pdlAccent);

btnOscMixerFwd.onClick = [this]

{

if (syncing) return;

if (isShowLockedToggle(btnOscMixerFwd)) return;

currentEngine().setOscMixerForward(btnOscMixerFwd.getToggleState());

applyTriggerSettings();

propagateGlobalSettings();

saveSettings();

};

leftContent.addAndMakeVisible(btnMidiMixerFwd);

btnMidiMixerFwd.setVisible(false);

btnMidiMixerFwd.setColour(juce::ToggleButton::textColourId, textMid);

btnMidiMixerFwd.setColour(juce::ToggleButton::tickColourId, pdlAccent);

btnMidiMixerFwd.onClick = [this]

{

if (syncing) return;

if (isShowLockedToggle(btnMidiMixerFwd)) return;

currentEngine().setMidiMixerForward(btnMidiMixerFwd.getToggleState(),

cmbMidiMixCCCh.getSelectedId(),

cmbMidiMixNoteCh.getSelectedId());

applyTriggerSettings();

propagateGlobalSettings();

updateDeviceSelectorVisibility();

saveSettings();

};

auto setupMidiChCombo = [this](juce::ComboBox& cmb, juce::Label& lbl, const juce::String& labelText)

{

leftContent.addAndMakeVisible(lbl);

lbl.setVisible(false);

lbl.setText(labelText, juce::dontSendNotification);

lbl.setFont(juce::Font(juce::FontOptions(10.0f)));

lbl.setColour(juce::Label::textColourId, textDim);

leftContent.addAndMakeVisible(cmb);

cmb.setVisible(false);

for (int ch = 1; ch <= 16; ++ch)

cmb.addItem("Ch " + juce::String(ch), ch);

cmb.setSelectedId(1, juce::dontSendNotification);

styleComboBox(cmb);

cmb.onChange = [this]

{

if (syncing) return;

if (isShowLockedRevert()) return;

currentEngine().setMidiMixerForward(btnMidiMixerFwd.getToggleState(),

cmbMidiMixCCCh.getSelectedId(),

cmbMidiMixNoteCh.getSelectedId());

propagateGlobalSettings();

saveSettings();

};

};

setupMidiChCombo(cmbMidiMixCCCh, lblMidiMixCCCh, "CC CH:");

setupMidiChCombo(cmbMidiMixNoteCh, lblMidiMixNoteCh, "NOTE CH:");

leftContent.addAndMakeVisible(btnArtnetMixerFwd);

btnArtnetMixerFwd.setVisible(false);

btnArtnetMixerFwd.setColour(juce::ToggleButton::textColourId, textMid);

btnArtnetMixerFwd.setColour(juce::ToggleButton::tickColourId, pdlAccent);

btnArtnetMixerFwd.onClick = [this]

{

if (syncing) return;

if (isShowLockedToggle(btnArtnetMixerFwd)) return;

currentEngine().setArtnetMixerForward(btnArtnetMixerFwd.getToggleState(),

getArtNetAddressFromCombos(cmbArtMixNet, cmbArtMixSub, cmbArtMixUni));

// Ensure ArtNet output is running -- DMX uses the same socket.

// If ArtNet timecode out is already running, this is a no-op.

if (btnArtnetMixerFwd.getToggleState() && !currentEngine().getArtnetOutput().getIsRunning())

{

int iface = cmbArtnetDmxInterface.getSelectedId() - 2; // -1=All, 0+=NIC

currentEngine().startArtnetOutput(iface);

}

propagateGlobalSettings();

updateDeviceSelectorVisibility();

saveSettings();

};

setupArtNetAddressCombos(cmbArtMixNet, cmbArtMixSub, cmbArtMixUni, lblArtMixAddr,

"MIXER:", [this]

{

if (syncing) return;

if (isShowLockedRevert()) return;

currentEngine().setArtnetMixerForward(btnArtnetMixerFwd.getToggleState(),

getArtNetAddressFromCombos(cmbArtMixNet, cmbArtMixSub, cmbArtMixUni));

propagateGlobalSettings();

saveSettings();

});

leftContent.addAndMakeVisible(btnLink);

btnLink.setVisible(false);

btnLink.setColour(juce::ToggleButton::textColourId, textMid);

btnLink.setColour(juce::ToggleButton::tickColourId, pdlAccent);

btnLink.onClick = [this]

{

if (syncing) return;

if (isShowLockedToggle(btnLink)) return;

if (btnLink.getToggleState())

{

// Check if another engine already has Link active

int owner = findLinkOwnerOtherThan(selectedEngine);

if (owner >= 0)

{