Upload Source/Plugin/PluginBridgeEditor.mm

Source/Plugin/PluginBridgeEditor.mm

@@ -0,0 +1,387 @@
+#include "PluginBridgeEditor.h"
+
+#if JUCE_MAC
+#import <Cocoa/Cocoa.h>
+#import <QuartzCore/QuartzCore.h>
+#endif
+
+#include "json.hpp"
+using json = nlohmann::json;
+
+static const juce::Colour kBgDark       (0xff0d0d1a);
+static const juce::Colour kBgPanel      (0xff1a1a2e);
+static const juce::Colour kAccent       (0xff6c63ff);
+static const juce::Colour kTextPrimary  (0xffe8e8f0);
+static const juce::Colour kTextSecondary(0xff8888aa);
+static const juce::Colour kGreen        (0xff4cef50);
+static const juce::Colour kRed          (0xffef5350);
+
+PluginBridgeEditor::PluginBridgeEditor(PluginBridgeProcessor& p)
+    : AudioProcessorEditor(&p), processorRef(p)
+{
+    setSize(kDefaultWidth, kDefaultHeight);
+    setResizable(true, true);
+
+    titleLabel.setText("PluginBridge", juce::dontSendNotification);
+    titleLabel.setFont(juce::FontOptions(13.0f));
+    titleLabel.setJustificationType(juce::Justification::centredLeft);
+    titleLabel.setColour(juce::Label::textColourId, kTextPrimary);
+    addAndMakeVisible(titleLabel);
+
+    mcpStatusLabel.setFont(juce::FontOptions(10.0f));
+    mcpStatusLabel.setJustificationType(juce::Justification::centredRight);
+    addAndMakeVisible(mcpStatusLabel);
+
+    pluginStatusLabel.setFont(juce::FontOptions(10.0f));
+    pluginStatusLabel.setJustificationType(juce::Justification::centredLeft);
+    pluginStatusLabel.setColour(juce::Label::textColourId, kTextSecondary);
+    addAndMakeVisible(pluginStatusLabel);
+
+    selectButton.onClick = [this]() { showPluginMenu(); };
+    selectButton.setColour(juce::TextButton::buttonColourId, kAccent);
+    selectButton.setColour(juce::TextButton::textColourOffId, kTextPrimary);
+    addAndMakeVisible(selectButton);
+
+    // Callbacks
+    processorRef.onPluginLoaded = [this]()
+    {
+        juce::MessageManager::callAsync([this]()
+        {
+            showingError = false;
+            // Request GUI display
+            processorRef.showPluginGui();
+        });
+    };
+
+    processorRef.onPluginUnloaded = [this]()
+    {
+        juce::MessageManager::callAsync([this]()
+        {
+            disconnectRemoteLayer();
+            setSize(kDefaultWidth, kDefaultHeight);
+        });
+    };
+
+    processorRef.onGuiReady = [this]()
+    {
+        juce::MessageManager::callAsync([this]() { connectRemoteLayer(); });
+    };
+
+    processorRef.onGuiResized = [this](int w, int h)
+    {
+        juce::MessageManager::callAsync([this, w, h]()
+        {
+            setSize(std::max(w, kDefaultWidth), h + kTopBarHeight);
+        });
+    };
+
+    processorRef.onLoadFailed = [this](const juce::String& error)
+    {
+        juce::MessageManager::callAsync([this, error]()
+        {
+            pluginStatusLabel.setText(error, juce::dontSendNotification);
+            pluginStatusLabel.setColour(juce::Label::textColourId, kRed);
+            showingError = true;
+        });
+    };
+
+    // If already loaded (restoring state)
+    if (processorRef.isPluginLoaded() && processorRef.getRemoteLayerPortName().isNotEmpty())
+        connectRemoteLayer();
+
+    startTimerHz(4);
+}
+
+PluginBridgeEditor::~PluginBridgeEditor()
+{
+    stopTimer();
+    processorRef.onPluginLoaded = nullptr;
+    processorRef.onPluginUnloaded = nullptr;
+    processorRef.onGuiReady = nullptr;
+    processorRef.onGuiResized = nullptr;
+    processorRef.onLoadFailed = nullptr;
+    disconnectRemoteLayer();
+}
+
+void PluginBridgeEditor::paint(juce::Graphics& g)
+{
+    g.fillAll(kBgDark);
+
+    auto topBar = getLocalBounds().removeFromTop(kTopBarHeight);
+    g.setColour(kBgPanel);
+    g.fillRect(topBar);
+
+    g.setColour(kAccent.withAlpha(0.3f));
+    g.drawHorizontalLine(kTopBarHeight - 1, 0.0f, (float)getWidth());
+
+    // If no remote layer connected, show message in the body area
+    if (!layerConnected && !processorRef.isPluginLoaded())
+    {
+        g.setColour(kTextSecondary);
+        g.setFont(juce::FontOptions(12.0f));
+        auto body = getLocalBounds().withTrimmedTop(kTopBarHeight);
+        if (body.getHeight() > 20)
+            g.drawText("Select a plugin to load", body, juce::Justification::centred);
+    }
+}
+
+void PluginBridgeEditor::resized()
+{
+    auto area = getLocalBounds();
+    auto topBar = area.removeFromTop(kTopBarHeight).reduced(4, 2);
+
+    titleLabel.setBounds(topBar.removeFromLeft(80));
+    selectButton.setBounds(topBar.removeFromLeft(100).reduced(0, 2));
+    topBar.removeFromLeft(4);
+    pluginStatusLabel.setBounds(topBar.removeFromLeft(topBar.getWidth() - 60));
+    mcpStatusLabel.setBounds(topBar);
+
+#if JUCE_MAC
+    // Resize the remote CALayer to fill the area below the top bar
+    if (layerConnected && remoteLayerClient)
+    {
+        CARemoteLayerClient* client = (__bridge CARemoteLayerClient*)remoteLayerClient;
+        if (client.layer)
+        {
+            auto body = getLocalBounds().withTrimmedTop(kTopBarHeight);
+            client.layer.frame = CGRectMake(0, 0, body.getWidth(), body.getHeight());
+        }
+    }
+#endif
+}
+
+void PluginBridgeEditor::timerCallback()
+{
+    if (processorRef.isMcpServerRunning())
+    {
+        mcpStatusLabel.setText("MCP:" + juce::String(processorRef.getMcpServerPort()), juce::dontSendNotification);
+        mcpStatusLabel.setColour(juce::Label::textColourId, kGreen);
+    }
+    else
+    {
+        mcpStatusLabel.setText("MCP:off", juce::dontSendNotification);
+        mcpStatusLabel.setColour(juce::Label::textColourId, kRed);
+    }
+
+    if (processorRef.isPluginLoaded())
+    {
+        selectButton.setButtonText(processorRef.getLoadedPluginName());
+        if (!showingError)
+        {
+            pluginStatusLabel.setText(juce::String(processorRef.getLoadedPluginParamCount()) + " params", juce::dontSendNotification);
+            pluginStatusLabel.setColour(juce::Label::textColourId, kGreen);
+        }
+    }
+    else if (!showingError)
+    {
+        selectButton.setButtonText("Select Plugin");
+        pluginStatusLabel.setText("", juce::dontSendNotification);
+    }
+
+    // Check for crash
+    if (processorRef.getConnectionState() == HelperConnection::State::Crashed)
+    {
+        disconnectRemoteLayer();
+        pluginStatusLabel.setText("Plugin crashed — select again to retry", juce::dontSendNotification);
+        pluginStatusLabel.setColour(juce::Label::textColourId, kRed);
+        showingError = true;
+    }
+}
+
+// --- Remote Layer Connection ---
+
+void PluginBridgeEditor::connectRemoteLayer()
+{
+#if JUCE_MAC
+    disconnectRemoteLayer();
+
+    auto portName = processorRef.getRemoteLayerPortName();
+    if (portName.isEmpty()) return;
+
+    int guiW = processorRef.getRemoteGuiWidth();
+    int guiH = processorRef.getRemoteGuiHeight();
+    if (guiW <= 0 || guiH <= 0) return;
+
+    // Look up the Mach port from the bootstrap server
+    NSString* nsPortName = [NSString stringWithUTF8String:portName.toRawUTF8()];
+    NSMachPort* machPort = (NSMachPort*)[[NSMachBootstrapServer sharedInstance]
+        portForName:nsPortName];
+
+    if (!machPort)
+    {
+        DBG("PluginBridgeEditor: Failed to look up Mach port: " + portName);
+        return;
+    }
+
+    mach_port_t port = [machPort machPort];
+
+    // Create remote layer client
+    CARemoteLayerClient* client = [[CARemoteLayerClient alloc] initWithServerPort:port];
+    if (!client)
+    {
+        DBG("PluginBridgeEditor: Failed to create CARemoteLayerClient");
+        return;
+    }
+
+    remoteLayerClient = (__bridge_retained void*)client;
+
+    // Get our NSView and make it layer-backed
+    if (auto* peer = getPeer())
+    {
+        NSView* nsView = (NSView*)peer->getNativeHandle();
+        [nsView setWantsLayer:YES];
+
+        // Add remote layer as sublayer, positioned below the top bar
+        CALayer* remoteLayer = client.layer;
+        if (remoteLayer)
+        {
+            remoteLayer.frame = CGRectMake(0, 0, guiW, guiH);
+            // Position at the bottom of the view (below top bar)
+            // NSView coordinates are flipped (0,0 = bottom-left)
+            [nsView.layer addSublayer:remoteLayer];
+        }
+    }
+
+    layerConnected = true;
+
+    // Resize editor to fit plugin GUI + top bar
+    setSize(std::max(guiW, kDefaultWidth), guiH + kTopBarHeight);
+
+    DBG("PluginBridgeEditor: Remote layer connected (" + juce::String(guiW) + "x" + juce::String(guiH) + ")");
+#endif
+}
+
+void PluginBridgeEditor::disconnectRemoteLayer()
+{
+#if JUCE_MAC
+    if (remoteLayerClient)
+    {
+        CARemoteLayerClient* client = (__bridge_transfer CARemoteLayerClient*)remoteLayerClient;
+        if (client.layer)
+            [client.layer removeFromSuperlayer];
+        remoteLayerClient = nullptr;
+    }
+    layerConnected = false;
+#endif
+}
+
+// --- Mouse Event Forwarding ---
+
+void PluginBridgeEditor::sendMouseEvent(const juce::String& type, float x, float y, int button)
+{
+    // Adjust Y for top bar offset
+    float adjustedY = y - kTopBarHeight;
+    if (adjustedY < 0) return; // Click is in top bar, not plugin area
+
+    json cmd = {{"cmd", "mouse"}, {"type", type.toStdString()},
+                {"x", x}, {"y", adjustedY}, {"button", button}};
+    processorRef.getHelperConnection().sendCommand(cmd.dump());
+}
+
+void PluginBridgeEditor::mouseDown(const juce::MouseEvent& e)
+{
+    if (e.y >= kTopBarHeight && layerConnected)
+        sendMouseEvent("down", (float)e.x, (float)e.y, e.mods.isLeftButtonDown() ? 0 : 1);
+    else
+        juce::AudioProcessorEditor::mouseDown(e);
+}
+
+void PluginBridgeEditor::mouseUp(const juce::MouseEvent& e)
+{
+    if (e.y >= kTopBarHeight && layerConnected)
+        sendMouseEvent("up", (float)e.x, (float)e.y, 0);
+    else
+        juce::AudioProcessorEditor::mouseUp(e);
+}
+
+void PluginBridgeEditor::mouseMove(const juce::MouseEvent& e)
+{
+    if (e.y >= kTopBarHeight && layerConnected)
+        sendMouseEvent("move", (float)e.x, (float)e.y);
+    else
+        juce::AudioProcessorEditor::mouseMove(e);
+}
+
+void PluginBridgeEditor::mouseDrag(const juce::MouseEvent& e)
+{
+    if (e.y >= kTopBarHeight && layerConnected)
+        sendMouseEvent("drag", (float)e.x, (float)e.y, 0);
+    else
+        juce::AudioProcessorEditor::mouseDrag(e);
+}
+
+void PluginBridgeEditor::mouseWheelMove(const juce::MouseEvent& e, const juce::MouseWheelDetails& w)
+{
+    if (e.y >= kTopBarHeight && layerConnected)
+    {
+        json cmd = {{"cmd", "mouse"}, {"type", "scroll"},
+                    {"x", (float)e.x}, {"y", (float)(e.y - kTopBarHeight)},
+                    {"dx", w.deltaX}, {"dy", w.deltaY}};
+        processorRef.getHelperConnection().sendCommand(cmd.dump());
+    }
+    else
+    {
+        juce::AudioProcessorEditor::mouseWheelMove(e, w);
+    }
+}
+
+// --- Plugin Menu ---
+
+void PluginBridgeEditor::showPluginMenu()
+{
+    auto files = processorRef.getInstalledPluginFiles();
+
+    juce::PopupMenu menu;
+
+    if (files.isEmpty())
+    {
+        menu.addItem(-1, "(No plugins found)", false);
+        menu.showMenuAsync(juce::PopupMenu::Options().withTargetComponent(&selectButton), [](int) {});
+        return;
+    }
+
+    juce::PopupMenu vst3Menu;
+    juce::PopupMenu auMenu;
+    int itemId = 1;
+
+    for (int i = 0; i < files.size(); ++i)
+    {
+        const auto& file = files[i];
+        auto name = file.getFileNameWithoutExtension();
+        auto path = file.getFullPathName();
+        bool blocked = processorRef.isBlocked(path);
+
+        if (file.getFileExtension() == ".vst3")
+            vst3Menu.addItem(itemId, blocked ? name + " (not compatible)" : name, !blocked);
+        else
+            auMenu.addItem(itemId, blocked ? name + " (not compatible)" : name, !blocked);
+
+        itemId++;
+    }
+
+    if (vst3Menu.getNumItems() > 0)
+        menu.addSubMenu("VST3", vst3Menu);
+    if (auMenu.getNumItems() > 0)
+        menu.addSubMenu("Audio Units", auMenu);
+
+    menu.addSeparator();
+    menu.addItem(9999, "Clear blocklist");
+
+    menu.showMenuAsync(juce::PopupMenu::Options().withTargetComponent(&selectButton),
+        [this, files](int result)
+        {
+            if (result == 9999)
+            {
+                processorRef.getBlocklist().clear();
+                return;
+            }
+
+            if (result > 0 && result <= files.size())
+            {
+                showingError = false;
+                pluginStatusLabel.setText("Loading...", juce::dontSendNotification);
+                pluginStatusLabel.setColour(juce::Label::textColourId, kTextSecondary);
+                processorRef.loadPlugin(files[result - 1].getFullPathName());
+            }
+        });
+}