/*

// Copyright (c) 2021-2025 Timothy Schoen

// For information on usage and redistribution, and for a DISCLAIMER OF ALL

// WARRANTIES, see the file, "LICENSE.txt," in this distribution.

*/

#include <juce_gui_basics/juce_gui_basics.h>

#include <juce_audio_processors/juce_audio_processors.h>

#include <juce_animation/juce_animation.h>

#include "Utility/Config.h"

#include "Utility/Fonts.h"

#include "Utility/OSUtils.h"

#include "PluginEditor.h"

#include "PluginProcessor.h"

#include "Pd/Patch.h"

#include "LookAndFeel.h"

#include "Sidebar/Palettes.h"

#include "Utility/Autosave.h"

#include "Utility/RateReducer.h"

#include "Utility/StackShadow.h"

#include "Canvas.h"

#include "Connection.h"

#include "Components/ConnectionMessageDisplay.h"

#include "Components/ObjectDragAndDrop.h"

#include "Dialogs/Dialogs.h"

#include "Statusbar.h"

#include "Toolbar.h"

#include "Components/WelcomePanel.h"

#include "Sidebar/Sidebar.h"

#include "Object.h"

#include "PluginMode.h"

#include "NVGSurface.h"

#include "Utility/NVGGraphicsContext.h"

#include "Sidebar/Console.h"

#include "Sidebar/Inspector.h"

#include "Sidebar/CommandInput.h"

#include "Sidebar/DocumentationBrowser.h"

#include "Sidebar/AutomationPanel.h"

#include "Sidebar/SearchPanel.h"

#include "Sidebar/Palettes.h"

#include "Sidebar/ReferencePanel.h"

#if ENABLE_TESTING

void runTests(PluginEditor* editor);

#endif

#include <juce_opengl/juce_opengl.h>

using namespace juce::gl;

#include <nanovg_async.h>

class CalloutArea final : public Component

, public Timer {

public:

explicit CalloutArea(Component* parent)

: target(parent)

, tooltipWindow(this)

{

setVisible(true);

setAlwaysOnTop(true);

setInterceptsMouseClicks(false, true);

startTimerHz(3);

}

~CalloutArea() override = default;

void timerCallback() override

{

#if JUCE_WINDOWS || JUCE_LINUX || JUCE_BSD

setBounds(target->getScreenBounds() / getApproximateScaleFactorForComponent(target));

#else

setBounds(target->getScreenBounds());

#endif

}

void paint(Graphics& g) override

{

if (!ProjectInfo::canUseSemiTransparentWindows()) {

g.fillAll(getThemeColours(*this).popupMenuBackgroundColour);

}

}

#if JUCE_WINDOWS || JUCE_LINUX || JUCE_BSD

float getDesktopScaleFactor() const override

{

return getApproximateScaleFactorForComponent(target) * Desktop::getInstance().getGlobalScaleFactor();

};

#endif

private:

WeakReference<Component> target;

TooltipWindow tooltipWindow;

};

PluginEditor::PluginEditor(PluginProcessor& p)

: AudioProcessorEditor(&p)

, pd(&p)

, statusbar(std::make_unique<Statusbar>(&p, this))

, nvgSurface(this)

, openedDialog(nullptr)

, pluginConstrainer(*getConstrainer())

, tooltipWindow([this] { return std::sqrt(std::abs(getTransform().getDeterminant())) * SettingsFile::getInstance()->getProperty<float>("global_scale"); }, [](Component const* c) {

if (auto const* cnv = c->findParentComponentOfClass<Canvas>()) {

return !getValue<bool>(cnv->locked);

}

return true; })

, tabComponent(this)

, pluginMode(nullptr)

, recentlyOpenedPanelSelector(Icons::Home, "Home")

, libraryPanelSelector(Icons::ItemGrid, "Library")

