/*

// 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_dsp/juce_dsp.h>

#include "Utility/Config.h"

#include "Utility/Fonts.h"

#include "ObjectGrid.h"

#include "Object.h"

#include "Canvas.h"

#include "PluginEditor.h"

#include "Connection.h"

#include "CanvasViewport.h"

ObjectGrid::ObjectGrid(Canvas* cnv)

: cnv(cnv)

, updater(cnv)

{

gridEnabled = SettingsFile::getInstance()->getProperty<int>("grid_enabled");

gridType = SettingsFile::getInstance()->getProperty<int>("grid_type");

gridSize = SettingsFile::getInstance()->getProperty<int>("grid_size");

}

void ObjectGrid::positionNewObject(Object* newObject, Point<int> mousePosition)

{

if (ModifierKeys::getCurrentModifiers().isShiftDown() || gridType == 0 || !gridEnabled) {

return;

}

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

ScopedValueSetter toleranceSetter(objectTolerance, 15);

auto offset = performMove(newObject, {0, 0});

auto nb = newObject->getObjectBounds() + offset;

if (newObject->gui)

newObject->gui->setPdBounds(nb);

else

newObject->setObjectBounds(nb);

clearIndicators(false);

}

SmallArray<Object*> ObjectGrid::getSnappableObjects(Object const* draggedObject)

{

auto const& cnv = draggedObject->cnv;

if (!cnv->viewport)

return { };

SmallArray<Object*> snappable;

auto const viewBounds = cnv->viewport->getViewArea();

for (auto* object : cnv->objects) {

if (draggedObject == object || object->isSelected() || !viewBounds.intersects(object->getBounds().toFloat()))

continue; // don't look at dragged object, selected objects, or objects that are outside of view bounds

snappable.add(object);

}

auto centre = draggedObject->getBounds().getCentre();

snappable.sort([centre](Object const* a, Object const* b) {

auto const distA = a->getBounds().getCentre().getDistanceFrom(centre);

auto const distB = b->getBounds().getCentre().getDistanceFrom(centre);

return distA > distB;

});

return snappable;

}

void ObjectGrid::startLineFadeAnimation(int idx, float ms, float targetAlpha)

{

lineAnimators[idx].complete();

lineTargetAlpha[idx] = targetAlpha;

lineAnimators[idx] = ValueAnimatorBuilder { }

.withDurationMs(ms)

.withEasing(Easings::createEaseOut())

.withValueChangedCallback([this, idx](float v) {

lineAlpha[idx] = makeAnimationLimits(lineAlpha[idx], lineTargetAlpha[idx]).lerp(v);

auto const lineArea = cnv->editor->nvgSurface.getLocalArea(cnv, Rectangle<int>(lines[idx].getStart(), lines[idx].getEnd()).expanded(2));

cnv->editor->nvgSurface.invalidateArea(lineArea);

})

.build();

updater.addAnimator(lineAnimators[idx], [this, idx]() {

lines[idx] = { };

});

lineAnimators[idx].start();

}

void ObjectGrid::settingsChanged(String const& name, var const& value)

{

if (name == "grid_type") {

gridType = static_cast<int>(value);

}

if (name == "grid_enabled") {

gridEnabled = static_cast<int>(value);

}

if (name == "grid_size") {

gridSize = static_cast<int>(value);

}

}

Point<int> ObjectGrid::performMove(Object* toDrag, Point<int> dragOffset)

{

if (ModifierKeys::getCurrentModifiers().isShiftDown() || gridType == 0 || !gridEnabled) {

clearIndicators(true);

return dragOffset;

}

auto [snapGrid, snapEdges, snapCentres] = std::tuple<bool, bool, bool> { gridType & 1, gridType & 2, gridType & 4 };

auto snappable = getSnappableObjects(toDrag);

Point<int> distance;

Line<int> verticalIndicator, horizontalIndicator;

bool connectionSnapped = false;

// Check for straight connections to snap to

if (snapEdges) {

for (auto* connection : toDrag->getConnections()) {

if (connection->inobj == toDrag) {

if (!snappable.contains(connection->outobj))

continue;

auto outletBounds = connection->outobj->getBounds() + connection->outlet->getPosition();

auto inletBounds = connection->inobj->originalBounds + dragOffset + connection->inlet->getPosition();

outletBounds = outletBounds.withSize(12, 12);

inletBounds = inletBounds.withSize(8, 8);

if (outletBounds.getY() > inletBounds.getY())

continue;

auto snapDistance = inletBounds.getX() - outletBounds.getX();

if (std::abs(snapDistance) < connectionTolerance) {

distance.x = -snapDistance;

horizontalIndicator = { outletBounds.getX() - 2, outletBounds.getBottom() + 3, outletBounds.getX() - 2, connection->inobj->getY() - 3 };

connectionSnapped = true;

}

break;

}

if (connection->outobj == toDrag) {

if (!snappable.contains(connection->inobj))

continue;

auto inletBounds = connection->inobj->getBounds() + connection->inlet->getPosition();

auto outletBounds = connection->outobj->originalBounds + dragOffset + connection->outlet->getPosition();

outletBounds = outletBounds.withSize(12, 12);

inletBounds = inletBounds.withSize(8, 8);

if (outletBounds.getY() > inletBounds.getY())

continue;

auto snapDistance = inletBounds.getX() - outletBounds.getX();

if (std::abs(snapDistance) < connectionTolerance) {

distance.x = snapDistance;

horizontalIndicator = { inletBounds.getX() - 2, connection->outobj->getBottom() + 3, inletBounds.getX() - 2, inletBounds.getY() - 3 };

connectionSnapped = true;

}

break;

}

}

}

auto desiredBounds = toDrag->originalBounds.reduced(Object::margin) + dragOffset;

bool objectSnapped = false;

// Check for relative object snap

for (auto* object : snappable) {

auto b1 = object->getBounds().reduced(Object::margin);

auto topDiff = b1.getY() - desiredBounds.getY();

auto bottomDiff = b1.getBottom() - desiredBounds.getBottom();

auto leftDiff = b1.getX() - desiredBounds.getX();

auto rightDiff = b1.getRight() - desiredBounds.getRight();

auto vCentreDiff = b1.getCentreY() - desiredBounds.getCentreY();

auto hCentreDiff = b1.getCentreX() - desiredBounds.getCentreX();

if (snapEdges && std::abs(topDiff) < objectTolerance) {

verticalIndicator = getObjectIndicatorLine(Top, b1, desiredBounds.withY(b1.getY()));

distance.y = topDiff;

objectSnapped = true;

} else if (snapEdges && std::abs(bottomDiff) < objectTolerance) {

verticalIndicator = getObjectIndicatorLine(Bottom, b1, desiredBounds.withBottom(b1.getBottom()));

distance.y = bottomDiff;

objectSnapped = true;

} else if (snapCentres && std::abs(vCentreDiff) < objectTolerance) {

verticalIndicator = getObjectIndicatorLine(VerticalCentre, b1, desiredBounds.withCentre({ desiredBounds.getCentreX(), b1.getCentreY() }));

distance.y = vCentreDiff;

objectSnapped = true;

}

// Skip horizontal snap if we've already found a connection snap

if (!connectionSnapped) {

if (snapEdges && std::abs(leftDiff) < objectTolerance) {

horizontalIndicator = getObjectIndicatorLine(Left, b1, desiredBounds.withX(b1.getX()));

distance.x = leftDiff;

objectSnapped = true;

} else if (snapEdges && std::abs(rightDiff) < objectTolerance) {

horizontalIndicator = getObjectIndicatorLine(Right, b1, desiredBounds.withRight(b1.getRight()));

distance.x = rightDiff;

objectSnapped = true;

} else if (snapCentres && std::abs(hCentreDiff) < objectTolerance) {

horizontalIndicator = getObjectIndicatorLine(HorizontalCentre, b1, desiredBounds.withCentre({ b1.getCentreX(), desiredBounds.getCentreY() }));

distance.x = hCentreDiff;

objectSnapped = true;

}

}

}

// Snap to absolute grid

if (snapGrid && !objectSnapped && !connectionSnapped) {

Point<int> newPos = toDrag->originalBounds.reduced(Object::margin).getPosition() + dragOffset;

newPos.setX(floor(newPos.getX() / static_cast<float>(gridSize) + 1) * gridSize);

newPos.x += toDrag->cnv->canvasOrigin.x % gridSize - 1;

dragOffset.x = newPos.x - toDrag->originalBounds.reduced(Object::margin).getX() - gridSize;

newPos.setY(floor(newPos.getY() / static_cast<float>(gridSize) + 1) * gridSize);

newPos.y += toDrag->cnv->canvasOrigin.y % gridSize - 1;

dragOffset.y = newPos.y - toDrag->originalBounds.reduced(Object::margin).getY() - gridSize;

}

if (objectSnapped || connectionSnapped) {

setIndicator(0, verticalIndicator);

setIndicator(1, horizontalIndicator);

return dragOffset + distance;

}

clearIndicators(true);

return dragOffset;

}

Point<int> ObjectGrid::performResize(Object* toDrag, Point<int> dragOffset, Rectangle<int> newResizeBounds)

{

if (ModifierKeys::getCurrentModifiers().isShiftDown() || gridType == 0 || !gridEnabled) {

clearIndicators(true);

return dragOffset;

}

auto [snapGrid, snapEdges, snapCentres] = std::tuple<bool, bool, bool> { gridType & 1, gridType & 2, gridType & 4 };

auto limits = [&]() -> Rectangle<int> {

return { Canvas::infiniteCanvasSize, Canvas::infiniteCanvasSize };

}();

auto resizeZone = toDrag->resizeZone;

auto isDraggingTop = resizeZone.isDraggingTopEdge();

auto isDraggingBottom = resizeZone.isDraggingBottomEdge();

auto isDraggingLeft = resizeZone.isDraggingLeftEdge();

auto isDraggingRight = resizeZone.isDraggingRightEdge();

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

// Not great that we need to do this, but otherwise we don't really know the object bounds for sure

constrainer->checkBounds(newResizeBounds, toDrag->originalBounds, limits,

isDraggingTop, isDraggingLeft, isDraggingBottom, isDraggingRight);

}

// Returns non-zero if the object has a fixed ratio

auto ratio = 0.0;

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

ratio = constrainer->getFixedAspectRatio();

}

auto desiredBounds = newResizeBounds.reduced(Object::margin);

auto actualBounds = toDrag->getBounds().reduced(Object::margin);

if (snapEdges) {

Line<int> verticalIndicator, horizontalIndicator;

Point<int> distance;

bool snapped = false;

// Check for objects to relative snap to

for (auto* object : getSnappableObjects(toDrag)) {

auto b1 = object->getBounds().reduced(Object::margin);

float topDiff = b1.getY() - desiredBounds.getY();

float bottomDiff = b1.getBottom() - desiredBounds.getBottom();

float leftDiff = b1.getX() - desiredBounds.getX();

float rightDiff = b1.getRight() - desiredBounds.getRight();

if (isDraggingTop && std::abs(topDiff) < objectTolerance) {

verticalIndicator = getObjectIndicatorLine(Top, b1, actualBounds.withY(b1.getY()));

if (ratio != 0) {

if (isDraggingRight)

distance.x = round(-topDiff * ratio);

if (isDraggingLeft)

distance.x = round(topDiff * ratio);

}

distance.y = topDiff;

snapped = true;

} else if (isDraggingBottom && std::abs(bottomDiff) < objectTolerance) {

verticalIndicator = getObjectIndicatorLine(Bottom, b1, actualBounds.withBottom(b1.getBottom()));

if (ratio != 0) {

if (isDraggingRight)

distance.x = round(bottomDiff * ratio);

if (isDraggingLeft)

distance.x = round(-bottomDiff * ratio);

}

distance.y = bottomDiff;

snapped = true;

}

if (approximatelyEqual(ratio, 0.0) || !snapped) {

if (isDraggingLeft && std::abs(leftDiff) < objectTolerance) {

horizontalIndicator = getObjectIndicatorLine(Left, b1, actualBounds.withX(b1.getX()));

if (ratio != 0) {

if (isDraggingBottom)

distance.y = round(-leftDiff / ratio);

if (isDraggingTop)

distance.y = round(leftDiff / ratio);

}

distance.x = leftDiff;

snapped = true;

} else if (isDraggingRight && std::abs(rightDiff) < objectTolerance) {

horizontalIndicator = getObjectIndicatorLine(Right, b1, actualBounds.withRight(b1.getRight()));

if (ratio != 0) {

if (isDraggingBottom)

distance.y = round(rightDiff / ratio);

if (isDraggingTop)

distance.y = round(-rightDiff / ratio);

}

distance.x = rightDiff;

snapped = true;

}

}

}

if (snapped) {

setIndicator(0, verticalIndicator);

setIndicator(1, horizontalIndicator);

return dragOffset + distance;

}

}

if (snapGrid) {

Point<int> newPosTopLeft = toDrag->originalBounds.reduced(Object::margin).getTopLeft() + dragOffset;

Point<int> newPosBotRight = toDrag->originalBounds.reduced(Object::margin).getBottomRight() + dragOffset;

if (isDraggingTop) {

auto newY = roundToInt(newPosTopLeft.getY() / gridSize + 1) * gridSize;

dragOffset.y = newY - toDrag->originalBounds.reduced(Object::margin).getY() - gridSize;

dragOffset.y += toDrag->cnv->canvasOrigin.y % gridSize + 1;

}

if (isDraggingBottom) {

auto newY = roundToInt(newPosBotRight.getY() / gridSize + 1) * gridSize;

dragOffset.y = newY - toDrag->originalBounds.reduced(Object::margin).getBottom() - gridSize;

dragOffset.y += toDrag->cnv->canvasOrigin.y % gridSize + 1;

}

if (isDraggingLeft) {

auto newX = roundToInt(newPosTopLeft.getX() / gridSize + 1) * gridSize;

dragOffset.x = newX - toDrag->originalBounds.reduced(Object::margin).getX() - gridSize;

dragOffset.x += toDrag->cnv->canvasOrigin.x % gridSize + 1;

}

if (isDraggingRight) {

auto newX = roundToInt(newPosBotRight.getX() / gridSize + 1) * gridSize;

dragOffset.x = newX - toDrag->originalBounds.reduced(Object::margin).getRight() - gridSize;

dragOffset.x += toDrag->cnv->canvasOrigin.x % gridSize + 1;

}

}

clearIndicators(true);

return dragOffset;

}

// Calculates the path of the grid lines

Line<int> ObjectGrid::getObjectIndicatorLine(Side const side, Rectangle<int> b1, Rectangle<int> b2)

{

// When snapping from both sides, we need to shorten the lines to prevent artifacts (because the line will follow mouse position on the opposite axis)

if (side == Top || side == Bottom || side == VerticalCentre) {

b2 = b2.reduced(2, 0);

} else {

b2 = b2.reduced(0, 2);

}

switch (side) {

case Left: {

if (b1.getY() > b2.getY()) {

return { b2.getTopLeft(), b1.getBottomLeft() };

}

return { b1.getTopLeft(), b2.getBottomLeft() };

}

case Right: {

if (b1.getY() > b2.getY()) {

return { b2.getTopRight(), b1.getBottomRight() };

}

return { b1.getTopRight(), b2.getBottomRight() };

}

case Top: {

if (b1.getX() > b2.getX()) {

return { b2.getTopLeft(), b1.getTopRight() };

}

return { b1.getTopLeft(), b2.getTopRight() };

}

case Bottom: {

if (b1.getX() > b2.getX()) {

return { b2.getBottomLeft(), b1.getBottomRight() };

}

return { b1.getBottomLeft(), b2.getBottomRight() };

}

case VerticalCentre: {

if (b1.getX() > b2.getX()) {

return { b2.getX(), b2.getCentreY(), b1.getRight(), b1.getCentreY() };

}

return { b1.getX(), b1.getCentreY(), b2.getRight(), b2.getCentreY() };

}

case HorizontalCentre: {

if (b1.getY() > b2.getY()) {

return { b2.getCentreX(), b2.getY(), b1.getCentreX(), b1.getBottom() };

}

return { b1.getCentreX(), b1.getY(), b2.getCentreX(), b2.getBottom() };

}

}

return { };

}

void ObjectGrid::clearIndicators(bool const fast)

{

float const lineFadeMs = fast ? 50 : 300;

if (lineTargetAlpha[0] != 0.0f || lineTargetAlpha[1] != 0.0f) {

startLineFadeAnimation(0, lineFadeMs, 0.0f);

startLineFadeAnimation(1, lineFadeMs, 0.0f);

}

}

void ObjectGrid::setIndicator(int const idx, Line<int> const line)

{

auto const lineIsEmpty = line.getLength() == 0;

if (lineIsEmpty && line != lines[idx]) {

startLineFadeAnimation(idx, 50.f, 0.0f);

} else if (line != lines[idx]) {

lineTargetAlpha[idx] = 1.0f;

lineAlpha[idx] = 1.0f;

auto lineArea = cnv->editor->nvgSurface.getLocalArea(cnv, Rectangle<int>(line.getStart(), line.getEnd()).expanded(2));

if (lines[idx].getLength() != 0) {

auto const oldLineArea = cnv->editor->nvgSurface.getLocalArea(cnv, Rectangle<int>(lines[idx].getStart(), lines[idx].getEnd()).expanded(2));

lineArea = lineArea.getUnion(oldLineArea);

}

cnv->editor->nvgSurface.invalidateArea(lineArea);

lines[idx] = line;

}

}

void ObjectGrid::render(NVGcontext* nvg)

{

if (lines[0].getLength() != 0) {

nvgStrokeColor(nvg, nvgColour(PlugDataColours::gridLineColour.withAlpha(lineAlpha[0])));

nvgStrokeWidth(nvg, 1.0f);

nvgBeginPath(nvg);

nvgMoveTo(nvg, lines[0].getStartX(), lines[0].getStartY());

nvgLineTo(nvg, lines[0].getEndX(), lines[0].getEndY());

nvgStroke(nvg);

}

if (lines[1].getLength() != 0) {

nvgStrokeColor(nvg, nvgColour(PlugDataColours::gridLineColour.withAlpha(lineAlpha[1])));

nvgStrokeWidth(nvg, 1.0f);

nvgBeginPath(nvg);

nvgMoveTo(nvg, lines[1].getStartX(), lines[1].getStartY());

nvgLineTo(nvg, lines[1].getEndX(), lines[1].getEndY());

nvgStroke(nvg);

}

}