public override void HandleInput()
{
if (canvas.isCreatingConnection)
{
if (e.IsMouseDown(MouseButton.Left))
{
var source = canvas.connectionSource;
var destination = source.CompatiblePort(unit);
if (destination != null)
{
UndoUtility.RecordEditedObject("Connect Units");
source.ValidlyConnectTo(destination);
canvas.connectionSource = null;
canvas.Widget(source.unit).Reposition();
canvas.Widget(destination.unit).Reposition();
GUI.changed = true;
}
e.Use();
}
else if (e.IsMouseDown(MouseButton.Right))
{
canvas.CancelConnection();
e.Use();
}
}
base.HandleInput();
}
public void Delete()
{
if (!canDelete)
{
return;
}
var deleted = false;
var deleteGroup = new HashSet <IGraphElement>(new IGraphElement[] { element });
canvas.Widget(element).ExpandDeleteGroup(deleteGroup);
foreach (var elementToDelete in deleteGroup)
{
if (canvas.Widget(elementToDelete).canDelete)
{
UndoUtility.RecordEditedObject("Delete Graph Element");
element.graph.elements.Remove(elementToDelete);
selection.Remove(elementToDelete);
deleted = true;
}
}
if (deleted)
{
GUI.changed = true;
e.Use();
}
}
public void PerformDragAndDrop()
{
UndoUtility.RecordEditedObject("Drag & Drop Macro");
state.nest.source = GraphSource.Macro;
state.nest.macro = DragAndDropUtility.Get <StateGraphAsset>();
state.nest.embed = null;
GUI.changed = true;
}
public void PerformDragAndDrop()
{
UndoUtility.RecordEditedObject("Drag & Drop Macro");
unit.nest.source = GraphSource.Macro;
unit.nest.macro = DragAndDropUtility.Get <ScriptGraphAsset>();
unit.nest.embed = null;
unit.Define();
GUI.changed = true;
}
public void AddUnit(IUnit unit, Vector2 position)
{
UndoUtility.RecordEditedObject("Create Unit");
unit.guid = Guid.NewGuid();
unit.position = position.PixelPerfect();
graph.units.Add(unit);
selection.Select(unit);
GUI.changed = true;
}
public void AddState(IState state, Vector2 position)
{
UndoUtility.RecordEditedObject("Create State");
state.position = position;
graph.states.Add(state);
state.position -= this.Widget(state).position.size / 2;
state.position = state.position.PixelPerfect();
this.Widget(state).Reposition();
selection.Select(state);
GUI.changed = true;
}
public void EndTransition(IState destination)
{
UndoUtility.RecordEditedObject("Create State Transition");
var transition = FlowStateTransition.WithDefaultTrigger(transitionSource, destination);
graph.transitions.Add(transition);
transitionSource = null;
this.Widget(transition).BringToFront();
selection.Select(transition);
GUI.changed = true;
}
public static void PasteInside(IGraphElement element)
{
Ensure.That(nameof(element)).IsNotNull(element);
if (!CanPasteInside(element))
{
throw new InvalidOperationException();
}
UndoUtility.RecordEditedObject("Paste Graph Element");
throw new NotImplementedException();
//GUI.changed = true;
//e?.TryUse();
}
private void RemoveConnections()
{
UndoUtility.RecordEditedObject("Disconnect Port");
foreach (var connectedPort in port.connectedPorts)
{
canvas.Widget(connectedPort.unit).Reposition();
}
unitWidget.Reposition();
port.Disconnect();
e.Use();
GUI.changed = true;
}
private void FinishConnection(IUnitPort source, IUnitPort destination)
{
if (source.CanValidlyConnectTo(destination))
{
UndoUtility.RecordEditedObject("Connect Nodes");
source.ValidlyConnectTo(destination);
canvas.connectionSource = null;
canvas.Widget(source.unit).Reposition();
canvas.Widget(destination.unit).Reposition();
GUI.changed = true;
}
else
{
Debug.LogWarningFormat
(
"Cannot connect this {0} to this {1}.\n",
source.GetType().HumanName().ToLower(),
destination.GetType().HumanName().ToLower()
);
}
}
private void ReplaceUnit()
{
var oldUnit = unit;
var unitPosition = oldUnit.position;
var preservation = UnitPreservation.Preserve(oldUnit);
var options = new UnitOptionTree(new GUIContent("Unit"));
options.reference = reference;
var activatorPosition = new Rect(e.mousePosition, new Vector2(200, 1));
var context = this.context;
LudiqGUI.FuzzyDropdown
(
activatorPosition,
options,
null,
delegate(object _option)
{
var option = (IUnitOption)_option;
context.BeginEdit();
UndoUtility.RecordEditedObject("Replace Unit");
var graph = oldUnit.graph;
oldUnit.graph.units.Remove(oldUnit);
var newUnit = option.InstantiateUnit();
newUnit.guid = Guid.NewGuid();
newUnit.position = unitPosition;
graph.units.Add(newUnit);
preservation.RestoreTo(newUnit);
option.PreconfigureUnit(newUnit);
selection.Select(newUnit);
GUI.changed = true;
context.EndEdit();
}
);
}
public static void DuplicateSelection()
{
object singleClipboardRestore = null;
object groupClipboardRestore = null;
if (singleClipboard.containsData)
{
singleClipboardRestore = singleClipboard.Paste();
}
if (groupClipboard.containsData)
{
groupClipboardRestore = groupClipboard.Paste();
}
UndoUtility.RecordEditedObject("Duplicate Graph Element Selection");
CopySelection();
PasteOutside(false);
if (singleClipboardRestore != null)
{
singleClipboard.Copy(singleClipboardRestore);
}
else
{
singleClipboard.Clear();
}
if (groupClipboardRestore != null)
{
groupClipboard.Copy(groupClipboardRestore);
}
else
{
groupClipboard.Clear();
}
}
public static void CutSelection()
{
UndoUtility.RecordEditedObject("Cut Graph Element Selection");
CopySelection();
canvas.DeleteSelection();
}
public void RecordUndo(string name)
{
UndoUtility.RecordEditedObject(name);
}
public static void PasteOutside(bool reposition, Vector2?position = null)
{
if (!canPasteOutside)
{
throw new InvalidOperationException();
}
UndoUtility.RecordEditedObject("Paste Graph Elements");
var pastedElements = GetPasteGroup();
// Assign new GUIDs
foreach (var pastedElement in pastedElements)
{
pastedElement.guid = Guid.NewGuid();
}
// Add elements to graph and selection
selection.Clear();
foreach (var pastedElement in pastedElements)
{
if (!pastedElement.HandleDependencies())
{
continue;
}
graph.elements.Add(pastedElement);
selection.Add(pastedElement);
}
canvas.Cache();
foreach (var pastedElement in pastedElements)
{
var pastedWidget = canvas.Widget(pastedElement);
pastedWidget.BringToFront();
}
var pastedWidgets = pastedElements.Select(e => canvas.Widget(e)).ToList();
// Recenter elements in graph view
if (reposition)
{
var area = GraphGUI.CalculateArea(pastedWidgets.Where(widget => widget.canDrag));
Vector2 delta;
if (position.HasValue)
{
delta = position.Value - area.position;
}
else
{
delta = graph.pan - area.center;
}
foreach (var pastedWidget in pastedWidgets)
{
if (pastedWidget.canDrag)
{
pastedWidget.position = new Rect(pastedWidget.position.position + delta, pastedWidget.position.size).PixelPerfect();
pastedWidget.Reposition();
pastedWidget.CachePositionFirstPass();
pastedWidget.CachePosition();
}
}
}
// Space out overlapping elements
foreach (var pastedWidget in pastedWidgets)
{
if (pastedWidget.canDrag)
{
var distanciation = 20;
var timeout = 100;
var timeoutIndex = 0;
while (GraphGUI.PositionOverlaps(canvas, pastedWidget, 5))
{
// Space the widget out
pastedWidget.position = new Rect(pastedWidget.position.position + new Vector2(distanciation, distanciation), pastedWidget.position.size).PixelPerfect();
// Calculate the resulting position immediately
pastedWidget.CachePositionFirstPass();
pastedWidget.CachePosition();
// Mark it as invalid still so dependencies like ports will be recached
pastedWidget.Reposition();
// Failsafe to keep the editor from freezing
if (++timeoutIndex > timeout)
{
Debug.LogWarning($"Failed to space out pasted element: {pastedWidget.element}");
break;
}
}
}
}
canvas.Cache();
GUI.changed = true;
e?.TryUse();
}
private void HandleResizing()
{
if (e.IsMouseDrag(MouseButton.Left) && !isResizing && canStartResize)
{
if (resizeLeftArea.Contains(mousePosition))
{
isResizingXMin = true;
xMinResizeOffset = mousePosition.x - position.xMin;
}
if (resizeRightArea.Contains(mousePosition))
{
isResizingXMax = true;
xMaxResizeOffset = mousePosition.x - position.xMax;
}
if (resizeTopArea.Contains(mousePosition))
{
isResizingYMin = true;
yMinResizeOffset = mousePosition.y - position.yMin;
}
if (resizeBottomArea.Contains(mousePosition))
{
isResizingYMax = true;
yMaxResizeOffset = mousePosition.y - position.yMax;
}
if (resizeTopLeftArea.Contains(mousePosition))
{
isResizingXMin = true;
isResizingYMin = true;
xMinResizeOffset = mousePosition.x - position.xMin;
yMinResizeOffset = mousePosition.y - position.yMin;
}
if (resizeTopRightArea.Contains(mousePosition))
{
isResizingXMax = true;
isResizingYMin = true;
xMaxResizeOffset = mousePosition.x - position.xMax;
yMinResizeOffset = mousePosition.y - position.yMin;
}
if (resizeBottomLeftArea.Contains(mousePosition))
{
isResizingXMin = true;
isResizingYMax = true;
xMinResizeOffset = mousePosition.x - position.xMin;
yMaxResizeOffset = mousePosition.y - position.yMax;
}
if (resizeBottomRightArea.Contains(mousePosition))
{
isResizingXMax = true;
isResizingYMax = true;
xMaxResizeOffset = mousePosition.x - position.xMax;
yMaxResizeOffset = mousePosition.y - position.yMax;
}
e.Use();
}
else if (e.IsMouseDrag(MouseButton.Left) && isResizing)
{
var resizedPosition = position;
if (isResizingXMin)
{
resizedPosition.xMin = Mathf.Min(position.xMax - minResizeSize.x, mousePosition.x - xMinResizeOffset);
if (snapToGrid)
{
resizedPosition.xMin = GraphGUI.SnapToGrid(resizedPosition.xMin);
}
}
if (isResizingXMax)
{
resizedPosition.xMax = Mathf.Max(position.xMin + minResizeSize.x, mousePosition.x - xMaxResizeOffset);
if (snapToGrid)
{
resizedPosition.xMax = GraphGUI.SnapToGrid(resizedPosition.xMax);
}
}
if (isResizingYMin)
{
resizedPosition.yMin = Mathf.Min(position.yMax - minResizeSize.y, mousePosition.y - yMinResizeOffset);
if (snapToGrid)
{
resizedPosition.yMin = GraphGUI.SnapToGrid(resizedPosition.yMin);
}
}
if (isResizingYMax)
{
resizedPosition.yMax = Mathf.Max(position.yMin + minResizeSize.y, mousePosition.y - yMaxResizeOffset);
if (snapToGrid)
{
resizedPosition.yMax = GraphGUI.SnapToGrid(resizedPosition.yMax);
}
}
resizedPosition.width = Mathf.Clamp(resizedPosition.width, minResizeSize.x, maxResizeSize.x);
resizedPosition.height = Mathf.Clamp(resizedPosition.height, minResizeSize.y, maxResizeSize.y);
UndoUtility.RecordEditedObject("Resize Graph Element");
position = resizedPosition;
Reposition();
e.Use();
}
else if (e.IsMouseUp(MouseButton.Left) && isResizing)
{
isResizingXMin = false;
isResizingXMax = false;
isResizingYMin = false;
isResizingYMax = false;
e.Use();
}
}
protected void ToggleStart()
{
UndoUtility.RecordEditedObject("Toggle State Start");
state.isStart = !state.isStart;
}