{

editorLookAndFeel.setTheme(SettingsFile::getInstance()->getTheme(p.currentThemeName));

setLookAndFeel(&editorLookAndFeel);

auto const& colours = getThemeColours(*this);

keyboardLayout = OSUtils::getKeyboardLayout();

setCachedComponentImage(new NVGSurface::InvalidationListener(nvgSurface, this));

#if !JUCE_IOS

// if we are inside a DAW / host set up the border resizer now

if (!ProjectInfo::isStandalone) {

// NEVER touch pluginConstrainer outside of plugin mode!

pluginConstrainer.setMinimumSize(890, 660);

setUseBorderResizer(true);

} else {

constrainer.setMinimumSize(890, 660);

}

#endif

mainMenuButton.setButtonText(Icons::Menu);

undoButton.setButtonText(Icons::Undo);

redoButton.setButtonText(Icons::Redo);

welcomePanelSearchButton.setButtonText(Icons::SearchFilled);

addKeyListener(commandManager.getKeyMappings());

welcomePanel = std::make_unique<WelcomePanel>(this);

addChildComponent(*welcomePanel);

welcomePanel->setAlwaysOnTop(true);

welcomePanelSearchButton.setClickingTogglesState(true);

welcomePanelSearchButton.onClick = [this] {

if (welcomePanelSearchButton.getToggleState()) {

welcomePanelSearchInput.setVisible(true);

welcomePanelSearchInput.grabKeyboardFocus();

welcomePanel->setSearchQuery("");

} else {

welcomePanelSearchInput.setVisible(false);

}

};

welcomePanelSearchInput.onTextChange = [this] {

welcomePanel->setSearchQuery(welcomePanelSearchInput.getText());

};

// Hide the search input bar if the text is empty and focus is lost

welcomePanelSearchInput.onFocusLost = [this] {

if (welcomePanelSearchButton.isMouseOver()) {

return;

}

if (welcomePanelSearchInput.getText().isEmpty()) {

welcomePanelSearchButton.setToggleState(false, dontSendNotification);

welcomePanelSearchInput.setVisible(false);

}

};

welcomePanelSearchInput.setTextToShowWhenEmpty("Type to search patches", colours.panelTextColour.withAlpha(0.5f));

welcomePanelSearchInput.setBorder({ 1, 3, 5, 1 });

welcomePanelSearchInput.setJustification(Justification::centredLeft);

welcomePanelSearchInput.setAlwaysOnTop(true);

addChildComponent(welcomePanelSearchInput);

setWantsKeyboardFocus(true);

commandManager.registerAllCommandsForTarget(this);

auto* settingsFile = SettingsFile::getInstance();

PlugDataLook::setDefaultFont(settingsFile->getProperty<String>("default_font"));

updateDefaultFont();

if (auto const elt = XmlDocument(settingsFile->getKeyMap()).getDocumentElement()) {

commandManager.getKeyMappings()->restoreFromXml(*elt);

}

autoconnect.referTo(settingsFile->getPropertyAsValue("autoconnect"));

addAndMakeVisible(tabComponent);

calloutArea = std::make_unique<CalloutArea>(this);

calloutArea->setVisible(true);

calloutArea->setAlwaysOnTop(true);

calloutArea->setInterceptsMouseClicks(true, true);

setOpaque(false);

// Show settings

mainMenuButton.setTooltip("Main menu");

mainMenuButton.onClick = [this] {

Dialogs::showMainMenu(this, &mainMenuButton);

};

addAndMakeVisible(mainMenuButton);

// Undo button

undoButton.isUndo = true;

undoButton.onClick = [this] { getCurrentCanvas()->undo(); };

addChildComponent(undoButton);

// Redo button

redoButton.isRedo = true;

redoButton.onClick = [this] { getCurrentCanvas()->redo(); };

addChildComponent(redoButton);

// New object button

addObjectMenuButton.setButtonText(Icons::AddObject);

addObjectMenuButton.setTooltip("Add object");

addObjectMenuButton.onClick = [this] { Dialogs::showObjectMenu(this, &addObjectMenuButton); };

addChildComponent(addObjectMenuButton);

sidebarToggleButton.setClickingTogglesState(true);

sidebarToggleButton.setButtonText(Icons::PanelRight);

sidebarToggleButton.setTooltip("Toggle sidebar");

sidebarToggleButton.onClick = [this] {

if (rightSidebar) {

rightSidebar->setVisible(sidebarToggleButton.getToggleState());

rightSidebar->showSidebar(true);

resized();

}

};

recentlyOpenedPanelSelector.setClickingTogglesState(true);

libraryPanelSelector.setClickingTogglesState(true);

recentlyOpenedPanelSelector.setRadioGroupId(hash("welcome_panel_selectors"));

libraryPanelSelector.setRadioGroupId(hash("welcome_panel_selectors"));

addChildComponent(recentlyOpenedPanelSelector);

addChildComponent(libraryPanelSelector);

recentlyOpenedPanelSelector.onClick = [this, settingsFile] {

settingsFile->setProperty("last_welcome_panel", var(0));

welcomePanel->setShownTab(WelcomePanel::Home);

};

libraryPanelSelector.onClick = [this, settingsFile] {

settingsFile->setProperty("last_welcome_panel", var(1));

welcomePanel->setShownTab(WelcomePanel::Library);

};

auto const lastWelcomePanel = settingsFile->getProperty<int>("last_welcome_panel");

recentlyOpenedPanelSelector.setToggleState(!lastWelcomePanel, sendNotification);

libraryPanelSelector.setToggleState(lastWelcomePanel, sendNotification);

consolePanel = std::make_unique<Console>(&p);

browserPanel = std::make_unique<DocumentationBrowser>(&p);

automationPanel = std::make_unique<AutomationPanel>(&p);

searchPanel = std::make_unique<SearchPanel>(this);

palettePanel = std::make_unique<Palettes>(this);

referencePanel = std::make_unique<ReferencePanel>(this);

inspectorPanel = std::make_unique<Inspector>();

commandInput = std::make_unique<CommandInput>(this);

auto makeSidebar = [&](Sidebar::Side s) {

return std::make_unique<Sidebar>(s, &p, this,

consolePanel.get(), browserPanel.get(), automationPanel.get(),

searchPanel.get(), palettePanel.get(), referencePanel.get(),

inspectorPanel.get(), commandInput.get());

};

leftSidebar = makeSidebar(Sidebar::Side::Left);

rightSidebar = makeSidebar(Sidebar::Side::Right);

addChildComponent(*leftSidebar);

addChildComponent(*rightSidebar);

auto* settings = SettingsFile::getInstance();

// Default: everything on the right (preserves existing behaviour).

auto loadAssignment = [&](Sidebar::SidePanel id, Sidebar::Side defaultSide) {

auto const key = "sidebar_panel_" + Sidebar::panelIdToString(id);

auto sideStr = settings->getProperty<String>(key);

auto side = Sidebar::sideFromString(sideStr, defaultSide);

(side == Sidebar::Side::Left ? leftSidebar : rightSidebar)->addPanel(id);

};

loadAssignment(Sidebar::ConsolePanel, Sidebar::Side::Right);

loadAssignment(Sidebar::DocPanel, Sidebar::Side::Right);

loadAssignment(Sidebar::ParamPanel, Sidebar::Side::Right);

loadAssignment(Sidebar::PatchSearchPanel, Sidebar::Side::Right);

loadAssignment(Sidebar::PalettePanel, Sidebar::Side::Right);

loadAssignment(Sidebar::ObjectReferencePanel, Sidebar::Side::Right);

loadAssignment(Sidebar::InspectorPanel, Sidebar::Side::Right);

int const leftW = settings->getProperty<int> ("left_sidebar_width");

int const rightW = settings->getProperty<int> ("right_sidebar_width");

leftSidebar->setSize(leftW > 0 ? leftW : 250, pd->lastUIHeight);

rightSidebar->setSize(rightW > 0 ? rightW : 250, pd->lastUIHeight);

// If a sidebar has no panels (everything moved to the other side), keep it hidden.

if (!leftSidebar->hasAnyPanel())

leftSidebar->setVisible(false);

if (!rightSidebar->hasAnyPanel())

rightSidebar->setVisible(false);

// Make sure existing console messages are processed

if (auto* s = getSidebarForPanel(Sidebar::ConsolePanel))

s->updateConsole(0, false);

updateCommandStatus();

addModifierKeyListener(this);

connectionMessageDisplay = std::make_unique<ConnectionMessageDisplay>(this);

ObjectThemeManager::get()->updateTheme(pd, colours);

addChildComponent(nvgSurface);

nvgSurface.toBehind(&tabComponent);

editorIndex = ProjectInfo::isStandalone ? numEditors++ : 0;

statusbar->setAlwaysOnTop(true);

addAndMakeVisible(statusbar.get());

audioToolbar = std::make_unique<AudioToolbar>(pd, this);

audioToolbar->setAlwaysOnTop(true);

addAndMakeVisible(audioToolbar.get());

#if JUCE_WINDOWS || JUCE_LINUX || JUCE_BSD

if (ProjectInfo::isStandalone) {

standaloneWindowMinimiseButton.reset(getLookAndFeel().createDocumentWindowButton(DocumentWindow::minimiseButton));

standaloneWindowMaximiseButton.reset(getLookAndFeel().createDocumentWindowButton(DocumentWindow::maximiseButton));

standaloneWindowCloseButton.reset(getLookAndFeel().createDocumentWindowButton(DocumentWindow::closeButton));

if (standaloneWindowMinimiseButton) {

standaloneWindowMinimiseButton->onClick = [this] {

if (auto* window = findParentComponentOfClass<PlugDataWindow>())

window->minimiseButtonPressed();

};

}

if (standaloneWindowMaximiseButton) {

standaloneWindowMaximiseButton->onClick = [this] {

if (auto* window = findParentComponentOfClass<PlugDataWindow>())

window->maximiseButtonPressed();

};

}

if (standaloneWindowCloseButton) {

standaloneWindowCloseButton->addShortcut(KeyPress(KeyPress::F4Key, ModifierKeys::altModifier, 0));

standaloneWindowCloseButton->onClick = [this] {

if (auto* window = findParentComponentOfClass<PlugDataWindow>())

window->closeButtonPressed();

};

}

for (auto* button : { standaloneWindowMinimiseButton.get(), standaloneWindowMaximiseButton.get(), standaloneWindowCloseButton.get() }) {

if (button) {

button->setAlwaysOnTop(true);

button->setWantsKeyboardFocus(false);

button->setVisible(false);

addChildComponent(button);

}

}

}

#endif

for (auto* button : SmallArray<MainToolbarButton*> {

&mainMenuButton,

&undoButton,

&redoButton,

&addObjectMenuButton,

&welcomePanelSearchButton,

&sidebarToggleButton }) {

addChildComponent(button);

}

setSize(pd->lastUIWidth, pd->lastUIHeight);

#if ENABLE_TESTING

// Call after window is ready

::Timer::callAfterDelay(200, [_this = SafePointer(this)]() {

if (_this)

runTests(_this.getComponent());

});

#endif

pd->messageDispatcher->setBlockMessages(false);

lookAndFeelChanged();

::Timer::callAfterDelay(100, [this, settingsFile] {

if (settingsFile->getSettingsState() != SettingsFile::SettingsState::UserSettings) {

String errorText = "Corrupt settings detected and fixed\n";

if (settingsFile->getSettingsState() == SettingsFile::SettingsState::DefaultSettings) {

errorText += "plugdata will use default settings.\n\n";

} else {

errorText += "plugdata will use last good settings.\n\n";

}

auto corruptedSettingsLocation = settingsFile->getCorruptBackupSettingsLocation();

errorText += " Previous settings backed up to:\n\n" + settingsFile->getCorruptBackupSettingsLocation();

Dialogs::showMultiChoiceDialog(&openedDialog, this, errorText, [corruptedSettingsLocation](int const result) {

if (result) {

File(corruptedSettingsLocation).revealToUser();

}

},

{ "Dismiss", "Reveal corrupted file" });

settingsFile->resetSettingsState();

}

});

#if JUCE_IOS

editorLookAndFeel.setMainComponent(this);

#else

// Show the onboarding dialog

// Skip this on iOS since most settings here are irrelevant to it

MessageManager::callAsync([_this = SafePointer(this)](){

if(_this && !_this->pd->findPatchInPluginMode(_this->editorIndex)) {

if (!SettingsFile::getInstance()->getProperty<bool>("onboarding_completed") || SystemStats::getEnvironmentVariable("PLUGDATA_ONBOARDING", {}).isNotEmpty())

Dialogs::showOnboardingDialog(&_this->openedDialog, _this.get());

}

});

#endif

addModifierKeyListener(&pd->keyHandler);

startTimerHz(90);

}

