: NVGComponent(this)

, cnv(parent)

, editor(parent->editor)

, ds(parent->dragState)

{

setTopLeftPosition(position - Point<int>(margin, margin));

initialise();

// Open editor for undefined objects

// Delay the setting of the type to prevent creating an invalid object first

if (name.isEmpty()) {

setSize(58, height);

} else {

setType(name);

}

if (!getValue<bool>(locked)) {

showEditor();

}

: NVGComponent(this)

, cnv(parent)

, editor(parent->editor)

, ds(parent->dragState)

{

initialise();

setType("", object);

{

if (gui) {

return gui->getSelectableBounds() + cnv->canvasOrigin;

}

return getBounds().reduced(margin);

{

cnv->objectLayer.addAndMakeVisible(this);

cnv->selectedComponents.addChangeListener(this);

// Updates lock/unlock mode

locked.referTo(cnv->locked);

commandLocked.referTo(cnv->pd->commandLocked);

presentationMode.referTo(cnv->presentationMode);

hvccMode.referTo(SettingsFile::getInstance()->getValueTree(), Identifier("hvcc_mode"), nullptr, false);

patchDownwardsOnly.referTo(SettingsFile::getInstance()->getValueTree(), Identifier("patch_downwards_only"), nullptr);

presentationMode.addListener(this);

locked.addListener(this);

commandLocked.addListener(this);

originalBounds.setBounds(0, 0, 0, 0);

setAccessible(false); // TODO: implement accessibility. We disable default, since it makes stuff slow on macOS

{

activeStateAlpha -= 0.06f;

repaint();

if (activeStateAlpha <= 0.0f) {

activeStateAlpha = 0.0f;

stopTimer();

}

{

if (auto selectedItems = dynamic_cast<SelectedItemSet<WeakReference<Component>>*>(source))

setSelected(selectedItems->isSelected(this));

{

if (selectedFlag != shouldBeSelected) {

selectedFlag = shouldBeSelected;

repaint();

}

{

if (name == "hvcc_mode") {

isHvccCompatible = checkIfHvccCompatible();

if (gui && !isHvccCompatible) {

cnv->pd->logWarning(String("Warning: object \"" + gui->getType() + "\" is not supported in Compiled Mode").toRawUTF8());

}

repaint();

}

{

if (v.refersToSameSourceAs(cnv->presentationMode)) {

// else it was a lock/unlock/presentation mode action

// Hide certain objects in GOP

setVisible(!((cnv->isGraph || cnv->presentationMode == var(true)) && gui && gui->hideInGraph()));

} else if (v.refersToSameSourceAs(cnv->locked) || v.refersToSameSourceAs(cnv->commandLocked)) {

if (gui) {

gui->lock(cnv->isGraph || locked == var(true) || commandLocked == var(true));

}

}

{

if (gui) {

auto typeName = gui->getType();

// Check hvcc compatibility

bool isSubpatch = gui->getPatch() != nullptr;

return !hvccMode.get() || isSubpatch || HeavyCompatibleObjects::getAllCompatibleObjects().contains(typeName);

}

return true;

{

if (::getValue<bool>(presentationMode)) {

if (cnv->isPointOutsidePluginArea(cnv->getLocalPoint(this, Point<int>(x, y))))

return false;

}

if (cnv->panningModifierDown())

return false;

// If the hit-test get's to here, and any of these are still true

// return! Otherwise it will test non-existent iolets and return true!

bool blockIolets = presentationMode.getValue() || locked.getValue() || commandLocked.getValue();

// Mouse over iolets

for (auto* iolet : iolets) {

if (!blockIolets && iolet->getBounds().contains(x, y))

return true;

}

if (selectedFlag) {

for (auto& corner : getCorners()) {

if (corner.contains(x, y))

return true;

}

return getLocalBounds().reduced(margin).contains(x, y);

}

if (gui && !gui->canReceiveMouseEvent(x, y)) {

return false;

}

// Mouse over object

if (getLocalBounds().reduced(margin).contains(x, y)) {

return true;

}

return false;

{

drawIoletExpanded = true;

repaint();

{

// we need to reset the resizeZone & validResizeZone,

// otherwise it can have an old zone already selected on re-entry

resizeZone = ResizableBorderComponent::Zone(ResizableBorderComponent::Zone::centre);

validResizeZone = false;

drawIoletExpanded = false;

repaint();

{

if (!selectedFlag || locked == var(true) || commandLocked == var(true)) {

setMouseCursor(MouseCursor::NormalCursor);

updateMouseCursor();

return;

}

int zone = 0;

auto b = getLocalBounds().toFloat().reduced(margin - 2);

if (b.contains(e.position)

&& !b.reduced(7).contains(e.position)) {

auto corners = getCorners();

auto minW = jmax(b.getWidth() / 10.0f, jmin(10.0f, b.getWidth() / 3.0f));

auto minH = jmax(b.getHeight() / 10.0f, jmin(10.0f, b.getHeight() / 3.0f));

if (corners[0].contains(e.position) || corners[1].contains(e.position) || (e.position.x < jmax(7.0f, minW) && b.getX() > 0.0f))

zone |= ResizableBorderComponent::Zone::left;

else if (corners[2].contains(e.position) || corners[3].contains(e.position) || (e.position.x >= b.getWidth() - jmax(7.0f, minW)))

zone |= ResizableBorderComponent::Zone::right;

if (corners[0].contains(e.position) || corners[3].contains(e.position) || (e.position.y < jmax(7.0f, minH)))

zone |= ResizableBorderComponent::Zone::top;

else if (corners[1].contains(e.position) || corners[2].contains(e.position) || (e.position.y >= b.getHeight() - jmax(7.0f, minH)))

zone |= ResizableBorderComponent::Zone::bottom;

}

resizeZone = static_cast<ResizableBorderComponent::Zone>(zone);

validResizeZone = resizeZone.getZoneFlags() != ResizableBorderComponent::Zone::centre && e.originalComponent == this && !(gui && gui->isEditorShown()) && !newObjectEditor;

setMouseCursor(validResizeZone ? resizeZone.getMouseCursor() : MouseCursor::NormalCursor);

updateMouseCursor();

{

UnorderedMap<Object*, Rectangle<int>> newObjectSizes;

for (auto* obj : cnv->getSelectionOfType<Object>())

newObjectSizes[obj] = obj->getObjectBounds();

auto positionOffset = gui ? (getBounds().reduced(margin).getPosition() - cnv->canvasOrigin) - gui->getPdBounds().getPosition() : Point<int>(0, 0);

auto* patch = &cnv->patch;

cnv->pd->lockAudioThread();

if (ds.wasResized || ds.wasDragDuplicated) {

patch->startUndoSequence("Resize");

for (auto& [object, bounds] : newObjectSizes) {

if (object->gui)

object->gui->setPdBounds(bounds);

}

if(auto* patch = cnv->patch.getRawPointer()) {

canvas_dirty(patch, 1);

}

patch->endUndoSequence("Resize");

} else if (ds.didStartDragging) {

patch->startUndoSequence("Move");

SmallArray<t_gobj*> objects;

for (auto* obj : cnv->getSelectionOfType<Object>()) {

if (auto* ptr = obj->getPointer()) {

objects.add(ptr);

}

}

cnv->patch.moveObjects(objects, positionOffset.x, positionOffset.y);

patch->endUndoSequence("Move");

}

cnv->pd->unlockAudioThread();

MessageManager::callAsync([editor = SafePointer(this->editor)] {

if (editor)

editor->updateCommandStatus();

});

{

if (cnv->isGraph && gui && gui->hideInGraph())

return;

// only update if we have a gui and the object isn't been moved by the user

// otherwise PD hasn't been informed of the new position 'while' we are dragging

// so we don't need to update the bounds when an object is being interacted with

if (gui && !isObjectMouseActive) {

// Get the bounds of the object in Pd

auto newBounds = gui->getPdBounds();

// Objects may return empty bounds if they are not a real object (like scalars)

if (!newBounds.isEmpty())

setObjectBounds(newBounds);

else

setTopLeftPosition(newBounds.getX() + margin + cnv->canvasOrigin.x, newBounds.getY() + margin + cnv->canvasOrigin.y);

}

if (newObjectEditor) {

textEditorTextChanged(*newObjectEditor);

}

{

// Change object type

String type = newType.upToFirstOccurrenceOf(" ", false, false);

pd::WeakReference objectPtr = nullptr;

// "exists" indicates that this object already exists in pd

// When setting exists to true, the gui needs to be assigned already

if (!existingObject.isValid()) {

auto* patch = &cnv->patch;

if (gui) {

// Clear connections to this object

// They will be remade by the synchronise call later

for (auto* connection : getConnections())

cnv->connections.remove_one(connection);

if (auto* checkedObject = pd::Interface::checkObject(getPointer())) {

auto renamedObject = patch->renameObject(checkedObject, newType);

objectPtr = pd::WeakReference(renamedObject, cnv->pd);

}

// Synchronise to make sure connections are preserved correctly

cnv->synchronise();

} else {

auto rect = getObjectBounds();

auto* newObject = patch->createObject(rect.getX(), rect.getY(), newType);

objectPtr = pd::WeakReference(newObject, cnv->pd);

}

} else {

objectPtr = existingObject;

}

if (!objectPtr.getRaw<t_gobj>()) {

jassertfalse;

return;

}

// Create gui for the object

gui.reset(ObjectBase::createGui(objectPtr, this));

isGemObject = is_gem_object(gui->getText().toRawUTF8());

if (gui) {

gui->initialise();

gui->lock(cnv->isGraph || locked == var(true) || commandLocked == var(true));

gui->addMouseListener(this, true);

addAndMakeVisible(gui.get());

}

isHvccCompatible = checkIfHvccCompatible();

if (gui && !isHvccCompatible) {

cnv->pd->logWarning(String("Warning: object \"" + gui->getType() + "\" is not supported in Compiled Mode").toRawUTF8());

}

// Update inlets/outlets

updateIolets();

updateBounds();

resized(); // If bounds haven't changed, we'll still want to update gui and iolets bounds

// Auto patching

if (getValue<bool>(editor->autoconnect) && numInputs && cnv->lastSelectedObject && cnv->lastSelectedObject != this && cnv->lastSelectedObject->numOutputs) {

auto* outlet = cnv->lastSelectedObject->iolets[cnv->lastSelectedObject->numInputs];

auto* inlet = iolets[0];

if (outlet->isSignal == inlet->isSignal) {

// Call async to make sure the object is created before the connection

MessageManager::callAsync([this, outlet, inlet]() {

cnv->connections.add(cnv, outlet, inlet, nullptr);

});

}

}

if (cnv->lastSelectedConnection && numInputs && numOutputs) {

// if 1 connection is selected, connect the new object in middle of connection

auto outobj = cnv->lastSelectedConnection->outobj;

auto inobj = cnv->lastSelectedConnection->inobj;

auto* outlet = outobj->iolets[outobj->numInputs + cnv->lastSelectedConnection->outIdx];

auto* inlet = inobj->iolets[cnv->lastSelectedConnection->inIdx];

auto* checkedOut = pd::Interface::checkObject(outobj->getPointer());

auto* checkedIn = pd::Interface::checkObject(inobj->getPointer());

if (checkedOut && checkedIn && (outlet->isSignal == iolets[0]->isSignal) && (inlet->isSignal == iolets[this->numInputs]->isSignal)) {

// Call async to make sure the object is created before the connection

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

if (!_this)

return;

cnv->connections.add(cnv, outlet, iolets[0], nullptr);

cnv->connections.add(cnv, iolets[this->numInputs], inlet, nullptr);

});

// remove the previous connection

cnv->patch.removeConnection(checkedOut, cnv->lastSelectedConnection->outIdx, checkedIn, cnv->lastSelectedConnection->inIdx, cnv->lastSelectedConnection->getPathState());

cnv->connections.remove_one(cnv->lastSelectedConnection);

}

}

cnv->lastSelectedObject = nullptr;

cnv->lastSelectedConnection = nullptr;

editor->updateCommandStatus();

cnv->synchroniseSplitCanvas();

cnv->pd->updateObjectImplementations();

{

auto rect = getLocalBounds().reduced(margin);

float const offset = 2.0f;

SmallArray<Rectangle<float>> corners = { Rectangle<float>(9.0f, 9.0f).withCentre(rect.getTopLeft().toFloat()).translated(offset, offset), Rectangle<float>(9.0f, 9.0f).withCentre(rect.getBottomLeft().toFloat()).translated(offset, -offset),

Rectangle<float>(9.0f, 9.0f).withCentre(rect.getBottomRight().toFloat()).translated(-offset, -offset), Rectangle<float>(9.0f, 9.0f).withCentre(rect.getTopRight().toFloat()).translated(-offset, offset) };

return corners;

{

if (gui && withOriginPrefix)

return gui->getTypeWithOriginPrefix();

else if (gui)

return gui->getType();

return String();

{

if (rateReducer.tooFast())

return;

if (!cnv->shouldShowObjectActivity())

return;

activeStateAlpha = 1.0f;

startTimer(1000 / ACTIVITY_UPDATE_RATE);

// Because the timer is being reset when new messages come in

// it will not trigger it's callback until it's free-running

// so we manually call the repaint here if this happens

repaint();

{

if (gui)

gui->updateLabel();

{

setVisible(!((cnv->isGraph || cnv->presentationMode == var(true)) && gui && gui->hideInGraph()));

if (gui) {

gui->setBounds(getLocalBounds().reduced(margin));

}

if (newObjectEditor) {

newObjectEditor->setBounds(getLocalBounds().reduced(margin));

}

updateIoletGeometry();

{

int ioletHitBox = 6;

int maxIoletWidth = std::min(((getWidth() - doubleMargin) / std::max(numInputs, 1)) - 4, ((getWidth() - doubleMargin) / std::max(numOutputs, 1)) - 4);

int maxIoletHeight = (getHeight() / 2.0f) - 2;

int ioletSize = PlugDataLook::ioletSize;

ioletSize = std::max(std::min({ ioletSize, maxIoletWidth, maxIoletHeight }), 10);

int borderWidth = jmap<float>(ioletSize, 10, 13, 7, 12);

// IOLET layout for vanilla style (iolets in corners of objects)

if (PlugDataLook::getUseIoletSpacingEdge()) {

auto vanillaIoletBounds = getLocalBounds();

auto marginOffset = Corners::objectCornerRadius == 0.0f;

vanillaIoletBounds.removeFromLeft(margin - marginOffset);

vanillaIoletBounds.removeFromRight(margin - marginOffset);

auto objectWidth = vanillaIoletBounds.getWidth() + 0.5f; // FIXME: the right most iolet looks not right otherwise

int inletIndex = 0;

int outletIndex = 0;

for (auto& iolet : iolets) {

bool const isInlet = iolet->isInlet;

float const yPosition = (isInlet ? margin + 1 : getHeight() - margin) - (ioletSize / 2.0f);

auto distributeIolets = [ioletSize, objectWidth, vanillaIoletBounds, yPosition](Iolet* iolet, int ioletIndex, int totalIolets) {

auto allOutLetWidth = totalIolets * ioletSize;

auto spacing = ioletIndex != 0 ? (objectWidth - allOutLetWidth) / static_cast<float>(totalIolets - 1) : 0;

auto ioletOffset = ioletIndex != 0 ? ioletSize * ioletIndex : 0;

iolet->setBounds(vanillaIoletBounds.getX() + (spacing * ioletIndex) + ioletOffset, yPosition, ioletSize, ioletSize);

};

if (isInlet) {

distributeIolets(iolet, inletIndex, numInputs);

inletIndex++;

} else {

distributeIolets(iolet, outletIndex, numOutputs);

outletIndex++;

}

}

// DEFAULT iolet position style

} else {

auto inletBounds = getLocalBounds();

if (auto spaceToRemove = jlimit<int>(0, borderWidth, inletBounds.getWidth() - (ioletHitBox * numInputs) - borderWidth)) {

inletBounds.removeFromLeft(spaceToRemove);

inletBounds.removeFromRight(spaceToRemove);

}

auto outletBounds = getLocalBounds();

if (auto spaceToRemove = jlimit<int>(0, borderWidth, outletBounds.getWidth() - (ioletHitBox * numOutputs) - borderWidth)) {

outletBounds.removeFromLeft(spaceToRemove);

outletBounds.removeFromRight(spaceToRemove);

}

int index = 0;

for (auto& iolet : iolets) {

bool const isInlet = iolet->isInlet;

int const position = index < numInputs ? index : index - numInputs;

int const total = isInlet ? numInputs : numOutputs;

float const yPosition = (isInlet ? (margin + 1) : getHeight() - margin) - ioletSize / 2.0f;

auto const bounds = isInlet ? inletBounds : outletBounds;

if (total == 1 && position == 0) {

iolet->setBounds(getWidth() < (25 + ioletSize) ? getLocalBounds().getCentreX() - ioletSize / 2.0f : bounds.getX(),

yPosition, ioletSize, ioletSize);

} else if (total > 1) {

float const ratio = (bounds.getWidth() - ioletSize) / static_cast<float>(total - 1);

iolet->setBounds(bounds.getX() + ratio * position, yPosition, ioletSize, ioletSize);

}

index++;

}

}

{

if (!gui || cnv->isGraph)

return;

auto objectInfo = cnv->pd->objectLibrary->getObjectInfo(gui->getTypeWithOriginPrefix());

StackArray<StringArray, 2> ioletTooltips;

if (objectInfo.isValid()) {

// Set object tooltip

gui->setTooltip(objectInfo.getProperty("description").toString());

// Check pd library for pddp tooltips, those have priority

ioletTooltips = cnv->pd->objectLibrary->parseIoletTooltips(objectInfo.getChildWithName("iolets"), gui->getText(), numInputs, numOutputs);

}

// First clear all tooltips, so we can see later if it has already been set or not

for (auto iolet : iolets) {

iolet->setTooltip("");

}

// Load tooltips from documentation files, these have priority

for (int i = 0; i < iolets.size(); i++) {

auto* iolet = iolets[i];

auto& tooltip = ioletTooltips[!iolet->isInlet][iolet->isInlet ? i : i - numInputs];

if (tooltip.startsWith("(gemlist)")) {

iolet->isGemState = true;

iolet->setTooltip("(gemlist)");

} else {

if (tooltip.isNotEmpty()) { // Don't overwrite custom documentation if there is no md documentation

iolet->setTooltip(tooltip);

}

iolet->isGemState = false;

}

}

SmallArray<std::pair<int, String>, 16> inletMessages;

SmallArray<std::pair<int, String>, 16> outletMessages;

if (auto subpatch = gui->getPatch()) {

cnv->pd->lockAudioThread();

auto* subpatchPtr = subpatch->getPointer().get();

// Check child objects of subpatch for inlet/outlet messages

for (auto obj : subpatch->getObjects()) {

if (!obj.isValid())

continue;

auto const name = hash(pd::Interface::getObjectClassName(obj.getRaw<t_pd>()));

auto* checkedObject = pd::Interface::checkObject(obj.getRaw<t_pd>());

if (name == hash("inlet") || name == hash("inlet~")) {

int size;

char* str_ptr;

pd::Interface::getObjectText(checkedObject, &str_ptr, &size);

int x, y, w, h;

pd::Interface::getObjectBounds(subpatchPtr, obj.getRaw<t_gobj>(), &x, &y, &w, &h);

// Anything after the first space will be the comment

auto const text = String::fromUTF8(str_ptr, size);

inletMessages.emplace_back(x, text.fromFirstOccurrenceOf(" ", false, false));

freebytes(static_cast<void*>(str_ptr), static_cast<size_t>(size) * sizeof(char));

} else if (name == hash("outlet") || name == hash("outlet~")) {

int size;

char* str_ptr;

pd::Interface::getObjectText(checkedObject, &str_ptr, &size);

int x, y, w, h;

pd::Interface::getObjectBounds(subpatchPtr, obj.getRaw<t_gobj>(), &x, &y, &w, &h);

auto const text = String::fromUTF8(str_ptr, size);

outletMessages.emplace_back(x, text.fromFirstOccurrenceOf(" ", false, false));

freebytes(static_cast<void*>(str_ptr), static_cast<size_t>(size) * sizeof(char));

}

}

cnv->pd->unlockAudioThread();

}

if (inletMessages.empty() && outletMessages.empty())

return;

auto sortFunc = [](auto const& a, auto const& b) {

return a.first < b.first;

};

inletMessages.sort(sortFunc);

outletMessages.sort(sortFunc);

int numIn = 0;

int numOut = 0;

for (auto iolet : iolets) {

if (iolet->getTooltip().isNotEmpty())

continue;

if ((iolet->isInlet && numIn >= inletMessages.size()) || (!iolet->isInlet && numOut >= outletMessages.size()))

continue;

auto& [x, message] = iolet->isInlet ? inletMessages[numIn++] : outletMessages[numOut++];

iolet->setTooltip(message);

iolet->isGemState = message.startsWith("(gemlist)");

}

{

if (!getPointer())

return;

// update inlets and outlets

int oldNumInputs = 0;

int oldNumOutputs = 0;

for (auto* iolet : iolets) {

iolet->isInlet ? oldNumInputs++ : oldNumOutputs++;

}

numInputs = 0;

numOutputs = 0;

if (auto* ptr = pd::Interface::checkObject(getPointer())) {

numInputs = pd::Interface::numInlets(ptr);

numOutputs = pd::Interface::numOutlets(ptr);

}

// Looking up tooltips takes a bit of time, so we make sure we're not constantly updating them for no reason

bool tooltipsNeedUpdate = gui->getPatch() != nullptr || numInputs != oldNumInputs || numOutputs != oldNumOutputs || isGemObject;

for (auto* iolet : iolets) {

if (gui && !iolet->isInlet) {

iolet->setHidden(gui->outletIsSymbol());

} else if (gui && iolet->isInlet) {

iolet->setHidden(gui->inletIsSymbol());

}

}

while (numInputs < oldNumInputs)

iolets.remove_at(oldNumInputs--);

while (numInputs > oldNumInputs)

iolets.insert(oldNumInputs++, this, true);

while (numOutputs < oldNumOutputs)

iolets.remove_at(numInputs + (oldNumOutputs--));

while (numOutputs > oldNumOutputs)

iolets.insert(numInputs + (oldNumOutputs++), this, false);

int numIn = 0;

int numOut = 0;

for (int i = 0; i < numInputs + numOutputs; i++) {

auto* iolet = iolets[i];

bool input = iolet->isInlet;

bool isSignal = false;

auto* patchableObject = pd::Interface::checkObject(getPointer());

if (patchableObject && i < numInputs) {

isSignal = pd::Interface::isSignalInlet(patchableObject, i);

} else if (patchableObject) {

isSignal = pd::Interface::isSignalOutlet(patchableObject, i - numInputs);

}

iolet->ioletIdx = input ? numIn : numOut;

iolet->isSignal = isSignal;

iolet->repaint();

numIn += input;

numOut += !input;

}

if (tooltipsNeedUpdate)

updateTooltips();

resized();

{

// Only show right-click menu in locked mode if the object can be opened

// We don't allow alt+click for popupmenus here, as that will conflict with some object behaviour, like for [range.hsl]

if (e.mods.isRightButtonDown() && !cnv->isGraph) {

PopupMenu::dismissAllActiveMenus();

if (!getValue<bool>(locked)) {

if (!e.mods.isAnyModifierKeyDown() && !e.mods.isRightButtonDown())

cnv->deselectAll();

cnv->setSelected(this, true);

}

Dialogs::showCanvasRightClickMenu(cnv, this, e.getScreenPosition());

return;

}

if (cnv->isGraph || getValue<bool>(presentationMode) || getValue<bool>(locked) || getValue<bool>(commandLocked)) {

wasLockedOnMouseDown = true;

return;

}

wasLockedOnMouseDown = false;

if (e.mods.isShiftDown()) {

// select multiple objects

ds.wasSelectedOnMouseDown = selectedFlag;

ds.duplicateOffset = { 0, 0 };

ds.lastDuplicateOffset = { 0, 0 };

ds.wasDuplicated = false;

} else if (!selectedFlag) {

cnv->deselectAll();

ds.duplicateOffset = { 0, 0 };

ds.lastDuplicateOffset = { 0, 0 };

ds.wasDuplicated = false;

}

cnv->setSelected(this, true);

ds.componentBeingDragged = this;

for (auto* object : cnv->getSelectionOfType<Object>()) {

object->originalBounds = object->getBounds();

}

bool overEdgeNotCorner = (resizeZone.isDraggingTopEdge() + resizeZone.isDraggingLeftEdge() + resizeZone.isDraggingBottomEdge() + resizeZone.isDraggingRightEdge() == 1) ? true : false;

auto toResize = cnv->getSelectionOfType<Object>();

for (auto* obj : toResize) {

if (!obj->gui)

continue;

bool isDraggingOneEdge = false;

if (obj->gui->canEdgeOverrideAspectRatio() && overEdgeNotCorner) {

isDraggingOneEdge = true;

}

if (auto* constrainer = obj->getConstrainer()) {

if (gui && gui->canEdgeOverrideAspectRatio()) {

if (isDraggingOneEdge)

constrainer->setFixedAspectRatio(0);

else

constrainer->setFixedAspectRatio(static_cast<float>(obj->getObjectBounds().getWidth()) / obj->getObjectBounds().getHeight());

}

}

}

repaint();

ds.canvasDragStartPosition = cnv->getPosition();

if (!selectedFlag) {

selectionStateChanged = true;

}

cnv->updateSidebarSelection();

cnv->patch.startUndoSequence("Drag");

isInsideUndoSequence = true;

{

if (wasLockedOnMouseDown || (gui && gui->isEditorShown()))

return;

if (!ds.didStartDragging && !getValue<bool>(locked) && e.mods.isAltDown()) {

// Show help file on alt+mouseup if object were not draged

openHelpPatch();

}

auto objects = cnv->getSelectionOfType<Object>();

for (auto* obj : objects)

obj->isObjectMouseActive = false;

if (ds.wasResized) {

cnv->objectGrid.clearIndicators(false);

applyBounds();

ds.wasResized = false;

originalBounds.setBounds(0, 0, 0, 0);

} else {

if (cnv->isGraph) {

if (isInsideUndoSequence) {

isInsideUndoSequence = false;

cnv->patch.endUndoSequence("Drag");

}

return;

}

if (e.mods.isShiftDown() && ds.wasSelectedOnMouseDown && !ds.didStartDragging) {

// Unselect object if selected

cnv->setSelected(this, false);

repaint();

} else if (!e.mods.isShiftDown() && !e.mods.isAltDown() && selectedFlag && !ds.didStartDragging && !e.mods.isRightButtonDown()) {

// Don't run normal deselectAll, that would clear the sidebar inspector as well

// We'll update sidebar selection later in this function

cnv->selectedComponents.deselectAll();

cnv->setSelected(this, true);

}

if (ds.didStartDragging) {

cnv->objectGrid.clearIndicators(false);

applyBounds();

ds.didStartDragging = false;

}

cnv->updateSidebarSelection();

if (ds.objectSnappingInbetween) {

auto* c = ds.connectionToSnapInbetween.getComponent();

cnv->patch.startUndoSequence("Snap inbetween");

auto* checkedOut = pd::Interface::checkObject(c->outobj->getPointer());

auto* checkedIn = pd::Interface::checkObject(c->inobj->getPointer());

auto* checkedSnapped = pd::Interface::checkObject(ds.objectSnappingInbetween->getPointer());

if (checkedOut && checkedIn && checkedSnapped) {

cnv->patch.removeConnection(checkedOut, c->outIdx, checkedIn, c->inIdx, c->getPathState());

cnv->patch.createConnection(checkedOut, c->outIdx, checkedSnapped, 0);

cnv->patch.createConnection(checkedSnapped, 0, checkedIn, c->inIdx);

}

cnv->patch.endUndoSequence("Snap inbetween");

ds.objectSnappingInbetween->iolets[0]->isTargeted = false;

ds.objectSnappingInbetween->iolets[ds.objectSnappingInbetween->numInputs]->isTargeted = false;

ds.objectSnappingInbetween = nullptr;

cnv->synchronise();

}

for (auto* object : cnv->getSelectionOfType<Object>()) {

object->repaint();

}

ds.componentBeingDragged = nullptr;

repaint();

}

if (ds.wasDragDuplicated) {

cnv->patch.endUndoSequence("Duplicate");

ds.wasDragDuplicated = false;

}

if (gui && selectedFlag && !selectionStateChanged && !e.mouseWasDraggedSinceMouseDown() && !e.mods.isRightButtonDown() && !e.mods.isAnyModifierKeyDown()) {

gui->showEditor();

}

selectionStateChanged = false;

if (isInsideUndoSequence) {

isInsideUndoSequence = false;

cnv->patch.endUndoSequence("Drag");

}

cnv->needsSearchUpdate = true;

{

if (wasLockedOnMouseDown || (gui && gui->isEditorShown()))

return;

if (cnv->objectRateReducer.tooFast())

return;

#if JUCE_MAC || JUCE_WINDOWS

beginDragAutoRepeat(25); // Doing this leads to terrible performance on Linux, unfortunately

#endif

cnv->cancelConnectionCreation();

if (e.mods.isMiddleButtonDown())

return;

if (validResizeZone && !originalBounds.isEmpty()) {

auto draggedBounds = resizeZone.resizeRectangleBy(originalBounds, e.getOffsetFromDragStart());

auto dragDistance = cnv->objectGrid.performResize(this, e.getOffsetFromDragStart(), draggedBounds);

auto toResize = cnv->getSelectionOfType<Object>();

for (auto* obj : toResize) {

if (!obj->gui)

continue;

obj->isObjectMouseActive = true;

// Create undo step when we start resizing

if (!ds.wasResized) {

auto* objPtr = static_cast<t_gobj*>(obj->getPointer());

auto* cnv = obj->cnv;

if(auto patchPtr = cnv->patch.getPointer())

{

pd::Interface::undoApply(patchPtr.get(), objPtr);

}

}

auto const newBounds = resizeZone.resizeRectangleBy(obj->originalBounds, dragDistance);

if (auto* constrainer = obj->getConstrainer()) {

constrainer->setBoundsForComponent(obj, newBounds, resizeZone.isDraggingTopEdge(), resizeZone.isDraggingLeftEdge(), resizeZone.isDraggingBottomEdge(), resizeZone.isDraggingRightEdge());

}

}

ds.wasResized = true;

} else if (!cnv->isGraph) {

int const minimumMovementToStartDrag = 5;

// Ensure tiny movements don't start a drag.

if (!ds.didStartDragging && e.getDistanceFromDragStart() < minimumMovementToStartDrag)

return;

if (!ds.didStartDragging) {

ds.didStartDragging = true;

}

auto canvasMoveOffset = ds.canvasDragStartPosition - cnv->getPosition();

auto selection = cnv->getSelectionOfType<Object>();

auto dragDistance = e.getOffsetFromDragStart() + canvasMoveOffset;

if (ds.componentBeingDragged) {