wehub-resource-sync
1774 lines
69 KiB
C#
1774 lines
69 KiB
C#
#nullable enable
|
|
|
|
using System.Diagnostics;
|
|
using ImGuiNET;
|
|
using T3.Core.DataTypes.Vector;
|
|
using T3.Core.Utils;
|
|
using T3.Core.Operator;
|
|
using T3.Editor.Gui.Interaction;
|
|
using T3.Editor.Gui.Interaction.Snapping;
|
|
using T3.Editor.Gui.MagGraph.Model;
|
|
using T3.Editor.Gui.MagGraph.States;
|
|
using T3.Editor.Gui.Styling;
|
|
using T3.Editor.Gui.UiHelpers;
|
|
using T3.Editor.UiModel;
|
|
using T3.Editor.UiModel.Commands.Graph;
|
|
using T3.Editor.UiModel.InputsAndTypes;
|
|
using T3.Editor.UiModel.Modification;
|
|
using T3.Editor.UiModel.ProjectHandling;
|
|
using T3.Editor.UiModel.Selection;
|
|
using MagGraphView = T3.Editor.Gui.MagGraph.Ui.MagGraphView;
|
|
using Vector2 = System.Numerics.Vector2;
|
|
|
|
// ReSharper disable ForeachCanBePartlyConvertedToQueryUsingAnotherGetEnumerator
|
|
// ReSharper disable UseWithExpressionToCopyStruct
|
|
|
|
namespace T3.Editor.Gui.MagGraph.Interaction;
|
|
|
|
/// <summary>
|
|
/// Provides functions for moving, snapping, connecting, insertion etc. of operators. It controlled by the <see cref="StateMachine{T}"/>
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Things would be slightly more efficient if this would would use SnapGraphItems. However this would
|
|
/// prevent us from reusing fence selection. Enforcing this to be used for dragging inputs and outputs
|
|
/// makes this class unnecessarily complex.
|
|
/// </remarks>
|
|
internal sealed partial class MagItemMovement
|
|
{
|
|
internal MagItemMovement(GraphUiContext graphUiContext, MagGraphView magGraphView, MagGraphLayout layout, NodeSelection nodeSelection)
|
|
{
|
|
_view = magGraphView;
|
|
_layout = layout;
|
|
_nodeSelection = nodeSelection;
|
|
_context = graphUiContext;
|
|
}
|
|
|
|
private readonly GraphUiContext _context;
|
|
|
|
internal void PrepareFrame(GraphUiContext context)
|
|
{
|
|
//PrepareDragInteraction();
|
|
_snapHandlerX.DrawSnapIndicator(context.View, UiColors.StatusActivated.Fade(0.3f));
|
|
}
|
|
|
|
internal void PrepareDragInteraction()
|
|
{
|
|
UpdateConnectionsToDraggedItems(DraggedItems); // Sadly structure might change during drag...
|
|
UpdateSnappedConnectionsToDraggedItems();
|
|
}
|
|
|
|
internal void CompleteDragOperation(GraphUiContext context)
|
|
{
|
|
Debug.Assert(context.MacroCommand != null);
|
|
if (context.MacroCommand != null)
|
|
{
|
|
context.MoveElementsCommand?.StoreCurrentValues();
|
|
CompleteSlowGrow(context);
|
|
GrowSectionsToFitDisplacedMembers(context);
|
|
context.CompleteMacroCommand();
|
|
|
|
// Section ownership is re-derived from geometry on the layout refresh
|
|
_layout.FlagStructureAsChanged();
|
|
}
|
|
|
|
if (!InputPicking.TryInitializeInputSelectionPickerForDraggedItem(context))
|
|
Reset();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dragging ops slowly against their section's bottom/right border makes the border
|
|
/// yield. The speed test only decides the initial engagement — once the border
|
|
/// yielded, it follows the dragged ops continuously, so the growth is smooth instead
|
|
/// of stuttering with the speed hovering around the threshold. Pulling the ops fully
|
|
/// back inside (or holding Shift) releases the latch, and the next border contact
|
|
/// decides afresh. Disabled while the frame is selected, or when
|
|
/// <see cref="UserSettings.ConfigData.SectionSlowResizeSpeed"/> is 0.
|
|
/// </summary>
|
|
private void TrySlowGrowSection(GraphUiContext context)
|
|
{
|
|
var unlockSpeed = UserSettings.Config.SectionSlowResizeSpeed;
|
|
if (unlockSpeed <= 0 || _slowGrowSectionId == Guid.Empty || DraggedItems.Count == 0)
|
|
return;
|
|
|
|
var io = ImGui.GetIO();
|
|
var speed = io.MouseDelta.Length() / MathF.Max(io.DeltaTime, 0.0001f) / T3Ui.UiScaleFactor;
|
|
_dampedDragSpeed = MathUtils.Lerp(_dampedDragSpeed, speed, 0.3f);
|
|
|
|
var symbolUi = context.CompositionInstance.GetSymbolUi();
|
|
if (!symbolUi.Sections.TryGetValue(_slowGrowSectionId, out var section)
|
|
|| section.Collapsed || section.IsHiddenInCollapsedSection
|
|
|| context.Selector.IsNodeSelected(section))
|
|
return;
|
|
|
|
var draggedBounds = MagGraphItem.GetItemsBounds(DraggedItems);
|
|
var boundsMin = section.PosOnCanvas;
|
|
var boundsMax = section.PosOnCanvas + section.Size;
|
|
|
|
// Border contact requires overlapping the frame on the other axis too - an op
|
|
// dragged past the frame's corner is outside, not pressing against the border
|
|
var overlapsVertically = draggedBounds.Min.Y < boundsMax.Y && draggedBounds.Max.Y > boundsMin.Y;
|
|
var overlapsHorizontally = draggedBounds.Min.X < boundsMax.X && draggedBounds.Max.X > boundsMin.X;
|
|
|
|
var touchesRight = overlapsVertically && draggedBounds.Max.X > boundsMax.X && draggedBounds.Min.X < boundsMax.X;
|
|
var touchesBottom = overlapsHorizontally && draggedBounds.Max.Y > boundsMax.Y && draggedBounds.Min.Y < boundsMax.Y;
|
|
|
|
if (io.KeyShift)
|
|
{
|
|
_slowGrowEngaged = false;
|
|
return;
|
|
}
|
|
|
|
if (!_slowGrowEngaged)
|
|
{
|
|
// Fully back inside? The next contact decides afresh.
|
|
if (!touchesRight && !touchesBottom)
|
|
return;
|
|
|
|
if (_dampedDragSpeed > unlockSpeed)
|
|
return;
|
|
|
|
_slowGrowEngaged = true;
|
|
}
|
|
|
|
// Follow the dragged ops continuously while engaged
|
|
var newMax = boundsMax;
|
|
if (touchesRight)
|
|
newMax.X = draggedBounds.Max.X + SectionTree.ContentPadding.X;
|
|
|
|
if (touchesBottom)
|
|
newMax.Y = draggedBounds.Max.Y + SectionTree.ContentPadding.Y;
|
|
|
|
if (draggedBounds.Max.X <= boundsMax.X && draggedBounds.Max.Y <= boundsMax.Y)
|
|
{
|
|
// Ops returned fully inside - release the latch (the frame keeps its size)
|
|
_slowGrowEngaged = false;
|
|
return;
|
|
}
|
|
|
|
if (newMax == boundsMax)
|
|
return;
|
|
|
|
if (_slowGrowCommand == null)
|
|
{
|
|
_slowGrowCommand = new ModifyCanvasElementsCommand(symbolUi, [section], context.Selector);
|
|
_growPushPreview.Engage(symbolUi, section, context.Selector);
|
|
}
|
|
|
|
_slowGrewX |= newMax.X > boundsMax.X;
|
|
_slowGrewY |= newMax.Y > boundsMax.Y;
|
|
section.Size = newMax - section.PosOnCanvas;
|
|
|
|
// Push neighbors ahead of the growing border right away - leaving overlaps
|
|
// unresolved until release would let ownership derivation flip memberships mid-drag
|
|
_growPushPreview.Update(section, pushDown: _slowGrewY, pushRight: _slowGrewX);
|
|
_layout.FlagStructureAsChanged();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Folds the accumulated slow-grow resize into the drag's MacroCommand and pushes
|
|
/// neighbors out of the grown bounds.
|
|
/// </summary>
|
|
private void CompleteSlowGrow(GraphUiContext context)
|
|
{
|
|
if (_slowGrowCommand == null)
|
|
{
|
|
_slowGrowSectionId = Guid.Empty;
|
|
return;
|
|
}
|
|
|
|
_slowGrowCommand.StoreCurrentValues();
|
|
context.MacroCommand!.AddExecutedCommandForUndo(_slowGrowCommand);
|
|
_growPushPreview.Complete(context.MacroCommand);
|
|
|
|
// Sibling overlaps are already resolved by the live preview; this settles
|
|
// ancestor growth for nested frames
|
|
var symbolUi = context.CompositionInstance.GetSymbolUi();
|
|
if (symbolUi.Sections.TryGetValue(_slowGrowSectionId, out var grownSection))
|
|
{
|
|
// Only resolve along axes that actually grew - resolving the other axis would
|
|
// "fix" remaining overlaps by flinging neighbors sideways
|
|
var bounds = ImRect.RectWithSize(grownSection.PosOnCanvas, grownSection.Size);
|
|
if (_slowGrewY)
|
|
SectionTree.ResolveBoundsExpansion(symbolUi, grownSection, bounds, Vector2.UnitY, context.MacroCommand, context.Selector);
|
|
|
|
if (_slowGrewX)
|
|
SectionTree.ResolveBoundsExpansion(symbolUi, grownSection, bounds, Vector2.UnitX, context.MacroCommand, context.Selector);
|
|
}
|
|
|
|
_slowGrowCommand = null;
|
|
_slowGrowSectionId = Guid.Empty;
|
|
}
|
|
|
|
private Guid _slowGrowSectionId;
|
|
private ModifyCanvasElementsCommand? _slowGrowCommand;
|
|
private readonly SectionPushPreview _growPushPreview = new();
|
|
private bool _slowGrowEngaged;
|
|
private bool _slowGrewX;
|
|
private bool _slowGrewY;
|
|
private float _dampedDragSpeed;
|
|
|
|
/// <summary>
|
|
/// Splice-inserting into a stack pushes the ops below/right of the insertion — when such
|
|
/// displaced members cross their section's bottom or right border, the section grows to
|
|
/// keep them and neighboring frames get pushed out of the claimed area, all folded into
|
|
/// the drag's MacroCommand. Dragged items themselves are ignored, so deliberately
|
|
/// dragging an op out of a frame never grows it.
|
|
/// </summary>
|
|
private void GrowSectionsToFitDisplacedMembers(GraphUiContext context)
|
|
{
|
|
Debug.Assert(context.MacroCommand != null);
|
|
var symbolUi = context.CompositionInstance.GetSymbolUi();
|
|
if (symbolUi.Sections.Count == 0)
|
|
return;
|
|
|
|
_draggedChildIds.Clear();
|
|
foreach (var item in DraggedItems)
|
|
{
|
|
if (item.ChildUi != null)
|
|
_draggedChildIds.Add(item.ChildUi.Id);
|
|
}
|
|
|
|
foreach (var section in symbolUi.Sections.Values)
|
|
{
|
|
if (section.Collapsed || section.IsHiddenInCollapsedSection)
|
|
continue;
|
|
|
|
GrowSectionToFitContent(context, symbolUi, section, _draggedChildIds);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Grows a frame (bottom/right) so its member ops stay inside, pushing siblings and
|
|
/// growing ancestors via the bounds-expansion cascade. Folds into the interaction's
|
|
/// MacroCommand. Ops in <paramref name="excludedChildIds"/> are ignored, so a
|
|
/// deliberate drag out of the frame never grows it.
|
|
/// </summary>
|
|
private static void GrowSectionToFitContent(GraphUiContext context, SymbolUi symbolUi, Section section, HashSet<Guid>? excludedChildIds)
|
|
{
|
|
Debug.Assert(context.MacroCommand != null);
|
|
|
|
var contentMax = new Vector2(float.NegativeInfinity, float.NegativeInfinity);
|
|
var hasContent = false;
|
|
foreach (var childUi in symbolUi.ChildUis.Values)
|
|
{
|
|
if (childUi.SectionId != section.Id)
|
|
continue;
|
|
|
|
if (excludedChildIds != null && excludedChildIds.Contains(childUi.Id))
|
|
continue;
|
|
|
|
contentMax = Vector2.Max(contentMax, childUi.PosOnCanvas + childUi.Size);
|
|
hasContent = true;
|
|
}
|
|
|
|
if (!hasContent)
|
|
return;
|
|
|
|
var boundsMax = section.PosOnCanvas + section.Size;
|
|
var requiredMax = Vector2.Max(boundsMax, contentMax + SectionTree.ContentPadding);
|
|
var grewX = requiredMax.X > boundsMax.X + 0.5f;
|
|
var grewY = requiredMax.Y > boundsMax.Y + 0.5f;
|
|
if (!grewX && !grewY)
|
|
return;
|
|
|
|
var resizeCommand = new ModifyCanvasElementsCommand(symbolUi, [section], context.Selector);
|
|
section.Size = requiredMax - section.PosOnCanvas;
|
|
resizeCommand.StoreCurrentValues();
|
|
context.MacroCommand!.AddExecutedCommandForUndo(resizeCommand);
|
|
|
|
var newBounds = ImRect.RectWithSize(section.PosOnCanvas, section.Size);
|
|
if (grewY)
|
|
SectionTree.ResolveBoundsExpansion(symbolUi, section, newBounds, Vector2.UnitY, context.MacroCommand, context.Selector);
|
|
if (grewX)
|
|
SectionTree.ResolveBoundsExpansion(symbolUi, section, newBounds, Vector2.UnitX, context.MacroCommand, context.Selector);
|
|
}
|
|
|
|
private static readonly HashSet<Guid> _draggedChildIds = [];
|
|
|
|
/// <summary>
|
|
/// Reset to avoid accidental dragging of previous elements
|
|
/// </summary>
|
|
internal void StopDragOperation()
|
|
{
|
|
_lastAppliedOffset = Vector2.Zero;
|
|
SpliceSets.Clear();
|
|
DraggedItems.Clear();
|
|
|
|
// If the drag ended without CompleteDragOperation, take the uncommitted
|
|
// slow-grow preview back
|
|
if (_slowGrowCommand != null)
|
|
{
|
|
_slowGrowCommand.Undo();
|
|
_slowGrowCommand = null;
|
|
}
|
|
|
|
_growPushPreview.CancelAndReset();
|
|
_slowGrowSectionId = Guid.Empty;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This will reset the state including all highlights and indicators
|
|
/// </summary>
|
|
internal void Reset()
|
|
{
|
|
// TODO: should be done by states...
|
|
_context.ActiveSourceItem = null;
|
|
_context.DraggedPrimaryOutputType = null;
|
|
|
|
DraggedItems.Clear();
|
|
_shakeDetector.ResetShaking();
|
|
}
|
|
|
|
internal static void SelectActiveItem(GraphUiContext context)
|
|
{
|
|
var item = context.ActiveItem;
|
|
if (item == null)
|
|
return;
|
|
|
|
var append = ImGui.GetIO().KeyShift;
|
|
|
|
if (context.Selector.IsNodeSelected(item))
|
|
{
|
|
if (append)
|
|
{
|
|
context.Selector.DeselectNode(item, item.Instance);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (append)
|
|
{
|
|
item.AddToSelection(context.Selector);
|
|
}
|
|
else
|
|
{
|
|
item.Select(context.Selector);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void UpdateDragging(GraphUiContext context)
|
|
{
|
|
if (!T3Ui.IsCurrentlySaving && _shakeDetector.TestDragForShake(ImGui.GetMousePos()))
|
|
{
|
|
_shakeDetector.ResetShaking();
|
|
if (HandleShakeDisconnect(context))
|
|
{
|
|
_layout.FlagStructureAsChanged();
|
|
return;
|
|
}
|
|
}
|
|
|
|
var snappingChanged = HandleSnappedDragging(context);
|
|
|
|
TrySlowGrowSection(context);
|
|
|
|
if (!snappingChanged)
|
|
return;
|
|
|
|
_layout.FlagStructureAsChanged();
|
|
|
|
HandleUnsnapAndCollapse(context);
|
|
|
|
if (!_snapping.IsSnapped)
|
|
return;
|
|
|
|
if (_snapping.IsInsertion)
|
|
{
|
|
TrySplitInsert(context);
|
|
}
|
|
else
|
|
{
|
|
TryCreateNewConnectionFromSnap(context);
|
|
}
|
|
}
|
|
|
|
private bool HandleShakeDisconnect(GraphUiContext context)
|
|
{
|
|
//Log.Debug("Shake it!");
|
|
Debug.Assert(context.MacroCommand != null);
|
|
if (_connectionsToDraggedItems.Count == 0)
|
|
return false;
|
|
|
|
NodeActions.DisconnectDraggedNodes(context.CompositionInstance, DraggedItems.Select(i => i.Selectable).ToList());
|
|
|
|
// foreach (var c in _borderConnections)
|
|
// {
|
|
// context.MacroCommand.AddAndExecCommand(new DeleteConnectionCommand(context.CompositionOp.Symbol, c.AsSymbolConnection(), 0));
|
|
// }
|
|
|
|
_layout.FlagStructureAsChanged();
|
|
return true;
|
|
}
|
|
|
|
internal static void UpdateLongPressIndicator(float longTapProgress)
|
|
{
|
|
var dl = ImGui.GetWindowDrawList();
|
|
dl.AddCircle(ImGui.GetMousePos(), 100 * (1 - longTapProgress), Color.White.Fade(MathF.Pow(longTapProgress, 3)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update dragged items and use anchor definitions to identify and use potential snap targets
|
|
/// </summary>
|
|
private bool HandleSnappedDragging(GraphUiContext context)
|
|
{
|
|
var dl = ImGui.GetWindowDrawList();
|
|
|
|
if (!_hasDragged)
|
|
{
|
|
_dragStartPosInOpOnCanvas = context.View.InverseTransformPositionFloat(ImGui.GetMousePos());
|
|
_hasDragged = true;
|
|
|
|
// Remember the frame the drag started in for the slow-grow interaction
|
|
_slowGrowSectionId = Guid.Empty;
|
|
_slowGrowCommand = null;
|
|
_growPushPreview.Reset();
|
|
_slowGrowEngaged = false;
|
|
_slowGrewX = false;
|
|
_slowGrewY = false;
|
|
_dampedDragSpeed = UserSettings.Config.SectionSlowResizeSpeed * 3; // start above unlock so a fresh grab doesn't engage instantly
|
|
|
|
// Rearranging a selection that includes frames must never auto-grow or push -
|
|
// that's deliberate layout work, not ops pressing against a border
|
|
var selectionIncludesSection = false;
|
|
foreach (var node in _nodeSelection.Selection)
|
|
{
|
|
if (node is not Section)
|
|
continue;
|
|
|
|
selectionIncludesSection = true;
|
|
break;
|
|
}
|
|
|
|
if (!selectionIncludesSection)
|
|
{
|
|
foreach (var item in DraggedItems)
|
|
{
|
|
if (item.ChildUi == null || item.ChildUi.SectionId == Guid.Empty)
|
|
continue;
|
|
|
|
_slowGrowSectionId = item.ChildUi.SectionId;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
var mousePosOnCanvas = context.View.InverseTransformPositionFloat(ImGui.GetMousePos());
|
|
var requestedDeltaOnCanvas = mousePosOnCanvas - _dragStartPosInOpOnCanvas;
|
|
|
|
var dragExtend = MagGraphItem.GetItemsBounds(DraggedItems);
|
|
dragExtend.Expand(SnapThreshold * context.View.Scale.X);
|
|
|
|
if (_view.ShowDebug)
|
|
{
|
|
dl.AddCircle(_view.TransformPosition(_dragStartPosInOpOnCanvas), 10, Color.Blue);
|
|
|
|
dl.AddLine(_view.TransformPosition(_dragStartPosInOpOnCanvas),
|
|
_view.TransformPosition(_dragStartPosInOpOnCanvas + requestedDeltaOnCanvas), Color.Blue);
|
|
|
|
dl.AddRect(_view.TransformPosition(dragExtend.Min),
|
|
_view.TransformPosition(dragExtend.Max),
|
|
Color.Green.Fade(0.1f));
|
|
}
|
|
|
|
var overlappingItems = new List<MagGraphItem>();
|
|
|
|
foreach (var otherItem in _layout.Items.Values)
|
|
{
|
|
if (DraggedItems.Contains(otherItem) || !dragExtend.Overlaps(otherItem.Area))
|
|
continue;
|
|
|
|
overlappingItems.Add(otherItem);
|
|
}
|
|
|
|
// Move back to non-snapped position
|
|
foreach (var n in DraggedItems)
|
|
{
|
|
n.PosOnCanvas -= _lastAppliedOffset; // Move to position
|
|
n.PosOnCanvas += requestedDeltaOnCanvas; // Move to request position
|
|
}
|
|
|
|
// Only drag selected sections along when the drag started from the selection itself,
|
|
// not when dragging an unselected snapped group.
|
|
if (_draggedItemsFromSelection && DraggedItems.Count != _context.Selector.Selection.Count)
|
|
{
|
|
foreach (var a in _context.Selector.Selection)
|
|
{
|
|
if (a is not Section)
|
|
continue;
|
|
|
|
a.PosOnCanvas -= _lastAppliedOffset; // Move to position
|
|
a.PosOnCanvas += requestedDeltaOnCanvas; // Move to request position
|
|
}
|
|
}
|
|
|
|
|
|
_lastAppliedOffset = requestedDeltaOnCanvas;
|
|
_snapping.Reset();
|
|
|
|
foreach (var ip in SpliceSets)
|
|
{
|
|
var insertionAnchorItem = DraggedItems.FirstOrDefault(i => i.Id == ip.InputItemId);
|
|
if (insertionAnchorItem == null)
|
|
continue;
|
|
|
|
foreach (var otherItem in overlappingItems)
|
|
{
|
|
_snapping.TestItemsForInsertion(otherItem, insertionAnchorItem, ip, _view);
|
|
}
|
|
}
|
|
|
|
foreach (var otherItem in overlappingItems)
|
|
{
|
|
foreach (var draggedItem in DraggedItems)
|
|
{
|
|
_snapping.TestItemsForSnap(otherItem, draggedItem, false, _view);
|
|
_snapping.TestItemsForSnap(draggedItem, otherItem, true, _view);
|
|
}
|
|
}
|
|
|
|
// Highlight best distance
|
|
if (_view.ShowDebug && _snapping.BestDistance < 500)
|
|
{
|
|
var p1 = _view.TransformPosition(_snapping.OutAnchorPos);
|
|
var p2 = _view.TransformPosition(_snapping.InputAnchorPos);
|
|
dl.AddLine(p1, p2, UiColors.ForegroundFull.Fade(0.1f), 6);
|
|
}
|
|
|
|
// Snapped
|
|
var snapPositionChanged = false;
|
|
if (_snapping.IsSnapped)
|
|
{
|
|
var bestSnapDelta = _snapping.Reverse
|
|
? _snapping.InputAnchorPos - _snapping.OutAnchorPos
|
|
: _snapping.OutAnchorPos - _snapping.InputAnchorPos;
|
|
|
|
// var snapTargetPos = _snapping.Reverse
|
|
// ? _snapping.InputAnchorPos
|
|
// : _snapping.OutAnchorPos;
|
|
|
|
var snapPos = mousePosOnCanvas + bestSnapDelta;
|
|
|
|
// dl.AddLine(_canvas.TransformPosition(mousePosOnCanvas),
|
|
// context.Canvas.TransformPosition(mousePosOnCanvas) + _canvas.TransformDirection(bestSnapDelta),
|
|
// Color.White);
|
|
|
|
if (Vector2.Distance(snapPos, _lastSnapDragPositionOnCanvas) > 2) // ugh. Magic number
|
|
{
|
|
snapPositionChanged = true;
|
|
LastSnapTime = ImGui.GetTime();
|
|
_lastSnapDragPositionOnCanvas = snapPos;
|
|
LastSnapTargetPositionOnCanvas = _snapping.Reverse
|
|
? _snapping.InputAnchorPos
|
|
: _snapping.OutAnchorPos;
|
|
}
|
|
|
|
foreach (var n in DraggedItems)
|
|
{
|
|
n.PosOnCanvas += bestSnapDelta;
|
|
}
|
|
|
|
_lastAppliedOffset += bestSnapDelta;
|
|
}
|
|
// Unsnapped...
|
|
else
|
|
{
|
|
_lastSnapDragPositionOnCanvas = Vector2.Zero;
|
|
LastSnapTime = double.NegativeInfinity;
|
|
|
|
HandleHorizontalAlignmentSnapping(context);
|
|
}
|
|
|
|
var snappingChanged = _snapping.IsSnapped != _wasSnapped || _snapping.IsSnapped && snapPositionChanged;
|
|
_wasSnapped = _snapping.IsSnapped;
|
|
return snappingChanged;
|
|
}
|
|
|
|
private void HandleHorizontalAlignmentSnapping(GraphUiContext context)
|
|
{
|
|
if (!UserSettings.Config.EnableHorizontalSnapping)
|
|
return;
|
|
|
|
var snapFactor = 1f;
|
|
var newDragPosInCanvas = _draggedSelectables[0].PosOnCanvas;
|
|
|
|
var isFirst = true;
|
|
ImRect bounds = default;
|
|
foreach (var item in DraggedItems)
|
|
{
|
|
var itemBounds = item.Bounds;
|
|
if (isFirst)
|
|
{
|
|
bounds = itemBounds;
|
|
isFirst = false;
|
|
continue;
|
|
}
|
|
|
|
bounds.Add(itemBounds);
|
|
}
|
|
|
|
bounds.Expand(200);
|
|
|
|
|
|
_visibleItemsForSnapping.Clear();
|
|
foreach (var snapTo in context.Layout.Items.Values)
|
|
{
|
|
if (bounds.Overlaps(snapTo.Bounds))
|
|
_visibleItemsForSnapping.Add(snapTo);
|
|
}
|
|
|
|
if (!_snapHandlerX.TryCheckForSnapping(newDragPosInCanvas.X, out var snappedXValue,
|
|
context.View.Scale.X * snapFactor,
|
|
DraggedItems,
|
|
_visibleItemsForSnapping
|
|
))
|
|
return;
|
|
|
|
var snapDelta = snappedXValue - newDragPosInCanvas.X;
|
|
var offset = new Vector2((float)snapDelta, 0);
|
|
foreach (var n in DraggedItems)
|
|
{
|
|
n.PosOnCanvas += offset;
|
|
}
|
|
|
|
_lastAppliedOffset += offset;
|
|
}
|
|
|
|
private static readonly ValueSnapHandler _snapHandlerX = new(SnapResult.Orientations.Horizontal);
|
|
private static readonly List<MagGraphItem> _visibleItemsForSnapping = [];
|
|
|
|
public void StartDragOperation(GraphUiContext context)
|
|
{
|
|
_draggedSelectables = DraggedItems.Select(i => i as ISelectableCanvasObject).ToList();
|
|
if (_draggedSelectables.Count == 0)
|
|
return;
|
|
|
|
var macroCommand = context.StartMacroCommand("Move nodes");
|
|
|
|
context.MoveElementsCommand = new ModifyCanvasElementsCommand(context.CompositionInstance.Symbol.Id, _draggedSelectables, _nodeSelection);
|
|
macroCommand.AddExecutedCommandForUndo(context.MoveElementsCommand);
|
|
|
|
_lastAppliedOffset = Vector2.Zero;
|
|
_hasDragged = false;
|
|
|
|
UpdateConnectionsToDraggedItems(DraggedItems);
|
|
UpdateSnappedConnectionsToDraggedItems();
|
|
|
|
var mousePosInCanvas = context.View.InverseTransformPositionFloat(ImGui.GetMousePos());
|
|
InitSpliceLinks(DraggedItems, mousePosInCanvas);
|
|
InitPrimaryDraggedOutput();
|
|
|
|
_unsnappedBorderConnectionsBeforeDrag.Clear();
|
|
foreach (var c in _connectionsToDraggedItems)
|
|
{
|
|
if (!c.IsSnapped)
|
|
{
|
|
_unsnappedBorderConnectionsBeforeDrag.Add(c.ConnectionHash);
|
|
}
|
|
}
|
|
|
|
_context.CompositionInstance.Symbol.GetSymbolUi().FlagAsModified();
|
|
}
|
|
|
|
private readonly HashSet<int> _unsnappedBorderConnectionsBeforeDrag = [];
|
|
|
|
/// <summary>
|
|
/// Handles op disconnection and collapsed
|
|
/// </summary>
|
|
private void HandleUnsnapAndCollapse(GraphUiContext context)
|
|
{
|
|
Debug.Assert(context.MacroCommand != null);
|
|
|
|
var unsnappedConnections = new List<MagGraphConnection>();
|
|
|
|
//var enableDisconnected = UserSettings.Config.DisconnectOnUnsnap ^ ImGui.GetIO().KeyShift;
|
|
// if (!enableDisconnected)
|
|
// return;
|
|
|
|
// Delete unsnapped connections
|
|
foreach (var mc in _layout.MagConnections)
|
|
{
|
|
if (!IsBorderConnection(mc, DraggedItems))
|
|
continue;
|
|
|
|
if (_unsnappedBorderConnectionsBeforeDrag.Contains(mc.ConnectionHash))
|
|
continue;
|
|
|
|
var existedBeforeDragStart = _connectionToDragItemHashes.Contains(mc.ConnectionHash);
|
|
if (existedBeforeDragStart)
|
|
{
|
|
var isVerticalStackDisconnect = FindVerticalCollapsableConnectionPairs(_connectionsToDraggedItems);
|
|
var isHorizontalStackDisconnect = FindHorizontalCollapsableConnectionPairs(_connectionsToDraggedItems);
|
|
if(isVerticalStackDisconnect.Count != 1 && isHorizontalStackDisconnect.Count != 1)
|
|
continue;
|
|
}
|
|
|
|
unsnappedConnections.Add(mc);
|
|
|
|
var targetItemInputLine = mc.TargetItem.InputLines[mc.InputLineIndex];
|
|
var connection = mc.AsSymbolConnection();
|
|
|
|
context.MacroCommand.AddAndExecCommand(new DeleteConnectionCommand(context.CompositionInstance.Symbol,
|
|
connection,
|
|
targetItemInputLine.MultiInputIndex));
|
|
mc.IsTemporary = true;
|
|
}
|
|
|
|
if (TryCollapseDragFromVerticalStack(context, unsnappedConnections))
|
|
return;
|
|
|
|
if (TryCollapseDragFromHorizontalStack(context, unsnappedConnections))
|
|
return;
|
|
|
|
TryCollapseDisconnectedInputs(context, unsnappedConnections);
|
|
}
|
|
|
|
private bool TryCollapseDragFromVerticalStack(GraphUiContext context, List<MagGraphConnection> unsnappedConnections)
|
|
{
|
|
Debug.Assert(context.MacroCommand != null);
|
|
|
|
if (unsnappedConnections.Count == 0)
|
|
return false;
|
|
|
|
var list = FindVerticalCollapsableConnectionPairs(unsnappedConnections);
|
|
|
|
if (list.Count > 1)
|
|
{
|
|
Log.Debug("Collapsing has too many possibilities");
|
|
return false;
|
|
}
|
|
|
|
if (list.Count == 0)
|
|
return false;
|
|
|
|
var pair = list[0];
|
|
var bridgeConnection = new Symbol.Connection(pair.Ca.SourceParentOrChildId,
|
|
pair.Ca.SourceOutput.Id,
|
|
pair.Cb.TargetParentOrChildId,
|
|
pair.Cb.TargetInput.Id);
|
|
if (Structure.CheckForCycle(context.CompositionInstance.Symbol, bridgeConnection))
|
|
{
|
|
Log.Debug("Sorry, this connection would create a cycle. (1)");
|
|
return false;
|
|
}
|
|
|
|
var potentialMovers = CollectSnappedItems(pair.Cb.TargetItem);
|
|
|
|
// Clarify if the subset of items snapped to lower target op is sufficient to fill most gaps
|
|
|
|
// First find movable items and then create command with movements
|
|
var movableItems = MoveToCollapseVerticalGaps(pair.Ca, pair.Cb, potentialMovers, true);
|
|
if (movableItems.Count == 0)
|
|
return false;
|
|
|
|
var affectedItemsAsNodes = movableItems.Select(i => i as ISelectableCanvasObject).ToList();
|
|
var newMoveCommand = new ModifyCanvasElementsCommand(context.CompositionInstance.Symbol.Id, affectedItemsAsNodes, _nodeSelection);
|
|
context.MacroCommand.AddExecutedCommandForUndo(newMoveCommand);
|
|
|
|
MoveToCollapseVerticalGaps(pair.Ca, pair.Cb, movableItems, false);
|
|
newMoveCommand.StoreCurrentValues();
|
|
|
|
context.MacroCommand.AddAndExecCommand(new AddConnectionCommand(context.CompositionInstance.Symbol,
|
|
bridgeConnection,
|
|
pair.Cb.MultiInputIndex));
|
|
return true;
|
|
}
|
|
|
|
private bool TryCollapseDragFromHorizontalStack(GraphUiContext context, List<MagGraphConnection> unsnappedConnections)
|
|
{
|
|
Debug.Assert(context.MacroCommand != null);
|
|
|
|
if (unsnappedConnections.Count == 0)
|
|
return false;
|
|
|
|
var list = FindHorizontalCollapsableConnectionPairs(unsnappedConnections);
|
|
|
|
if (list.Count > 1)
|
|
{
|
|
Log.Debug("Collapsing has too many possibilities");
|
|
return false;
|
|
}
|
|
|
|
if (list.Count == 0)
|
|
return false;
|
|
|
|
var pair = list[0];
|
|
|
|
var bridgeConnection = new Symbol.Connection(pair.Ca.SourceParentOrChildId,
|
|
pair.Ca.SourceOutput.Id,
|
|
pair.Cb.TargetParentOrChildId,
|
|
pair.Cb.TargetInput.Id);
|
|
if (Structure.CheckForCycle(context.CompositionInstance.Symbol, bridgeConnection))
|
|
{
|
|
Log.Debug("Sorry, this connection would create a cycle. (1)");
|
|
return false;
|
|
}
|
|
|
|
var potentialMovers = CollectSnappedItems(pair.Cb.TargetItem);
|
|
|
|
// First find movable items and then create command with movements
|
|
var movableItems = MoveToCollapseHorizontalGaps(pair.Ca, pair.Cb, potentialMovers, true);
|
|
if (movableItems.Count == 0)
|
|
return false;
|
|
|
|
var affectedItemsAsNodes = movableItems.Select(i => i as ISelectableCanvasObject).ToList();
|
|
var newMoveCommand = new ModifyCanvasElementsCommand(context.CompositionInstance.Symbol.Id, affectedItemsAsNodes, _nodeSelection);
|
|
context.MacroCommand.AddExecutedCommandForUndo(newMoveCommand);
|
|
|
|
MoveToCollapseHorizontalGaps(pair.Ca, pair.Cb, movableItems, false);
|
|
newMoveCommand.StoreCurrentValues();
|
|
|
|
context.MacroCommand.AddAndExecCommand(new AddConnectionCommand(context.CompositionInstance.Symbol,
|
|
bridgeConnection,
|
|
pair.Cb.MultiInputIndex));
|
|
return true;
|
|
}
|
|
|
|
internal static List<SnapCollapseConnectionPair> FindLinkedVerticalCollapsableConnectionPairs(List<MagGraphConnection> unsnappedConnections)
|
|
{
|
|
// Find collapses
|
|
var pairs = new List<SnapCollapseConnectionPair>();
|
|
|
|
var ordered = unsnappedConnections.OrderBy(x => x.SourcePos.Y);
|
|
|
|
var capturedConnections = new HashSet<MagGraphConnection>();
|
|
// Flood fill vertical snap pairs
|
|
foreach (var topC in ordered)
|
|
{
|
|
if (topC.Style != MagGraphConnection.ConnectionStyles.MainOutToMainInSnappedVertical)
|
|
continue;
|
|
|
|
if (capturedConnections.Contains(topC))
|
|
continue;
|
|
|
|
var linkedOutConnection = topC;
|
|
|
|
// Find matching linked connections
|
|
while (true)
|
|
{
|
|
if (!linkedOutConnection.IsSnapped)
|
|
break;
|
|
|
|
var targetItem = linkedOutConnection.TargetItem;
|
|
if (targetItem == null)
|
|
break;
|
|
|
|
if (!targetItem.TryGetPrimaryOutConnections(out var outConnections))
|
|
break;
|
|
|
|
var cOut = outConnections[0];
|
|
|
|
if (!unsnappedConnections.Contains(cOut))
|
|
break;
|
|
|
|
linkedOutConnection = cOut;
|
|
|
|
capturedConnections.Add(linkedOutConnection);
|
|
}
|
|
|
|
if (linkedOutConnection != topC && topC.Type == linkedOutConnection.Type)
|
|
{
|
|
pairs.Add(new SnapCollapseConnectionPair(topC, linkedOutConnection));
|
|
}
|
|
}
|
|
|
|
return pairs;
|
|
}
|
|
|
|
private static List<SnapCollapseConnectionPair> FindVerticalCollapsableConnectionPairs(List<MagGraphConnection> unsnappedConnections)
|
|
{
|
|
var list = new List<SnapCollapseConnectionPair>();
|
|
|
|
// Collapse ops dragged from vertical stack...
|
|
var potentialLinks = new List<MagGraphConnection>();
|
|
|
|
foreach (var mc in unsnappedConnections)
|
|
{
|
|
if (mc.Style == MagGraphConnection.ConnectionStyles.MainOutToMainInSnappedVertical)
|
|
{
|
|
potentialLinks.Clear();
|
|
foreach (var cb in unsnappedConnections)
|
|
{
|
|
if (mc != cb
|
|
&& cb.Style == MagGraphConnection.ConnectionStyles.MainOutToMainInSnappedVertical
|
|
&& cb.SourcePos.Y > mc.SourcePos.Y
|
|
&& Math.Abs(cb.SourcePos.X - mc.SourcePos.X) < SnapTolerance
|
|
&& cb.Type == mc.Type)
|
|
{
|
|
potentialLinks.Add(cb);
|
|
}
|
|
}
|
|
|
|
if (potentialLinks.Count == 1)
|
|
{
|
|
list.Add(new SnapCollapseConnectionPair(mc, potentialLinks[0]));
|
|
}
|
|
else if (potentialLinks.Count > 1)
|
|
{
|
|
Log.Debug("Collapsing with gaps not supported yet");
|
|
}
|
|
}
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
private static List<SnapCollapseConnectionPair> FindHorizontalCollapsableConnectionPairs(List<MagGraphConnection> unsnappedConnections)
|
|
{
|
|
var list = new List<SnapCollapseConnectionPair>();
|
|
|
|
// Collapse ops dragged from vertical stack...
|
|
var potentialLinks = new List<MagGraphConnection>();
|
|
|
|
foreach (var mc in unsnappedConnections)
|
|
{
|
|
if (mc.Style == MagGraphConnection.ConnectionStyles.MainOutToMainInSnappedHorizontal)
|
|
{
|
|
potentialLinks.Clear();
|
|
foreach (var cb in unsnappedConnections)
|
|
{
|
|
if (mc != cb
|
|
&& (cb.Style == MagGraphConnection.ConnectionStyles.MainOutToMainInSnappedHorizontal ||
|
|
cb.Style ==MagGraphConnection.ConnectionStyles.MainOutToInputSnappedHorizontal)
|
|
&& cb.SourcePos.X > mc.SourcePos.X
|
|
&& Math.Abs(cb.SourcePos.Y - mc.SourcePos.Y) < SnapTolerance
|
|
&& cb.Type == mc.Type)
|
|
{
|
|
potentialLinks.Add(cb);
|
|
}
|
|
}
|
|
|
|
if (potentialLinks.Count == 1)
|
|
{
|
|
list.Add(new SnapCollapseConnectionPair(mc, potentialLinks[0]));
|
|
}
|
|
else if (potentialLinks.Count > 1)
|
|
{
|
|
Log.Debug("Collapsing with gaps not supported yet");
|
|
}
|
|
}
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
private void TryCollapseDisconnectedInputs(GraphUiContext context, List<MagGraphConnection> unsnappedConnections)
|
|
{
|
|
if (unsnappedConnections.Count == 0)
|
|
return;
|
|
|
|
var snappedItems = new HashSet<MagGraphItem>();
|
|
foreach (var mc in unsnappedConnections)
|
|
{
|
|
CollectSnappedItems(mc.TargetItem, snappedItems);
|
|
}
|
|
|
|
// Collapse lines of no longer visible inputs stack...
|
|
var collapseLines = new HashSet<float>();
|
|
foreach (var mc in unsnappedConnections)
|
|
{
|
|
var disconnectedInputWouldCollapseLine = DisconnectedInputWouldCollapseLine(mc);
|
|
if (disconnectedInputWouldCollapseLine)
|
|
{
|
|
collapseLines.Add(mc.SourcePos.Y);
|
|
}
|
|
}
|
|
|
|
if (collapseLines.Count == 0)
|
|
return;
|
|
|
|
foreach (var y in collapseLines.OrderDescending())
|
|
{
|
|
MoveSnappedItemsVertically(context,
|
|
snappedItems,
|
|
y,
|
|
-MagGraphItem.GridSize.Y
|
|
);
|
|
}
|
|
}
|
|
|
|
public static bool DisconnectedInputWouldCollapseLine(MagGraphConnection connection)
|
|
{
|
|
var inputWasNotPrimary = connection.InputLineIndex > 0;
|
|
if (connection.TargetItem.Variant != MagGraphItem.Variants.Operator)
|
|
return false;
|
|
|
|
var inputWasOptional = connection.TargetItem.InputLines[connection.InputLineIndex].InputUi.Relevancy == Relevancy.Optional;
|
|
|
|
var multiInputConnectionCount = 0;
|
|
|
|
foreach (var line in connection.TargetItem.InputLines)
|
|
{
|
|
if (line.InputUi.Id == connection.TargetItem.InputLines[connection.InputLineIndex].Id)
|
|
multiInputConnectionCount++;
|
|
}
|
|
|
|
var multiInputHadOtherConnectedMultiInput = multiInputConnectionCount > 1;
|
|
var connectedToLeftInput =
|
|
connection.Style == MagGraphConnection.ConnectionStyles.BottomToLeft
|
|
|| connection.Style == MagGraphConnection.ConnectionStyles.RightToLeft
|
|
|| connection.Style == MagGraphConnection.ConnectionStyles.MainOutToMainInSnappedHorizontal
|
|
|| connection.Style == MagGraphConnection.ConnectionStyles.MainOutToInputSnappedHorizontal;
|
|
|
|
if (connectedToLeftInput
|
|
&& (inputWasNotPrimary && inputWasOptional)
|
|
|| multiInputHadOtherConnectedMultiInput)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
///<summary>
|
|
/// Iterate through gap lines and move items below upwards
|
|
/// </summary>
|
|
public static HashSet<MagGraphItem> MoveToCollapseVerticalGaps(MagGraphConnection ca, MagGraphConnection cb, HashSet<MagGraphItem> movableItems,
|
|
bool dryRun)
|
|
{
|
|
var minY = ca.SourcePos.Y;
|
|
var maxY = cb.TargetPos.Y;
|
|
var lineWidth = MagGraphItem.GridSize.Y;
|
|
|
|
var snapCount = (maxY - minY) / lineWidth;
|
|
var roundedSnapCount = (int)(snapCount + 0.5f);
|
|
var affectedItems = new HashSet<MagGraphItem>();
|
|
for (var lineIndex = roundedSnapCount - 1; lineIndex >= 0; lineIndex--)
|
|
{
|
|
var isLineBlocked = false;
|
|
var middleSnapLineY = minY + (0.5f + lineIndex) * lineWidth;
|
|
|
|
foreach (var item in movableItems)
|
|
{
|
|
if (item.Area.Min.Y >= middleSnapLineY || item.Area.Max.Y <= middleSnapLineY)
|
|
continue;
|
|
|
|
isLineBlocked = true;
|
|
break;
|
|
}
|
|
|
|
if (isLineBlocked)
|
|
continue;
|
|
|
|
// move lines below up one step
|
|
foreach (var item in movableItems)
|
|
{
|
|
if (item.PosOnCanvas.Y < middleSnapLineY)
|
|
continue;
|
|
|
|
affectedItems.Add(item);
|
|
|
|
if (!dryRun)
|
|
item.PosOnCanvas -= new Vector2(0, lineWidth);
|
|
}
|
|
}
|
|
|
|
return affectedItems;
|
|
}
|
|
|
|
|
|
///<summary>
|
|
/// Try to close gap be looking for disjoint snapped set on the left and right
|
|
/// </summary>
|
|
private HashSet<MagGraphItem> MoveToCollapseHorizontalGaps(MagGraphConnection ca, MagGraphConnection cb, HashSet<MagGraphItem> movableItems,
|
|
bool dryRun)
|
|
{
|
|
var counterOffset = Vector2.Zero;
|
|
foreach (var ss in SpliceSets)
|
|
{
|
|
if (ss.InputItemId == ca.TargetItem.Id && ss.Direction == MagGraphItem.Directions.Horizontal)
|
|
{
|
|
counterOffset = ss.DragPositionWithinBlock;
|
|
}
|
|
}
|
|
|
|
var leftBatch = CollectSnappedItems(ca.SourceItem, null, true, ca.ConnectionHash);
|
|
var rightBatch = CollectSnappedItems(cb.TargetItem, null, true, ca.ConnectionHash);
|
|
|
|
var onlyLeft = new HashSet<MagGraphItem>(leftBatch);
|
|
onlyLeft.ExceptWith(rightBatch);
|
|
|
|
var onlyRight = new HashSet<MagGraphItem>(rightBatch);
|
|
onlyRight.ExceptWith(leftBatch);
|
|
|
|
var intersection = new HashSet<MagGraphItem>(rightBatch);
|
|
intersection.IntersectWith(leftBatch);
|
|
|
|
if (intersection.Count != 0)
|
|
{
|
|
return [];
|
|
}
|
|
|
|
var affectedItems = new HashSet<MagGraphItem>(onlyLeft);
|
|
affectedItems.UnionWith(onlyRight);
|
|
if (dryRun)
|
|
return affectedItems;
|
|
|
|
foreach (var item in onlyRight)
|
|
{
|
|
item.PosOnCanvas += new Vector2( counterOffset.X - MagGraphItem.GridSize.X, 0);
|
|
}
|
|
|
|
foreach (var item in onlyLeft)
|
|
{
|
|
item.PosOnCanvas += new Vector2(counterOffset.X, 0);
|
|
}
|
|
|
|
return affectedItems;
|
|
}
|
|
|
|
/// <summary>
|
|
/// A pair of snapped connections that can be fused after unsnapping some items from a stack
|
|
/// </summary>
|
|
internal sealed record SnapCollapseConnectionPair(MagGraphConnection Ca, MagGraphConnection Cb);
|
|
|
|
///<summary>
|
|
/// Search for potential new connections through snapping
|
|
/// </summary>
|
|
private void TryCreateNewConnectionFromSnap(GraphUiContext context)
|
|
{
|
|
if (!_snapping.IsSnapped)
|
|
return;
|
|
|
|
Debug.Assert(context.MacroCommand != null);
|
|
|
|
var newConnections = new List<PotentialConnection>();
|
|
foreach (var draggedItem in DraggedItems)
|
|
{
|
|
foreach (var otherItem in _layout.Items.Values)
|
|
{
|
|
if (DraggedItems.Contains(otherItem))
|
|
continue;
|
|
|
|
GetPotentialConnectionsAfterSnap(ref newConnections, draggedItem, otherItem);
|
|
GetPotentialConnectionsAfterSnap(ref newConnections, otherItem, draggedItem);
|
|
}
|
|
}
|
|
|
|
foreach (var potentialConnection in newConnections)
|
|
{
|
|
// Avoid accidental vertical double connections to item above when snapping a horizontal connection
|
|
if (potentialConnection.TargetItem.OutputLines.Length > 0
|
|
&& potentialConnection.TargetItem.OutputLines[0].ConnectionsOut.Count > 0)
|
|
{
|
|
var wouldConnectionOutSnapAfterMove = false;
|
|
foreach (var targetOutConnection in potentialConnection.TargetItem.OutputLines[0].ConnectionsOut)
|
|
{
|
|
if (targetOutConnection.IsSnapped)
|
|
continue;
|
|
|
|
var newOutputPos = targetOutConnection.SourceItem.PosOnCanvas
|
|
+ new Vector2(MagGraphItem.GridSize.X, MagGraphItem.GridSize.Y * (0.5f + targetOutConnection.VisibleOutputIndex));
|
|
if (Vector2.Distance(newOutputPos, targetOutConnection.TargetPos) < 0.01f)
|
|
{
|
|
wouldConnectionOutSnapAfterMove = true;
|
|
}
|
|
}
|
|
|
|
if (wouldConnectionOutSnapAfterMove)
|
|
{
|
|
Log.Debug("Avoiding double vertical connection...");
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Avoid accidental vertical double connections to item below when snapping a horizontal connection
|
|
if (potentialConnection.SourceItem.OutputLines.Length > 0
|
|
&& potentialConnection.SourceItem.OutputLines[0].ConnectionsOut.Count > 0)
|
|
{
|
|
var wouldConnectionOutSnapAfterMove = false;
|
|
foreach (var sourceOutConnection in potentialConnection.SourceItem.OutputLines[0].ConnectionsOut)
|
|
{
|
|
// if (sourceOutConnection.IsSnapped && !sourceOutConnection.WasDisconnected.)
|
|
// continue;
|
|
|
|
var newOutputPos = sourceOutConnection.SourceItem.PosOnCanvas
|
|
+ new Vector2(MagGraphItem.GridSize.X, MagGraphItem.GridSize.Y * (0.5f + sourceOutConnection.VisibleOutputIndex));
|
|
if (Vector2.Distance(newOutputPos, sourceOutConnection.TargetPos) < 4f)
|
|
{
|
|
wouldConnectionOutSnapAfterMove = true;
|
|
}
|
|
}
|
|
|
|
if (wouldConnectionOutSnapAfterMove)
|
|
{
|
|
Log.Debug("Avoiding double connection...");
|
|
continue;
|
|
}
|
|
}
|
|
|
|
var sourceParentOfSymbolChildId =
|
|
potentialConnection.SourceItem.Variant == MagGraphItem.Variants.Input ? Guid.Empty : potentialConnection.SourceItem.Id;
|
|
|
|
var targetParentOfSymbolChildId =
|
|
potentialConnection.TargetItem.Variant == MagGraphItem.Variants.Output ? Guid.Empty : potentialConnection.TargetItem.Id;
|
|
|
|
var newConnection = new Symbol.Connection(sourceParentOfSymbolChildId,
|
|
potentialConnection.OutputLine.Id,
|
|
targetParentOfSymbolChildId,
|
|
potentialConnection.InputLine.Id);
|
|
|
|
if (Structure.CheckForCycle(context.CompositionInstance.Symbol, newConnection))
|
|
{
|
|
Log.Debug("Sorry, this connection would create a cycle. (4)");
|
|
continue;
|
|
}
|
|
|
|
context.MacroCommand.AddAndExecCommand(new AddConnectionCommand(context.CompositionInstance.Symbol,
|
|
newConnection,
|
|
potentialConnection.InputLine.MultiInputIndex));
|
|
}
|
|
}
|
|
|
|
private static void GetPotentialConnectionsAfterSnap(ref List<PotentialConnection> result, MagGraphItem a, MagGraphItem b)
|
|
{
|
|
MagGraphConnection? inConnection;
|
|
|
|
for (var bInputLineIndex = 0; bInputLineIndex < b.InputLines.Length; bInputLineIndex++)
|
|
{
|
|
ref var bInputLine = ref b.InputLines[bInputLineIndex];
|
|
inConnection = bInputLine.ConnectionIn;
|
|
|
|
int aOutLineIndex;
|
|
for (aOutLineIndex = 0; aOutLineIndex < a.OutputLines.Length; aOutLineIndex++)
|
|
{
|
|
ref var outputLine = ref a.OutputLines[aOutLineIndex]; // Avoid copying data from array
|
|
if (bInputLine.Type != outputLine.Output.ValueType)
|
|
continue;
|
|
|
|
// vertical
|
|
if (aOutLineIndex == 0 && bInputLineIndex == 0)
|
|
{
|
|
AddPossibleNewConnections(ref result,
|
|
ref outputLine,
|
|
ref bInputLine,
|
|
new Vector2(a.Area.Min.X + MagGraphItem.WidthHalf, a.Area.Max.Y),
|
|
new Vector2(b.Area.Min.X + MagGraphItem.WidthHalf, b.Area.Min.Y));
|
|
}
|
|
|
|
// horizontal
|
|
if (outputLine.Output.ValueType == bInputLine.Type)
|
|
{
|
|
AddPossibleNewConnections(ref result,
|
|
ref outputLine,
|
|
ref bInputLine,
|
|
new Vector2(a.Area.Max.X, a.Area.Min.Y + (0.5f + outputLine.VisibleIndex) * MagGraphItem.LineHeight),
|
|
new Vector2(b.Area.Min.X, b.Area.Min.Y + (0.5f + bInputLine.VisibleIndex) * MagGraphItem.LineHeight));
|
|
}
|
|
}
|
|
}
|
|
|
|
return;
|
|
|
|
void AddPossibleNewConnections(ref List<PotentialConnection> newConnections,
|
|
ref MagGraphItem.OutputLine outputLine,
|
|
ref MagGraphItem.InputLine inputLine,
|
|
Vector2 outPos,
|
|
Vector2 inPos)
|
|
{
|
|
if (Vector2.Distance(outPos, inPos) > SnapTolerance)
|
|
return;
|
|
|
|
if (inConnection != null)
|
|
return;
|
|
|
|
// Clarify if outConnection should also be empty...
|
|
if (outputLine.ConnectionsOut.Count > 0)
|
|
{
|
|
if (outputLine.ConnectionsOut[0].IsSnapped
|
|
&& (outputLine.ConnectionsOut[0].SourcePos - inPos).Length() < SnapTolerance)
|
|
return;
|
|
}
|
|
|
|
newConnections.Add(new PotentialConnection(a, outputLine,
|
|
b, inputLine));
|
|
}
|
|
}
|
|
|
|
private sealed record PotentialConnection(
|
|
MagGraphItem SourceItem,
|
|
MagGraphItem.OutputLine OutputLine,
|
|
MagGraphItem TargetItem,
|
|
MagGraphItem.InputLine InputLine);
|
|
|
|
private void UpdateConnectionsToDraggedItems(HashSet<MagGraphItem> draggedItems)
|
|
{
|
|
_connectionsToDraggedItems.Clear();
|
|
_connectionToDragItemHashes.Clear();
|
|
|
|
// This could be optimized by only looking for dragged item connections
|
|
foreach (var c in _layout.MagConnections)
|
|
{
|
|
if (!IsBorderConnection(c, draggedItems))
|
|
continue;
|
|
|
|
_connectionsToDraggedItems.Add(c);
|
|
_connectionToDragItemHashes.Add(c.ConnectionHash);
|
|
}
|
|
}
|
|
|
|
private static bool IsBorderConnection(MagGraphConnection c, HashSet<MagGraphItem> draggedItems)
|
|
{
|
|
var isTargetDragged = draggedItems.Contains(c.TargetItem);
|
|
var isSourceDragged = draggedItems.Contains(c.SourceItem);
|
|
|
|
return isTargetDragged != isSourceDragged;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// This is updated every frame...
|
|
/// </summary>
|
|
private void UpdateSnappedConnectionsToDraggedItems()
|
|
{
|
|
_snappedConnectionToDragItemHashes.Clear();
|
|
|
|
foreach (var c in _connectionsToDraggedItems)
|
|
{
|
|
if (c.IsSnapped)
|
|
_snappedConnectionToDragItemHashes.Add(c.ConnectionHash);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// When starting a new drag operation, we try to identify border input anchors of the dragged items,
|
|
/// that can be used to insert them between other snapped items.
|
|
/// </summary>
|
|
private void InitSpliceLinks(HashSet<MagGraphItem> draggedItems, Vector2 mousePosInCanvas)
|
|
{
|
|
SpliceSets.Clear();
|
|
|
|
foreach (var inputItemA in draggedItems)
|
|
{
|
|
var itemAInputCount = inputItemA.GetInputAnchorCount();
|
|
MagGraphItem.InputAnchorPoint inputAnchor = default;
|
|
|
|
for (var inputAnchorIndex = 0; inputAnchorIndex < itemAInputCount; inputAnchorIndex++)
|
|
{
|
|
inputItemA.GetInputAnchorAtIndex(inputAnchorIndex, ref inputAnchor);
|
|
// make sure it's a snapped border connection
|
|
if (inputAnchor.SnappedConnectionHash != MagGraphItem.FreeAnchor
|
|
&& !_snappedConnectionToDragItemHashes.Contains(inputAnchor.SnappedConnectionHash))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var spliceSets = new List<SpliceLink>();
|
|
foreach (var outputItemB in draggedItems)
|
|
{
|
|
var xy = inputAnchor.Direction == MagGraphItem.Directions.Horizontal ? 0 : 1;
|
|
|
|
if (Math.Abs(inputItemA.PosOnCanvas[1 - xy] - outputItemB.PosOnCanvas[1 - xy]) > SnapTolerance)
|
|
continue;
|
|
|
|
var outputAnchorCount = outputItemB.GetOutputAnchorCount();
|
|
MagGraphItem.OutputAnchorPoint outputAnchor = default;
|
|
|
|
for (var outputIndex = 0; outputIndex < outputAnchorCount; outputIndex++)
|
|
{
|
|
outputItemB.GetOutputAnchorAtIndex(outputIndex, ref outputAnchor);
|
|
if (outputAnchor.SnappedConnectionHash != MagGraphItem.FreeAnchor
|
|
&& !_snappedConnectionToDragItemHashes.Contains(outputAnchor.SnappedConnectionHash))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (
|
|
outputAnchor.Direction != inputAnchor.Direction
|
|
|| inputAnchor.ConnectionType != outputAnchor.ConnectionType)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var inputAnchorPositionOnCanvas = inputAnchor.PositionOnCanvas - inputItemA.PosOnCanvas;
|
|
|
|
spliceSets.Add(new SpliceLink(inputItemA.Id,
|
|
inputAnchor.SlotId,
|
|
outputItemB.Id,
|
|
outputAnchor.SlotId,
|
|
inputAnchor.Direction,
|
|
inputAnchor.ConnectionType,
|
|
outputAnchor.PositionOnCanvas[xy] - inputAnchor.PositionOnCanvas[xy],
|
|
mousePosInCanvas - inputItemA.PosOnCanvas,
|
|
inputAnchorPositionOnCanvas
|
|
));
|
|
}
|
|
}
|
|
|
|
// Skip insertion lines with gaps
|
|
if (spliceSets.Count == 1)
|
|
{
|
|
SpliceSets.Add(spliceSets[0]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
///<summary>
|
|
/// Search for potential new connections through snapping
|
|
/// </summary>
|
|
// ReSharper disable once UnusedMethodReturnValue.Local
|
|
private static bool TrySplitInsert(GraphUiContext context)
|
|
{
|
|
if (!_snapping.IsSnapped || _snapping.TargetItem == null || _snapping.SourceItem == null)
|
|
return false;
|
|
|
|
Debug.Assert(context.MacroCommand != null);
|
|
|
|
var spliceLink = _snapping.InsertionPoint;
|
|
|
|
// Split connection
|
|
var connection = _snapping.TargetItem.InputLines[_snapping.InputLineIndex].ConnectionIn;
|
|
if (connection == null)
|
|
{
|
|
Log.Warning("Missing connection?");
|
|
return true;
|
|
}
|
|
|
|
if (spliceLink == null)
|
|
{
|
|
Log.Warning("Insertion point is undefined?");
|
|
return false;
|
|
}
|
|
|
|
var connectionIntoSplice = new Symbol.Connection(connection.SourceParentOrChildId,
|
|
connection.SourceOutput.Id,
|
|
spliceLink.InputItemId,
|
|
spliceLink.InputId);
|
|
|
|
var connectionOutOfSplice = new Symbol.Connection(spliceLink.OutputItemId,
|
|
spliceLink.OutputId,
|
|
connection.TargetParentOrChildId,
|
|
connection.TargetInput.Id);
|
|
|
|
if (Structure.CheckForCycle(context.CompositionInstance.Symbol, connectionIntoSplice))
|
|
{
|
|
Log.Debug("Sorry, this connection would create a cycle. (2)");
|
|
return false;
|
|
}
|
|
|
|
if (Structure.CheckForCycle(context.CompositionInstance.Symbol, connectionOutOfSplice))
|
|
{
|
|
Log.Debug("Sorry, this connection would create a cycle. (3)");
|
|
return false;
|
|
}
|
|
|
|
context.MacroCommand.AddAndExecCommand(new DeleteConnectionCommand(context.CompositionInstance.Symbol,
|
|
connection.AsSymbolConnection(),
|
|
connection.MultiInputIndex));
|
|
context.MacroCommand.AddAndExecCommand(new AddConnectionCommand(context.CompositionInstance.Symbol,
|
|
connectionIntoSplice, 0));
|
|
|
|
context.MacroCommand.AddAndExecCommand(new AddConnectionCommand(context.CompositionInstance.Symbol,
|
|
connectionOutOfSplice, connection.MultiInputIndex));
|
|
|
|
// Move items
|
|
if (spliceLink.Direction == MagGraphItem.Directions.Vertical)
|
|
{
|
|
MoveSnappedItemsVertically(context,
|
|
CollectSnappedItems(_snapping.TargetItem),
|
|
_snapping.OutAnchorPos.Y - MagGraphItem.GridSize.Y / 2,
|
|
spliceLink.Distance);
|
|
}
|
|
else
|
|
{
|
|
var leftBatch = CollectSnappedItems(_snapping.SourceItem, null, true, connection.ConnectionHash);
|
|
var rightBatch = CollectSnappedItems(_snapping.TargetItem, null, true, connection.ConnectionHash);
|
|
|
|
var onlyLeft = new HashSet<MagGraphItem>(leftBatch);
|
|
onlyLeft.ExceptWith(rightBatch);
|
|
|
|
var onlyRight = new HashSet<MagGraphItem>(rightBatch);
|
|
onlyRight.ExceptWith(leftBatch);
|
|
|
|
var intersection = new HashSet<MagGraphItem>(rightBatch);
|
|
intersection.IntersectWith(leftBatch);
|
|
|
|
MoveItems(context, onlyLeft, -new Vector2(spliceLink.DragPositionWithinBlock.X ,0));
|
|
MoveItems(context, onlyRight, new Vector2(spliceLink.Distance - spliceLink.DragPositionWithinBlock.X,0));
|
|
MoveSnappedItemsHorizontally(context,
|
|
intersection,
|
|
_snapping.OutAnchorPos.X - MagGraphItem.GridSize.X / 2,
|
|
spliceLink.Distance);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates and applies a command to move items vertically
|
|
/// </summary>
|
|
/// <returns>
|
|
/// True if some items where moved
|
|
/// </returns>
|
|
public static void MoveSnappedItemsVertically(GraphUiContext context, HashSet<MagGraphItem> snappedItems, float yThreshold, float yDistance)
|
|
{
|
|
Debug.Assert(context.MacroCommand != null);
|
|
var movableItems = new List<MagGraphItem>();
|
|
foreach (var otherItem in snappedItems)
|
|
{
|
|
if (otherItem.PosOnCanvas.Y > yThreshold)
|
|
{
|
|
movableItems.Add(otherItem);
|
|
}
|
|
}
|
|
|
|
if (movableItems.Count == 0)
|
|
return;
|
|
|
|
MoveItems(context, movableItems, new Vector2(0, yDistance));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates and applies a command to move items vertically
|
|
/// </summary>
|
|
/// <returns>
|
|
/// True if some items where moved
|
|
/// </returns>
|
|
public static void MoveSnappedItemsHorizontally(GraphUiContext context, HashSet<MagGraphItem> snappedItems, float xThreshold, float xDistance)
|
|
{
|
|
Debug.Assert(context.MacroCommand != null);
|
|
|
|
var movableItems = new List<MagGraphItem>();
|
|
foreach (var otherItem in snappedItems)
|
|
{
|
|
if (otherItem.PosOnCanvas.X > xThreshold)
|
|
{
|
|
movableItems.Add(otherItem);
|
|
}
|
|
}
|
|
|
|
if (movableItems.Count == 0)
|
|
return;
|
|
|
|
MoveItems(context, movableItems, new Vector2(xDistance,0));
|
|
}
|
|
|
|
private static void MoveItems(GraphUiContext context, IEnumerable<MagGraphItem> movableItems, Vector2 offset)
|
|
{
|
|
Debug.Assert(context.MacroCommand != null);
|
|
|
|
// Move items left...
|
|
var affectedItemsAsNodes = movableItems.Select(i => i as ISelectableCanvasObject).ToList();
|
|
var newMoveComment = new ModifyCanvasElementsCommand(context.CompositionInstance.Symbol.Id, affectedItemsAsNodes, context.Selector);
|
|
context.MacroCommand.AddExecutedCommandForUndo(newMoveComment);
|
|
|
|
Log.Debug($"MoveItems: {affectedItemsAsNodes.Count} items by {offset}");
|
|
foreach (var item in affectedItemsAsNodes)
|
|
{
|
|
item.PosOnCanvas += offset;
|
|
}
|
|
|
|
newMoveComment.StoreCurrentValues();
|
|
|
|
// Programmatic pushes (splice inserts, added input rows, placeholder insertion) can
|
|
// shove ops across their section's bottom/right border - grow those frames to keep them
|
|
_growSectionIds.Clear();
|
|
var symbolUi = context.CompositionInstance.GetSymbolUi();
|
|
foreach (var item in movableItems)
|
|
{
|
|
if (item.ChildUi == null || item.ChildUi.SectionId == Guid.Empty)
|
|
continue;
|
|
|
|
if (!_growSectionIds.Add(item.ChildUi.SectionId))
|
|
continue;
|
|
|
|
if (!symbolUi.Sections.TryGetValue(item.ChildUi.SectionId, out var section)
|
|
|| section.Collapsed || section.IsHiddenInCollapsedSection)
|
|
continue;
|
|
|
|
GrowSectionToFitContent(context, symbolUi, section, excludedChildIds: null);
|
|
}
|
|
}
|
|
|
|
private static readonly HashSet<Guid> _growSectionIds = [];
|
|
|
|
private void InitPrimaryDraggedOutput()
|
|
{
|
|
_context.DraggedPrimaryOutputType = null;
|
|
_context.ItemForInputSelection = null;
|
|
|
|
_context.ActiveSourceItem = FindPrimaryOutputItem();
|
|
if (_context.ActiveSourceItem == null)
|
|
return;
|
|
|
|
_context.DraggedPrimaryOutputType = _context.ActiveSourceItem.PrimaryType;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Snapping an item onto a hidden parameter is a tricky ui problem.
|
|
/// To allow this interaction we add "peek" anchor indicator to the dragged item set.
|
|
/// If this is dropped without snapping onto an operator with hidden parameters of the matching type,
|
|
/// we present cables.gl inspired picker interface.
|
|
///
|
|
/// Set primary types to indicate targets for dragging
|
|
/// This part is a little fishy. To have "some" solution we try to identify dragged
|
|
/// constellations that has a single free horizontal output anchor on the left column.
|
|
/// </summary>
|
|
private MagGraphItem? FindPrimaryOutputItem()
|
|
{
|
|
if (DraggedItems.Count == 0)
|
|
return null;
|
|
|
|
if (DraggedItems.Count == 1)
|
|
return DraggedItems.First();
|
|
|
|
var itemsOrderedByX = DraggedItems.OrderByDescending(c => c.PosOnCanvas.X);
|
|
var rightItem = itemsOrderedByX.First();
|
|
|
|
// Check if there are multiple items on right edge column...
|
|
var rightColumnItemCount = 0;
|
|
foreach (var i in DraggedItems)
|
|
{
|
|
if (Math.Abs(i.PosOnCanvas.X - rightItem.PosOnCanvas.X) < SnapTolerance)
|
|
rightColumnItemCount++;
|
|
}
|
|
|
|
if (rightColumnItemCount > 1)
|
|
return null;
|
|
|
|
if (DraggedItems.Count != CollectSnappedItems(rightItem).Count)
|
|
return null;
|
|
|
|
return rightItem;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add snapped items to the given set or create new set
|
|
/// </summary>
|
|
public static HashSet<MagGraphItem> CollectSnappedItems(MagGraphItem rootItem, HashSet<MagGraphItem>? set = null, bool includeRoot= true, int ignoreConnectionHash= 0)
|
|
{
|
|
set ??= [];
|
|
|
|
Collect(rootItem);
|
|
if (!includeRoot)
|
|
set.Remove(rootItem);
|
|
|
|
return set;
|
|
|
|
void Collect(MagGraphItem item)
|
|
{
|
|
if (!set.Add(item))
|
|
return;
|
|
|
|
for (var index = 0; index < item.InputLines.Length; index++)
|
|
{
|
|
var c = item.InputLines[index].ConnectionIn;
|
|
if (c == null || c.ConnectionHash == ignoreConnectionHash)
|
|
continue;
|
|
|
|
if (c.IsSnapped && !c.IsTemporary)
|
|
Collect(c.SourceItem);
|
|
}
|
|
|
|
for (var index = 0; index < item.OutputLines.Length; index++)
|
|
{
|
|
var connections = item.OutputLines[index].ConnectionsOut;
|
|
foreach (var c in connections)
|
|
{
|
|
if (c.ConnectionHash != ignoreConnectionHash && c.IsSnapped)
|
|
Collect(c.TargetItem);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static HashSet<MagGraphItem> CollectSnappedItems(IEnumerable<MagGraphItem> rootItems)
|
|
{
|
|
var set = new HashSet<MagGraphItem>();
|
|
|
|
foreach (var i in rootItems)
|
|
{
|
|
CollectSnappedItems(i, set);
|
|
}
|
|
|
|
return set;
|
|
}
|
|
|
|
internal void SetDraggedItemIds(List<Guid> selectedIds)
|
|
{
|
|
DraggedItems.Clear();
|
|
_draggedItemsFromSelection = false;
|
|
foreach (var id in selectedIds)
|
|
{
|
|
if (_layout.Items.TryGetValue(id, out var i))
|
|
{
|
|
DraggedItems.Add(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void SetDraggedItems(List<ISelectableCanvasObject> selection)
|
|
{
|
|
DraggedItems.Clear();
|
|
_draggedItemsFromSelection = true;
|
|
foreach (var s in selection)
|
|
{
|
|
if (_layout.Items.TryGetValue(s.Id, out var i))
|
|
{
|
|
DraggedItems.Add(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void SetDraggedItemIdsToSnappedForItem(MagGraphItem item)
|
|
{
|
|
DraggedItems.Clear();
|
|
_draggedItemsFromSelection = false;
|
|
CollectSnappedItems(item, DraggedItems);
|
|
}
|
|
|
|
internal bool IsItemDragged(MagGraphItem item) => DraggedItems.Contains(item);
|
|
|
|
internal double LastSnapTime = double.NegativeInfinity;
|
|
private Vector2 _lastSnapDragPositionOnCanvas;
|
|
|
|
/** for visual indication only */
|
|
internal Vector2 LastSnapTargetPositionOnCanvas;
|
|
|
|
internal readonly List<SpliceLink> SpliceSets = [];
|
|
|
|
private Vector2 _lastAppliedOffset;
|
|
private const float SnapThreshold = 30;
|
|
|
|
/// <summary>
|
|
/// Connections between dragged and non-dragged items
|
|
/// </summary>
|
|
private readonly List<MagGraphConnection> _connectionsToDraggedItems = [];
|
|
private readonly HashSet<int> _connectionToDragItemHashes = [];
|
|
private readonly HashSet<int> _snappedConnectionToDragItemHashes = [];
|
|
|
|
private bool _wasSnapped;
|
|
private static readonly MagItemMovement.Snapping _snapping = new();
|
|
|
|
private static bool _hasDragged;
|
|
private Vector2 _dragStartPosInOpOnCanvas;
|
|
|
|
private readonly ShakeDetector _shakeDetector = new();
|
|
|
|
internal readonly HashSet<MagGraphItem> DraggedItems = [];
|
|
private bool _draggedItemsFromSelection;
|
|
private List<ISelectableCanvasObject> _draggedSelectables = [];
|
|
|
|
/// <summary>
|
|
/// Defines a method how the currently dragged nodes could split some other snapped graph nodes
|
|
/// either horizontally or vertically. It provides information on how to snap, what type of
|
|
/// connection would be split and which inputs and outputs to splice in.
|
|
/// </summary>
|
|
/// <param name="DragPositionWithinBlock">The distance from top left position of InputItem (A) to where the mouse drag started.</param>
|
|
internal sealed record SpliceLink(
|
|
Guid InputItemId,
|
|
Guid InputId,
|
|
Guid OutputItemId,
|
|
Guid OutputId,
|
|
MagGraphItem.Directions Direction,
|
|
Type Type,
|
|
float Distance,
|
|
Vector2 DragPositionWithinBlock,
|
|
Vector2 AnchorOffset);
|
|
|
|
|
|
|
|
private readonly MagGraphView _view;
|
|
private readonly MagGraphLayout _layout;
|
|
private readonly NodeSelection _nodeSelection;
|
|
private const float SnapTolerance = 0.01f;
|
|
} |