PluginEditor::~PluginEditor()

{

setCachedComponentImage(nullptr);

ObjectDragAndDrop::dismiss(this);

removeModifierKeyListener(&pd->keyHandler);

nvgSurface.detachContext();

if (auto* window = dynamic_cast<PlugDataWindow*>(getTopLevelComponent())) {

SettingsFile::getInstance()->setProperty("window_size", Array<var> { window->getWidth(), window->getHeight() });

SettingsFile::getInstance()->saveSettings();

ProjectInfo::closeWindow(window); // Make sure plugdatawindow gets cleaned up

}

if (!ProjectInfo::isStandalone) {

// Block incoming gui messages from pd if there is no active editor

pd->messageDispatcher->setBlockMessages(true);

}

stopTimer();

setLookAndFeel(nullptr);

}

void PluginEditor::setTheme(DynamicObject::Ptr themeTree)

{

editorLookAndFeel.setTheme(themeTree);

}

void PluginEditor::updateDefaultFont()

{

editorLookAndFeel.applyDefaultFont();

auto& activeLookAndFeel = ::getPlugDataLook(*this);

if (&activeLookAndFeel != &editorLookAndFeel)

activeLookAndFeel.applyDefaultFont();

}

void PluginEditor::setUseBorderResizer(bool const shouldUse)

