wehub-resource-sync
769 lines
41 KiB
C#
769 lines
41 KiB
C#
using ImGuiNET;
|
|
using System.Diagnostics;
|
|
using T3.Editor.Gui.MagGraph.Interaction;
|
|
using T3.Editor.Gui.Interaction;
|
|
using T3.Editor.Gui.Interaction.Keyboard;
|
|
using T3.Editor.Gui.MagGraph.Model;
|
|
using T3.Editor.Gui.UiHelpers;
|
|
using T3.Editor.UiModel.Commands.Graph;
|
|
using T3.Editor.UiModel.ProjectHandling;
|
|
using MagItemMovement = T3.Editor.Gui.MagGraph.Interaction.MagItemMovement;
|
|
using SkillTraining = T3.Editor.Skills.Training.SkillTraining;
|
|
|
|
// ReSharper disable MemberCanBePrivate.Global
|
|
|
|
namespace T3.Editor.Gui.MagGraph.States
|
|
{
|
|
internal static class GraphStates
|
|
{
|
|
internal static State<GraphUiContext> Default
|
|
= new(
|
|
Enter: context =>
|
|
{
|
|
// Todo: this should be a reset method in context
|
|
context.TempConnections.Clear();
|
|
context.ActiveSourceItem = null;
|
|
context.ActiveTargetItem = null;
|
|
context.ActiveTargetInputId = Guid.Empty;
|
|
|
|
context.DraggedPrimaryOutputType = null;
|
|
|
|
// ReSharper disable once ConstantConditionalAccessQualifier
|
|
// This might not be initialized on startup
|
|
context.Placeholder.Reset(context);
|
|
context.DisconnectedInputHashes.Clear();
|
|
},
|
|
Update: context =>
|
|
{
|
|
if (context.ItemWithActiveCustomUi != null)
|
|
return;
|
|
|
|
if (context.ProjectView.GraphImageBackground.HasInteractionFocus)
|
|
{
|
|
context.StateMachine.SetState(BackgroundContentIsInteractive, context);
|
|
return;
|
|
}
|
|
|
|
// Check keyboard commands if focused...
|
|
if (context.View.IsFocused
|
|
&& context.View.IsHovered
|
|
&& !ImGui.IsAnyItemActive())
|
|
{
|
|
// Tab create placeholder
|
|
if (ImGui.IsKeyReleased(ImGuiKey.Tab) && !ImGui.GetIO().KeyShift)
|
|
{
|
|
var focusedObject =
|
|
context.Selector.Selection.Count == 1 &&
|
|
context.View.IsItemVisible(context.Selector.Selection[0])
|
|
? context.Selector.Selection[0]
|
|
: null;
|
|
|
|
if (focusedObject != null
|
|
&& context.Layout.Items.TryGetValue(focusedObject.Id, out var focusedItem))
|
|
{
|
|
if (focusedItem.OutputLines.Length > 0)
|
|
{
|
|
context.Placeholder.OpenForItemOutput(context, focusedItem, focusedItem.OutputLines[0]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var posOnCanvas = context.View.InverseTransformPositionFloat(ImGui.GetMousePos());
|
|
context.Placeholder.OpenOnCanvas(context, posOnCanvas);
|
|
}
|
|
|
|
context.StateMachine.SetState(Placeholder, context);
|
|
}
|
|
|
|
// else if (ImGui.IsKeyReleased(ImGuiKey.Delete) || ImGui.IsKeyReleased(ImGuiKey.Backspace))
|
|
// {
|
|
// Modifications.DeleteSelectedOps(context);
|
|
// }
|
|
}
|
|
|
|
if (!context.View.IsHovered)
|
|
return;
|
|
|
|
// Open children or parent component with keyboard
|
|
if (UserActions.CloseOperator.Triggered() && ProjectView.Focused != null)
|
|
{
|
|
ProjectView.Focused.TrySetCompositionOpToParent();
|
|
}
|
|
|
|
if (UserActions.OpenOperator.Triggered() && ProjectView.Focused != null)
|
|
{
|
|
var isWindowActive = ImGui.IsWindowFocused() || ImGui.IsWindowHovered(ImGuiHoveredFlags.AllowWhenBlockedByPopup);
|
|
|
|
// Check if we have either an active (selected) item or a hovered item
|
|
var itemToOpen = context.ActiveItem ?? context.HoveredItem;
|
|
|
|
if (isWindowActive && itemToOpen != null && itemToOpen.Variant == MagGraphItem.Variants.Operator)
|
|
{
|
|
Debug.Assert(itemToOpen.Instance != null);
|
|
if (itemToOpen.Instance.Children.Count > 0)
|
|
{
|
|
ProjectView.Focused.TrySetCompositionOpToChild(itemToOpen.Instance.SymbolChildId);
|
|
}
|
|
}
|
|
}
|
|
// Mouse click
|
|
var clickedDown = ImGui.IsMouseClicked(ImGuiMouseButton.Left);
|
|
if (!clickedDown)
|
|
return;
|
|
|
|
// Open children or parent component
|
|
if (ImGui.IsMouseDoubleClicked(ImGuiMouseButton.Left)
|
|
&& ProjectView.Focused != null
|
|
&& !SkillTraining.IsInPlayMode
|
|
)
|
|
{
|
|
var clickedBackground = context.ActiveItem == null;
|
|
if (clickedBackground)
|
|
{
|
|
// Skip double-clicks that started before the view was opened,
|
|
// e.g. the click that opened the project from the hub
|
|
if (!ProjectView.Focused.OpenedWithinDoubleClickTime)
|
|
{
|
|
// Already at the root composition -> return to the project hub
|
|
if (!ProjectView.Focused.TrySetCompositionOpToParent())
|
|
{
|
|
ProjectView.Focused.Close();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var isWindowActive = ImGui.IsWindowFocused() || ImGui.IsWindowHovered(ImGuiHoveredFlags.AllowWhenBlockedByPopup);
|
|
if (isWindowActive && context.ActiveItem.Variant == MagGraphItem.Variants.Operator)
|
|
{
|
|
Debug.Assert(context.ActiveItem.Instance != null);
|
|
// TODO: implement lib edit warning popup
|
|
// var blocked = false;
|
|
// if (UserSettings.Config.WarnBeforeLibEdit && context.ActiveItem.Instance.Symbol.Namespace.StartsWith("Lib."))
|
|
// {
|
|
// if (UserSettings.Config.WarnBeforeLibEdit)
|
|
// {
|
|
// var count = Structure.CollectDependingSymbols(instance.Symbol).Count();
|
|
// LibWarningDialog.DependencyCount = count;
|
|
// LibWarningDialog.HandledInstance = instance;
|
|
// _canvas.LibWarningDialog.ShowNextFrame();
|
|
// blocked = true;
|
|
// }
|
|
// }
|
|
// if (!blocked)
|
|
// {
|
|
// Until we align the context switching between graphs, this hack applies the current
|
|
// MagGraph scope to the legacy graph, so it's correctly saved for the Symbol in the user settings...
|
|
//ProjectView.Focused?.GraphCanvas?.SetTargetScope(context.Canvas.GetTargetScope());
|
|
|
|
if (context.ActiveItem.Instance.Children.Count > 0)
|
|
{
|
|
ProjectView.Focused.TrySetCompositionOpToChild(context.ActiveItem.Instance.SymbolChildId);
|
|
}
|
|
|
|
//ImGui.CloseCurrentPopup(); // ??
|
|
//}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Outputs and inputs are handled first, because they might
|
|
// overlap with other items that got activated on click.
|
|
|
|
if (context.ActiveSourceItem != null)
|
|
{
|
|
context.StateMachine.SetState(HoldOutput, context);
|
|
context.ActiveItem = context.ActiveSourceItem;
|
|
}
|
|
else if (context.ActiveTargetItem != null)
|
|
{
|
|
context.StateMachine.SetState(HoldInput, context);
|
|
}
|
|
else if (context.ActiveItem != null)
|
|
{
|
|
context.StateMachine.SetState(HoldItem, context);
|
|
}
|
|
// Mouse is pressed but nothing is active -> background
|
|
else
|
|
{
|
|
context.StateMachine.SetState(HoldBackground, context);
|
|
}
|
|
},
|
|
Exit:
|
|
_ => { }
|
|
);
|
|
|
|
/** A special mode to prevent interaction with graph elements */
|
|
internal static State<GraphUiContext> BackgroundContentIsInteractive
|
|
= new(
|
|
Enter: _ => { },
|
|
Update: context =>
|
|
{
|
|
// Switch back
|
|
if (!context.ProjectView.GraphImageBackground.HasInteractionFocus)
|
|
{
|
|
context.StateMachine.SetState(Default, context);
|
|
return;
|
|
}
|
|
},
|
|
Exit: _ => { }
|
|
);
|
|
|
|
|
|
/// <summary>
|
|
/// Active while long tapping on background for insertion
|
|
/// </summary>
|
|
internal static State<GraphUiContext> HoldBackground
|
|
= new(
|
|
Enter: _ => { },
|
|
Update: context =>
|
|
{
|
|
if (!ImGui.IsMouseDown(ImGuiMouseButton.Left)
|
|
|| !context.View.IsFocused
|
|
|| ImGui.IsMouseDragging(ImGuiMouseButton.Left))
|
|
{
|
|
context.StateMachine.SetState(Default, context);
|
|
return;
|
|
}
|
|
|
|
const float longTapDuration = 0.3f;
|
|
var longTapProgress = context.StateMachine.StateTime / longTapDuration;
|
|
MagItemMovement.UpdateLongPressIndicator(longTapProgress);
|
|
|
|
if (!(longTapProgress > 1))
|
|
return;
|
|
|
|
// TODO: setting both, state and placeholder, feels awkward.
|
|
context.StateMachine.SetState(Placeholder, context);
|
|
var posOnCanvas = context.View.InverseTransformPositionFloat(ImGui.GetMousePos());
|
|
context.Placeholder.OpenOnCanvas(context, posOnCanvas);
|
|
},
|
|
Exit: _ => { }
|
|
);
|
|
|
|
internal static State<GraphUiContext> Placeholder
|
|
= new(
|
|
Enter: _ => { },
|
|
Update: context =>
|
|
{
|
|
if (context.Placeholder.PlaceholderItem != null)
|
|
return;
|
|
|
|
context.Placeholder.Cancel(context);
|
|
context.StateMachine.SetState(Default, context);
|
|
},
|
|
Exit: _ => { }
|
|
);
|
|
|
|
internal static State<GraphUiContext> HoldItem
|
|
= new(
|
|
Enter: context =>
|
|
{
|
|
var item = context.ActiveItem;
|
|
Debug.Assert(item != null);
|
|
|
|
var selector = context.Selector;
|
|
|
|
var isPartOfSelection = selector.IsSelected(item);
|
|
if (isPartOfSelection)
|
|
{
|
|
context.ItemMovement.SetDraggedItems(selector.Selection);
|
|
}
|
|
else
|
|
{
|
|
context.ItemMovement.SetDraggedItemIdsToSnappedForItem(item);
|
|
}
|
|
},
|
|
Update: context =>
|
|
{
|
|
Debug.Assert(context.ActiveItem != null);
|
|
|
|
if (!ImGui.IsMouseDown(ImGuiMouseButton.Left))
|
|
{
|
|
MagItemMovement.SelectActiveItem(context);
|
|
context.ItemMovement.Reset();
|
|
context.StateMachine.SetState(Default, context);
|
|
return;
|
|
}
|
|
|
|
if (ImGui.IsMouseDragging(ImGuiMouseButton.Left))
|
|
{
|
|
context.StateMachine.SetState(DragItems, context);
|
|
return;
|
|
}
|
|
|
|
const float longTapDuration = 0.3f;
|
|
var longTapProgress = context.StateMachine.StateTime / longTapDuration;
|
|
MagItemMovement.UpdateLongPressIndicator(longTapProgress);
|
|
|
|
if (!(longTapProgress > 1))
|
|
return;
|
|
|
|
MagItemMovement.SelectActiveItem(context);
|
|
context.ItemMovement.SetDraggedItemIds([context.ActiveItem.Id]);
|
|
context.StateMachine.SetState(HoldItemAfterLongTap, context);
|
|
},
|
|
Exit: _ => { }
|
|
);
|
|
|
|
internal static State<GraphUiContext> HoldItemAfterLongTap
|
|
= new(
|
|
Enter: _ => { },
|
|
Update: context =>
|
|
{
|
|
Debug.Assert(context.ActiveItem != null);
|
|
|
|
if (!ImGui.IsMouseDown(ImGuiMouseButton.Left))
|
|
{
|
|
MagItemMovement.SelectActiveItem(context);
|
|
context.StateMachine.SetState(Default, context);
|
|
return;
|
|
}
|
|
|
|
if (ImGui.IsMouseDragging(ImGuiMouseButton.Left))
|
|
{
|
|
context.StateMachine.SetState(DragItems, context);
|
|
}
|
|
},
|
|
Exit: _ => { }
|
|
);
|
|
|
|
internal static State<GraphUiContext> DragItems
|
|
= new(
|
|
Enter: context =>
|
|
{
|
|
context.ItemMovement.PrepareDragInteraction();
|
|
context.ItemMovement.StartDragOperation(context);
|
|
},
|
|
Update: context =>
|
|
{
|
|
if (!ImGui.IsMouseDown(ImGuiMouseButton.Left))
|
|
{
|
|
context.ItemMovement.CompleteDragOperation(context);
|
|
|
|
context.StateMachine.SetState(Default, context);
|
|
return;
|
|
}
|
|
|
|
context.ItemMovement.UpdateDragging(context);
|
|
},
|
|
Exit: context => { context.ItemMovement.StopDragOperation(); }
|
|
);
|
|
|
|
/// <summary>
|
|
/// Active while long tapping on background for insertion
|
|
/// </summary>
|
|
internal static State<GraphUiContext> HoldOutput
|
|
= new(
|
|
Enter: _ => { },
|
|
Update: context =>
|
|
{
|
|
var sourceItem = context.ActiveItem;
|
|
Debug.Assert(sourceItem != null);
|
|
Debug.Assert(sourceItem.OutputLines.Length > 0);
|
|
Debug.Assert(context.ActiveSourceOutputId != Guid.Empty);
|
|
|
|
// Click
|
|
if (!ImGui.IsMouseDown(ImGuiMouseButton.Left))
|
|
{
|
|
if (context.TryGetActiveOutputLine(out var outputLine))
|
|
{
|
|
context.Placeholder.OpenForItemOutput(context, sourceItem, outputLine, context.ActiveOutputDirection);
|
|
context.StateMachine.SetState(Placeholder, context);
|
|
}
|
|
else
|
|
{
|
|
context.StateMachine.SetState(Default, context);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Start dragging...
|
|
if (ImGui.IsMouseDragging(ImGuiMouseButton.Left))
|
|
{
|
|
if (!context.TryGetActiveOutputLine(out var outputLine))
|
|
{
|
|
Log.Warning("Output not found?");
|
|
context.StateMachine.SetState(Default, context);
|
|
return;
|
|
}
|
|
|
|
AddTempConnectionsForOutputDrag(context, sourceItem, outputLine);
|
|
context.ActiveSourceItem = sourceItem;
|
|
context.DraggedPrimaryOutputType = outputLine.Output.ValueType;
|
|
context.StateMachine.SetState(DragConnectionEnd, context);
|
|
}
|
|
},
|
|
Exit: _ => { }
|
|
);
|
|
|
|
internal static State<GraphUiContext> HoldInput
|
|
= new(
|
|
Enter: _ => { },
|
|
Update: context =>
|
|
{
|
|
var sourceItem = context.ActiveItem;
|
|
Debug.Assert(sourceItem != null);
|
|
Debug.Assert(sourceItem.OutputLines.Length > 0 ||
|
|
sourceItem.Variant == MagGraphItem.Variants.Output);
|
|
Debug.Assert(context.ActiveTargetInputId != Guid.Empty);
|
|
|
|
// Click
|
|
var released = !ImGui.IsMouseDown(ImGuiMouseButton.Left);
|
|
if (released)
|
|
{
|
|
if (context.TryGetActiveInputLine(out var inputLine))
|
|
{
|
|
context.Placeholder.OpenForItemInput(context, context.ActiveTargetItem, inputLine.Id, context.ActiveInputDirection);
|
|
context.StateMachine.SetState(Placeholder, context);
|
|
}
|
|
else
|
|
{
|
|
context.StateMachine.SetState(Default, context);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Start dragging...
|
|
if (ImGui.IsMouseDragging(ImGuiMouseButton.Left))
|
|
{
|
|
if (context.TryGetActiveInputLine(out var draggedInputLine)
|
|
&& draggedInputLine.InputUi != null)
|
|
{
|
|
context.View.StartDraggingFromInput(context.ActiveTargetItem, draggedInputLine.InputUi.InputDefinition);
|
|
}
|
|
else
|
|
{
|
|
context.StateMachine.SetState(Default, context);
|
|
}
|
|
}
|
|
},
|
|
Exit: _ => { }
|
|
);
|
|
|
|
internal static State<GraphUiContext> HoldingConnectionEnd
|
|
= new(
|
|
Enter: _ => { },
|
|
Update: context =>
|
|
{
|
|
if (!ImGui.IsMouseDown(ImGuiMouseButton.Left))
|
|
{
|
|
context.Placeholder.OpenToSplitHoveredConnections(context); // Will change state implicitly
|
|
return;
|
|
}
|
|
|
|
if (ImGui.IsMouseDragging(ImGuiMouseButton.Left))
|
|
{
|
|
if (context.ConnectionHovering.ConnectionHoversWhenClicked.Count == 0)
|
|
return;
|
|
|
|
var connection = context.ConnectionHovering.ConnectionHoversWhenClicked[0].Connection;
|
|
context.ActiveSourceOutputId = connection.SourceOutput.Id;
|
|
|
|
// Remove existing connection
|
|
context.StartMacroCommand("Reconnect from input")
|
|
.AddAndExecCommand(new DeleteConnectionCommand(context.CompositionInstance.Symbol,
|
|
connection.AsSymbolConnection(),
|
|
connection.MultiInputIndex));
|
|
|
|
if (MagItemMovement.DisconnectedInputWouldCollapseLine(connection))
|
|
{
|
|
var collectSnappedItems = MagItemMovement.CollectSnappedItems(connection.TargetItem);
|
|
collectSnappedItems.Remove(connection.TargetItem);
|
|
MagItemMovement.MoveSnappedItemsVertically(context,
|
|
collectSnappedItems,
|
|
connection.TargetItem.PosOnCanvas.Y +
|
|
MagGraphItem.GridSize.Y * (connection.InputLineIndex + 0.5f),
|
|
-MagGraphItem.GridSize.Y);
|
|
}
|
|
// var deletedLineIndex = 0;
|
|
// var lines = connection.TargetItem.InputLines;
|
|
// while ( deletedLineIndex < lines.Length && lines[deletedLineIndex].Id != connection.TargetInput.Id)
|
|
// {
|
|
// deletedLineIndex++;
|
|
// }
|
|
|
|
var tempConnection = new MagGraphConnection
|
|
{
|
|
Style = MagGraphConnection.ConnectionStyles.Unknown,
|
|
SourcePos = connection.SourcePos,
|
|
TargetPos = default,
|
|
SourceItem = connection.SourceItem,
|
|
TargetItem = null,
|
|
SourceOutput = connection.SourceOutput,
|
|
OutputLineIndex = 0,
|
|
VisibleOutputIndex = 0,
|
|
ConnectionHash = 0,
|
|
IsTemporary = true,
|
|
WasDisconnected = true,
|
|
};
|
|
|
|
context.TempConnections.Add(tempConnection);
|
|
context.ActiveSourceItem = connection.SourceItem;
|
|
context.DraggedPrimaryOutputType = connection.Type;
|
|
context.ActiveItem = connection.SourceItem;
|
|
context.StateMachine.SetState(DragConnectionEnd, context);
|
|
context.Layout.FlagStructureAsChanged();
|
|
}
|
|
},
|
|
Exit: _ => { }
|
|
);
|
|
|
|
|
|
internal static State<GraphUiContext> DragConnectionEnd
|
|
= new(
|
|
Enter: _ => { },
|
|
Update: context =>
|
|
{
|
|
if (ImGui.IsKeyDown(ImGuiKey.Escape))
|
|
{
|
|
context.StateMachine.SetState(Default, context);
|
|
return;
|
|
}
|
|
|
|
var posOnCanvas = context.View.InverseTransformPositionFloat(ImGui.GetMousePos());
|
|
context.PeekAnchorInCanvas = posOnCanvas;
|
|
|
|
var mouseReleased = context.StateMachine.StateTime > 0 && ImGui.IsMouseReleased(ImGuiMouseButton.Left);
|
|
if (!mouseReleased)
|
|
return;
|
|
|
|
if (InputSnapper.TryToReconnect(context))
|
|
{
|
|
context.Layout.FlagStructureAsChanged();
|
|
context.CompleteMacroCommand();
|
|
context.StateMachine.SetState(Default, context);
|
|
return;
|
|
}
|
|
|
|
var hasDisconnections = context.TempConnections.Any(c => c.WasDisconnected);
|
|
|
|
var droppedOnItem = InputPicking.TryInitializeAtPosition(context, posOnCanvas);
|
|
if (droppedOnItem)
|
|
{
|
|
context.StateMachine.SetState(PickInput, context);
|
|
}
|
|
else if (hasDisconnections)
|
|
{
|
|
// Ripped off input -> Avoid open placeholder
|
|
//UndoRedoStack.Add(context.MacroCommand);
|
|
context.CompleteMacroCommand();
|
|
context.StateMachine.SetState(Default, context);
|
|
}
|
|
else
|
|
{
|
|
// Was dropped on operator or background...
|
|
context.Placeholder.OpenOnCanvas(context, posOnCanvas, context.DraggedPrimaryOutputType,
|
|
onlyMultiInputs: context.TempConnections.Count > 1);
|
|
context.StateMachine.SetState(Placeholder, context);
|
|
}
|
|
},
|
|
Exit: _ => { }
|
|
);
|
|
|
|
internal static State<GraphUiContext> PickInput
|
|
= new(
|
|
Enter: InputPicking.Init,
|
|
Update: InputPicking.DrawHiddenInputSelector,
|
|
Exit: InputPicking.Reset
|
|
);
|
|
|
|
internal static State<GraphUiContext> PickOutput
|
|
= new(
|
|
Enter: OutputPicking.Init,
|
|
Update => { }, //OutputPicking.DrawHiddenOutputSelector,
|
|
Exit: OutputPicking.Reset
|
|
);
|
|
|
|
|
|
internal static State<GraphUiContext> HoldingConnectionBeginning
|
|
= new(
|
|
Enter: _ => { },
|
|
Update: context =>
|
|
{
|
|
var wasClick = !ImGui.IsMouseDown(ImGuiMouseButton.Left);
|
|
if (wasClick)
|
|
{
|
|
context.Placeholder.OpenToSplitHoveredConnections(context); // Will change state implicitly
|
|
return;
|
|
}
|
|
|
|
if (ImGui.IsMouseDragging(ImGuiMouseButton.Left))
|
|
{
|
|
if (context.ConnectionHovering.ConnectionHoversWhenClicked.Count == 0)
|
|
return;
|
|
|
|
context.StartMacroCommand("Reconnect from output");
|
|
|
|
foreach (var h in context.ConnectionHovering.ConnectionHoversWhenClicked
|
|
.OrderByDescending(h => h.Connection.MultiInputIndex))
|
|
{
|
|
var connection = h.Connection;
|
|
|
|
context.DisconnectedInputHashes.Add(connection.GetItemInputHash()); // keep input visible until state is complete
|
|
|
|
// Remove existing connections
|
|
context.MacroCommand!
|
|
.AddAndExecCommand(new DeleteConnectionCommand(context.CompositionInstance.Symbol,
|
|
connection.AsSymbolConnection(),
|
|
h.Connection.MultiInputIndex));
|
|
|
|
//if (connection.MultiInputIndex > 0)
|
|
// continue;
|
|
|
|
var tempConnection = new MagGraphConnection
|
|
{
|
|
Style = MagGraphConnection.ConnectionStyles.Unknown,
|
|
TargetPos = connection.TargetPos,
|
|
TargetItem = connection.TargetItem,
|
|
InputLineIndex = connection.InputLineIndex,
|
|
MultiInputIndex = connection.MultiInputIndex,
|
|
SourceItem = null,
|
|
SourceOutput = null,
|
|
IsTemporary = true,
|
|
WasDisconnected = true,
|
|
};
|
|
|
|
// Sadly keeping disconnected multi input slots visible is tricky,
|
|
// so, this is only a preparation for a potential later implementation
|
|
//Log.Debug("Keep input hash " + connection.GetItemInputHash());
|
|
//context.DisconnectedInputsHashes.Add(connection.GetItemInputHash());
|
|
context.TempConnections.Add(tempConnection);
|
|
context.DraggedPrimaryOutputType = connection.Type;
|
|
}
|
|
|
|
context.Layout.FlagStructureAsChanged();
|
|
context.StateMachine.SetState(DragConnectionBeginning, context);
|
|
}
|
|
},
|
|
Exit:
|
|
_ => { }
|
|
);
|
|
|
|
internal static State<GraphUiContext> DragConnectionBeginning
|
|
= new(
|
|
Enter: _ => { },
|
|
Update: context =>
|
|
{
|
|
if (!ImGui.IsMouseDown(ImGuiMouseButton.Left))
|
|
{
|
|
if (OutputSnapper.TryToReconnect(context))
|
|
{
|
|
context.Layout.FlagStructureAsChanged();
|
|
context.CompleteMacroCommand();
|
|
context.StateMachine.SetState(Default, context);
|
|
return;
|
|
}
|
|
|
|
var hasDisconnections = context.TempConnections.Any(c => c.WasDisconnected);
|
|
if (hasDisconnections)
|
|
{
|
|
// Ripped off connection beginnings -> just keep them disconnected
|
|
context.CompleteMacroCommand();
|
|
context.StateMachine.SetState(Default, context);
|
|
}
|
|
else
|
|
{
|
|
// Dropped on background -> pick a new operator feeding the dragged input
|
|
var posOnCanvas = context.View.InverseTransformPositionFloat(ImGui.GetMousePos());
|
|
context.Placeholder.OpenOnCanvas(context, posOnCanvas, outputTypeFilter: context.DraggedPrimaryOutputType);
|
|
context.StateMachine.SetState(Placeholder, context);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (ImGui.IsKeyDown(ImGuiKey.Escape))
|
|
{
|
|
context.CancelMacroCommand();
|
|
context.Layout.FlagStructureAsChanged();
|
|
context.StateMachine.SetState(Default, context);
|
|
}
|
|
},
|
|
Exit: _ => { });
|
|
|
|
internal static State<GraphUiContext> RenameChild
|
|
= new(
|
|
Enter: _ => { },
|
|
Update: _ => { },
|
|
Exit: _ => { }
|
|
);
|
|
|
|
internal static State<GraphUiContext> RenameSection
|
|
= new(
|
|
Enter: _ => { },
|
|
Update: _ => { },
|
|
Exit: _ => { }
|
|
);
|
|
|
|
internal static State<GraphUiContext> DragSection
|
|
= new(
|
|
Enter: _ => { },
|
|
Update: _ => { },
|
|
Exit: _ => { }
|
|
);
|
|
|
|
internal static State<GraphUiContext> ResizeSection
|
|
= new(
|
|
Enter: _ => { },
|
|
Update: SectionResizing.Draw,
|
|
Exit: _ => { }
|
|
);
|
|
|
|
/// <summary>
|
|
/// Starts dragging temp connections from the picked output. If the dragged item is part of a multi-selection,
|
|
/// the primary outputs of all other selected operators with a matching type are picked up too, ordered by
|
|
/// canvas position, so they can be dropped onto a multi-input or the symbol browser together.
|
|
/// </summary>
|
|
private static void AddTempConnectionsForOutputDrag(GraphUiContext context, MagGraphItem sourceItem, MagGraphItem.OutputLine outputLine)
|
|
{
|
|
var draggedItems = new List<MagGraphItem> { sourceItem };
|
|
|
|
var outputType = outputLine.Output.ValueType;
|
|
if (context.Selector.IsSelected(sourceItem))
|
|
{
|
|
foreach (var item in context.Layout.Items.Values)
|
|
{
|
|
if (item == sourceItem
|
|
|| item.Variant != MagGraphItem.Variants.Operator
|
|
|| !context.Selector.IsSelected(item))
|
|
continue;
|
|
|
|
if (item.OutputLines.Length == 0 || item.OutputLines[0].Output.ValueType != outputType)
|
|
continue;
|
|
|
|
draggedItems.Add(item);
|
|
}
|
|
}
|
|
|
|
draggedItems.Sort(static (a, b) => a.PosOnCanvas.Y != b.PosOnCanvas.Y
|
|
? a.PosOnCanvas.Y.CompareTo(b.PosOnCanvas.Y)
|
|
: a.PosOnCanvas.X.CompareTo(b.PosOnCanvas.X));
|
|
|
|
for (var index = 0; index < draggedItems.Count; index++)
|
|
{
|
|
var item = draggedItems[index];
|
|
var itemOutputLine = item == sourceItem ? outputLine : item.OutputLines[0];
|
|
var posOnCanvas = item.PosOnCanvas + new Vector2(MagGraphItem.GridSize.X,
|
|
MagGraphItem.GridSize.Y * (1.5f + itemOutputLine.VisibleIndex));
|
|
|
|
context.TempConnections.Add(new MagGraphConnection
|
|
{
|
|
Style = MagGraphConnection.ConnectionStyles.Unknown,
|
|
SourcePos = posOnCanvas,
|
|
TargetPos = default,
|
|
SourceItem = item,
|
|
TargetItem = null,
|
|
SourceOutput = itemOutputLine.Output,
|
|
OutputLineIndex = itemOutputLine.VisibleIndex,
|
|
VisibleOutputIndex = 0,
|
|
ConnectionHash = 0,
|
|
IsTemporary = true,
|
|
MultiInputIndex = index,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
} |