{

if (shouldUse) {

if (ProjectInfo::isStandalone) {

if (!borderResizer) {

borderResizer = std::make_unique<MouseRateReducedComponent<ResizableBorderComponent>>(getTopLevelComponent(), &constrainer);

borderResizer->setAlwaysOnTop(true);

addAndMakeVisible(borderResizer.get());

}

borderResizer->setVisible(true);

resized(); // Makes sure resizer gets resized

if (isInPluginMode()) {

borderResizer->toBehind(pluginMode.get());

}

} else {

if (!cornerResizer) {

cornerResizer = std::make_unique<MouseRateReducedComponent<ResizableCornerComponent>>(this, &pluginConstrainer);

cornerResizer->setAlwaysOnTop(true);

}

addAndMakeVisible(cornerResizer.get());

}

} else {

if (ProjectInfo::isStandalone && borderResizer) {

borderResizer->setVisible(false);

}

}

}

void PluginEditor::updateStandaloneWindowControls()

{

#if JUCE_WINDOWS || JUCE_LINUX || JUCE_BSD

if (!ProjectInfo::isStandalone)

return;

auto const enabled = !SettingsFile::getInstance()->getProperty<bool>("native_window") && !pluginMode;

auto* window = dynamic_cast<PlugDataWindow*>(getTopLevelComponent());

for (auto* button : { standaloneWindowMinimiseButton.get(), standaloneWindowMaximiseButton.get(), standaloneWindowCloseButton.get() }) {

button->setVisible(enabled);

button->toFront(false);

}

if (standaloneWindowMaximiseButton && window)

standaloneWindowMaximiseButton->setToggleState(window->isMaximised(), dontSendNotification);

auto const titleBarArea = Rectangle<int>(0, 7, getWidth() - 6, 23);

getLookAndFeel().positionDocumentWindowButtons(*window, titleBarArea.getX(), titleBarArea.getY(), titleBarArea.getWidth(), titleBarArea.getHeight(), standaloneWindowMinimiseButton.get(), standaloneWindowMaximiseButton.get(), standaloneWindowCloseButton.get(), false);

#endif

}

void PluginEditor::paint(Graphics& g)

{

auto baseColour = getThemeColours(*this).toolbarBackgroundColour;

if (ProjectInfo::isStandalone && !isActiveWindow()) {

baseColour = baseColour.brighter(baseColour.getBrightness() / 2.5f);

}

#if JUCE_LINUX || JUCE_BSD

if (wantsRoundedCorners()) {

g.setColour(baseColour);

g.fillRoundedRectangle(getLocalBounds().toFloat(), Corners::windowCornerRadius);

} else {

g.fillAll(baseColour);

}

#else

g.fillAll(baseColour);

#endif

}

// Paint file drop outline

void PluginEditor::paintOverChildren(Graphics& g)

{

auto const& colours = getThemeColours(*this);

// Never want to be drawing over a dialog window

if (openedDialog || pluginMode)

return;

auto const welcomePanelVisible = !getCurrentCanvas();

auto const tabbarDepth = welcomePanelVisible ? toolbarHeight + 5.5f : toolbarHeight + 30.0f;

auto const leftSidebarCollapsed = leftSidebar && leftSidebar->isVisible() && leftSidebar->isHidden();

auto const rightSidebarCollapsed = rightSidebar && rightSidebar->isVisible() && rightSidebar->isHidden();

auto const drawToolbarOutlineAcrossDockedSidebars = leftSidebarCollapsed || rightSidebarCollapsed;

auto const sidebarLeft = drawToolbarOutlineAcrossDockedSidebars && rightSidebarCollapsed ? static_cast<float>(rightSidebar->getX()) : (rightSidebar && rightSidebar->isVisible()) ? rightSidebar->getX() + 1.0f : static_cast<float>(getWidth());

auto const sidebarRight = drawToolbarOutlineAcrossDockedSidebars && leftSidebarCollapsed ? static_cast<float>(leftSidebar->getRight()) : (leftSidebar && leftSidebar->isVisible()) ? leftSidebar->getWidth() + 1.0f : 0.0f;

g.setColour(colours.toolbarOutlineColour);

g.drawLine(sidebarRight, tabbarDepth, sidebarLeft, tabbarDepth);

if (isDraggingFile) {

g.setColour(colours.dataColour);

g.drawRoundedRectangle(getLocalBounds().reduced(1).toFloat(), Corners::windowCornerRadius - 1, 2.0f);

}

}

NVGGraphicsContext& PluginEditor::getOrCreateNanoLLGC(NVGcontext* nvg, float const renderScale)

{

if (!nvgCtx || nvgCtx->getContext() != nvg || !approximatelyEqual(nvgCtx->getPhysicalPixelScaleFactor(), renderScale)) {

nvgCtx = std::make_unique<NVGGraphicsContext>(nvg);

nvgCtx->setPhysicalPixelScaleFactor(renderScale);

}

return *nvgCtx;

}

CallOutBox& PluginEditor::showCalloutBox(std::unique_ptr<Component> content, Rectangle<int> const screenBounds)

{

class CalloutDeletionListener : public ComponentListener {

PluginEditor* editor;

public:

explicit CalloutDeletionListener(PluginEditor* e)

: editor(e)

{

}

void componentBeingDeleted(Component& c) override

{

c.removeComponentListener(this);

editor->calloutArea->removeFromDesktop();

delete this;

}

};

if (ProjectInfo::canUseSemiTransparentWindows()) {

content->addComponentListener(new CalloutDeletionListener(this));

calloutArea->addToDesktop(ComponentPeer::windowIsTemporary, OSUtils::getDesktopParentPeer(this));

calloutArea->toFront(true);

auto const bounds = calloutArea->getLocalArea(nullptr, screenBounds);

return CallOutBox::launchAsynchronously(std::move(content), bounds, calloutArea.get());

}

return CallOutBox::launchAsynchronously(std::move(content), screenBounds, nullptr);

}

void PluginEditor::showWelcomePanel(bool const shouldShow)

{

addObjectMenuButton.setVisible(!shouldShow);

undoButton.setVisible(!shouldShow);

redoButton.setVisible(!shouldShow);

leftSidebar->setVisible(!shouldShow && leftSidebar->hasAnyPanel());

rightSidebar->setVisible(!shouldShow && rightSidebar->hasAnyPanel());

statusbar->setVisible(!shouldShow);

sidebarToggleButton.setVisible(shouldShow);

welcomePanelSearchButton.setVisible(shouldShow);

recentlyOpenedPanelSelector.setVisible(shouldShow);

libraryPanelSelector.setVisible(shouldShow);

if (shouldShow) {

welcomePanel->show();

if (leftSidebar && leftSidebar->hasAnyPanel())

leftSidebar->showSidebar(true);

if (rightSidebar && rightSidebar->hasAnyPanel())

rightSidebar->showSidebar(true);

} else {

welcomePanel->hide();

welcomePanelSearchButton.setToggleState(false, sendNotification);

welcomePanel->setSearchQuery("");

}

}

void PluginEditor::dragOperationEnded(DragAndDropTarget::SourceDetails const& details)

{

if (!ProjectInfo::isStandalone)

return;

auto wasDroppedOnTarget = static_cast<bool>(details.description.getDynamicObject()->getProperty("dropped"));

if (!wasDroppedOnTarget) {

tabComponent.createNewWindowFromTab(details.sourceComponent);

}

}

void PluginEditor::resized()

{

#if JUCE_IOS

static bool alreadyResized = false;

if (auto* window = dynamic_cast<PlugDataWindow*>(getTopLevelComponent())) {

if (!alreadyResized) {

ScopedValueSetter recursionBlock(alreadyResized, true);

auto totalArea = Desktop::getInstance().getDisplays().getPrimaryDisplay()->logicalBounds.getSmallestIntegerContainer();

totalArea = OSUtils::getSafeAreaInsets().subtractedFrom(totalArea);

setBounds(totalArea);

window->setFullScreen(true);

}

}

#endif

pd->lastUIWidth = getWidth();

pd->lastUIHeight = getHeight();

if (isInPluginMode()) {

nvgSurface.updateBounds(getLocalBounds());

updateStandaloneWindowControls();

return;

}

auto const leftHasSelectors = leftSidebar && leftSidebar->isVisible() && leftSidebar->hasAnyPanel();

auto const rightHasSelectors = rightSidebar && rightSidebar->isVisible() && rightSidebar->hasAnyPanel();

auto const leftExpanded = leftHasSelectors && !leftSidebar->isHidden();

auto const rightExpanded = rightHasSelectors && !rightSidebar->isHidden();

auto bounds = getLocalBounds();

auto toolbarBounds = bounds.removeFromTop(toolbarHeight);

{

if (leftHasSelectors) {

if (leftExpanded) {

leftSidebar->setBounds(bounds.removeFromLeft(leftSidebar->getWidth()));

} else {

leftSidebar->setBounds(0, toolbarHeight, 34, bounds.getHeight());

bounds.removeFromLeft(34);

}

}

if (rightHasSelectors) {

if (rightExpanded) {

rightSidebar->setBounds(bounds.removeFromRight(rightSidebar->getWidth()));

} else {

rightSidebar->setBounds(getWidth() - 34, toolbarHeight, 34, bounds.getHeight());

bounds.removeFromRight(34);

}

}

if(!welcomePanel->isVisible()) {

statusbar->setBounds(bounds.removeFromBottom(Statusbar::getStatusbarHeight()));

}

}

nvgSurface.updateBounds(getLocalBounds());

welcomePanel->setBounds(bounds.withTrimmedTop(6));

tabComponent.setBounds(bounds);

#if JUCE_MAC

auto useLeftButtons = true;

#else

auto useLeftButtons = false;

#endif

auto const useNonNativeTitlebar = ProjectInfo::isStandalone && !SettingsFile::getInstance()->getProperty<bool>("native_window");

auto offset = useLeftButtons && useNonNativeTitlebar ? 80 : 15;

#if JUCE_MAC

if (auto const standalone = ProjectInfo::isStandalone ? dynamic_cast<DocumentWindow*>(getTopLevelComponent()) : nullptr)

offset = standalone->isFullScreen() ? 20 : offset;

#endif

toolbarBounds = toolbarBounds.withTrimmedLeft(offset).translated(0, 2);

constexpr auto buttonDistance = 38;

auto const buttonSize = toolbarHeight + 5;

auto nextButtonBounds = [&toolbarBounds, buttonSize](){ return toolbarBounds.removeFromLeft(buttonDistance).withSizeKeepingCentre(buttonSize, buttonSize); };

mainMenuButton.setBounds(nextButtonBounds());

undoButton.setBounds(nextButtonBounds());

redoButton.setBounds(nextButtonBounds());

addObjectMenuButton.setBounds(nextButtonBounds());

#if JUCE_IOS

auto windowControlsOffset = 0.f;

#else

auto windowControlsOffset = useNonNativeTitlebar && !useLeftButtons ? 90.f : 0.f;

#endif

auto audioToolbarWidth = welcomePanelSearchButton.isVisible() ? 210 : getWidth() - addObjectMenuButton.getRight();

if (audioToolbar)

audioToolbar->setBounds(toolbarBounds.removeFromRight(audioToolbarWidth).translated(-windowControlsOffset, 0));

auto enoughSpaceForExtraWelcomeButtons = toolbarBounds.getWidth() > 200;

sidebarToggleButton.setVisible(enoughSpaceForExtraWelcomeButtons);

welcomePanelSearchButton.setVisible(enoughSpaceForExtraWelcomeButtons);

sidebarToggleButton.setBounds(toolbarBounds.removeFromRight(buttonDistance).withSizeKeepingCentre(buttonSize, buttonSize));

welcomePanelSearchButton.setBounds(toolbarBounds.removeFromRight(buttonDistance).withSizeKeepingCentre(buttonSize, buttonSize));

auto welcomeSelectorBounds = toolbarBounds.withSizeKeepingCentre(200, toolbarHeight + 2);

recentlyOpenedPanelSelector.setBounds(welcomeSelectorBounds.removeFromLeft(100));

libraryPanelSelector.setBounds(welcomeSelectorBounds.removeFromLeft(100));

if (borderResizer && ProjectInfo::isStandalone) {

borderResizer->setBounds(getLocalBounds());

} else if (cornerResizer) {

constexpr int resizerSize = 18;

cornerResizer->setBounds(getWidth() - resizerSize + 1,

getHeight() - resizerSize + 1,

resizerSize, resizerSize);

}

auto welcomePanelSearchBounds = Rectangle<int>(libraryPanelSelector.getRight() + 10, 4, welcomePanelSearchButton.getX() - libraryPanelSelector.getRight() - 20, toolbarHeight - 4);

if(welcomePanelSearchBounds.getWidth() < 120)

welcomePanelSearchBounds.setLeft(recentlyOpenedPanelSelector.getX());

welcomePanelSearchInput.setBounds(welcomePanelSearchBounds);

updateStandaloneWindowControls();

repaint(); // Some outlines are dependent on whether or not the sidebars are expanded, or whether or not a patch is opened

}

bool PluginEditor::isInPluginMode() const

{

return static_cast<bool>(pluginMode);

}

Canvas* PluginEditor::getPluginModeCanvas() const

{

if (isInPluginMode())

return pluginMode->getCanvas();

return nullptr;

}

void PluginEditor::parentSizeChanged()

{

if (!ProjectInfo::isStandalone)

return;

#if JUCE_MAC

auto* standalone = dynamic_cast<PlugDataWindow*>(getTopLevelComponent());

// Hide TitleBar Buttons in Plugin Mode

bool visible = !isInPluginMode();

if (!standalone->useNativeTitlebar() && !visible && !standalone->isFullScreen()) {

// Hide TitleBar Buttons in Plugin Mode if using native title bar

if (ComponentPeer* peer = standalone->getPeer())

OSUtils::hideTitlebarButtons(peer, true, true, true);

} else {

// Show TitleBar Buttons

if (ComponentPeer* peer = standalone->getPeer())

OSUtils::hideTitlebarButtons(peer, false, false, false);

}

#else

updateStandaloneWindowControls();

#endif

resized();

}

void PluginEditor::updateIoletGeometryForAllObjects(PluginProcessor const* pd)

{

// update all object's iolet position

for (auto const& editor : pd->getEditors()) {

for (auto const& cnv : editor->getCanvases()) {

for (auto const& obj : cnv->objects) {

obj->updateIoletGeometry();

}

}

}

// update all connections to make sure they attach to the correct iolet positions

for (auto const& editor : pd->getEditors()) {

for (auto const& cnv : editor->getCanvases()) {

for (auto const& con : cnv->connections) {

con->forceUpdate();

}

}

}

}

Sidebar* PluginEditor::getSidebarForPanel(Sidebar::SidePanel panel) const

{

if (leftSidebar && leftSidebar->hasPanel(panel))

return leftSidebar.get();

if (rightSidebar && rightSidebar->hasPanel(panel))

return rightSidebar.get();

return nullptr;

}

void PluginEditor::movePanelToSide(Sidebar::SidePanel panel, Sidebar::Side targetSide)

{

auto* target = targetSide == Sidebar::Side::Left ? leftSidebar.get() : rightSidebar.get();

auto* source = targetSide == Sidebar::Side::Left ? rightSidebar.get() : leftSidebar.get();

if (!target || !source)

return;

if (target->hasPanel(panel))

return; // already there

source->removePanel(panel);

target->addPanel(panel);

// Persist

SettingsFile::getInstance()->setProperty(

"sidebar_panel_" + Sidebar::panelIdToString(panel),

Sidebar::sideToString(targetSide));

// The target sidebar may have been invisible (no panels). Re-evaluate.

leftSidebar->setVisible(leftSidebar->hasAnyPanel());

rightSidebar->setVisible(rightSidebar->hasAnyPanel());

resized();

repaint();

}

void PluginEditor::mouseDown(MouseEvent const& e)

{

// no window dragging by toolbar in plugin!

if (!ProjectInfo::isStandalone || !e.mods.isLeftButtonDown())

return;

if (e.getNumberOfClicks() >= 2) {

#if JUCE_MAC

if (isMaximised) {

getPeer()->setBounds(unmaximisedSize, false);

} else {

unmaximisedSize = getTopLevelComponent()->getBounds();

auto const userArea = Desktop::getInstance().getDisplays().getPrimaryDisplay()->userBounds.getSmallestIntegerContainer();

getPeer()->setBounds(userArea, false);

}

isMaximised = !isMaximised;

#else

findParentComponentOfClass<DocumentWindow>()->maximiseButtonPressed();

#endif

}

#if !JUCE_MAC && !JUCE_IOS

if (e.getPosition().getY() < toolbarHeight) {

if (auto* window = findParentComponentOfClass<PlugDataWindow>()) {

if (!window->useNativeTitlebar())

windowDragger.startDraggingWindow(window, e.getEventRelativeTo(window));

}

}

#endif

}

void PluginEditor::mouseDrag(MouseEvent const& e)

{

if (!ProjectInfo::isStandalone)

return;

#if !JUCE_MAC && !JUCE_IOS

if (!isMaximised) {

if (auto* window = findParentComponentOfClass<PlugDataWindow>()) {

if (!window->useNativeTitlebar())

windowDragger.dragWindow(window, e.getEventRelativeTo(window));

}

}

#endif

}

bool PluginEditor::isInterestedInFileDrag(StringArray const& files)

{

if (openedDialog)

return false;

for (auto& path : files) {

auto file = File(path);

if (file.exists()) {

return true;

}

}

return false;

}

void PluginEditor::fileDragMove(StringArray const& files, int const x, int const y)

{

for (auto& path : files) {

auto file = File(path);

if (file.exists() && file.hasFileExtension("pd") && !isDraggingFile) {

isDraggingFile = true;

repaint();

nvgSurface.invalidateAll();

return;

}

}

bool const wasDraggingFile = isDraggingFile;

if (auto* cnv = tabComponent.getCanvasAtScreenPosition(localPointToGlobal(Point<int>(x, y)))) {

if (wasDraggingFile) {

isDraggingFile = false;

repaint();

nvgSurface.invalidateAll();

}

tabComponent.setActiveSplit(cnv);

return;

}

if (!wasDraggingFile) {

isDraggingFile = true;

}

repaint();

nvgSurface.invalidateAll();

}

void PluginEditor::filesDropped(StringArray const& files, int const x, int const y)

{

// First check for .pd files

bool openedPdFiles = false;

for (auto& path : files) {

auto file = File(path);

if (file.exists() && file.hasFileExtension("pd")) {

openedPdFiles = true;

tabComponent.openPatch(URL(file));

}

if (file.exists() && file.hasFileExtension("plugdata")) {

installPackage(file);

}

}

if (auto* cnv = tabComponent.getCanvasAtScreenPosition(localPointToGlobal(Point<int>(x, y)))) {

for (auto& path : files) {

auto file = File(path);

if (file.exists() && !openedPdFiles) {

auto position = cnv->getLocalPoint(this, Point<int>(x, y));

auto filePath = file.getFullPathName().replaceCharacter('\\', '/').replace(" ", "\\ ");

auto* object = cnv->objects.add(cnv, "msg " + filePath, position);

object->hideEditor();

}

}

}

isDraggingFile = false;

repaint();

nvgSurface.invalidateAll();

}

void PluginEditor::fileDragEnter(StringArray const&, int, int)

{

isDraggingFile = true;

repaint();

nvgSurface.invalidateAll();

}