private void StartElementMove(UIElement targetElementUserControl)
{
var targetElementId = _elements[targetElementUserControl].Id;
MouseEventHandler handleMouseMove = (object sender, MouseEventArgs eventArgs) =>
{
// move the element
var origin = targetElementUserControl.RenderTransformOrigin;
var mousePosition = Mouse.GetPosition(DesignCanvas);
var difference = new Point(mousePosition.X - origin.X, mousePosition.Y - origin.Y);
targetElementUserControl.RenderTransform = new TranslateTransform(difference.X, difference.Y);
// move its wires
var elementId = _elements[targetElementUserControl].Id;
_connections.Where(wireConnectionPair => wireConnectionPair.Value.IsConnectedTo(elementId))
.ForEach(wireConnectionPair =>
{
var(wire, connection) = ((wireConnectionPair.Key as WireUserControl) !, wireConnectionPair.Value);
var pinIndex = connection.FromId == targetElementId ? connection.FromPinIndex : connection.ToPinIndex;
var pin = (targetElementUserControl as IElementUserControl) !.Pins[pinIndex];
var newPinLocation = DesignCanvas.TranslatePoint(new Point(), pin);
if (connection.FromId == targetElementId)
{
wire.RebaseTo(new Point(-newPinLocation.X, -newPinLocation.Y));
}
else
{
wire.PointTo(new Point(-newPinLocation.X, -newPinLocation.Y));
}
});
};
public override void OnDrawCompleted(DesignCanvas canvas, DrawEventArgs args)
{
base.OnDrawCompleted(canvas, args);
if (_origin.HasValue && _anchor != _origin.Value)
{
var ds = args.DrawingSession;
var rescale = args.InverseScale;
var color = (Color)FindResource(canvas, DesignCanvas.StrokeColorKey);
var rect = Rectangle;
if (_drawRectangle)
{
ds.DrawRectangle(rect, color, strokeWidth: rescale);
}
else
{
ds.DrawEllipse(
.5f * (float)(rect.Left + rect.Right),
.5f * (float)(rect.Top + rect.Bottom),
.5f * (float)rect.Width,
.5f * (float)rect.Height,
color,
strokeWidth: rescale
);
}
}
}
public override void OnKeyUp(DesignCanvas canvas, KeyRoutedEventArgs args)
{
if (args.Key == VirtualKey.Menu)
{
_drawRectangle = false;
Cursor = DefaultCursor;
canvas.InvalidateCursor();
}
else if (args.Key == VirtualKey.Shift)
{
_linkAxes = false;
}
else if (args.Key == VirtualKey.Control)
{
_originAtCenter = false;
}
else if (args.Key == VirtualKey.Space)
{
_shouldMoveOrigin = false;
}
else
{
base.OnKeyUp(canvas, args);
return;
}
args.Handled = true;
canvas.Invalidate();
}
public override void OnPointerMoved(DesignCanvas canvas, PointerRoutedEventArgs args)
{
base.OnPointerMoved(canvas, args);
if (_origin.HasValue)
{
var pos = canvas.FromClientPosition(args.GetCurrentPoint(canvas).Position);
if (args.KeyModifiers.HasFlag(VirtualKeyModifiers.Shift))
{
pos = ClampToOrigin(pos, _origin.Value);
}
if (_shouldMoveOrigin)
{
_origin = new Point(
_origin.Value.X + pos.X - _anchor.X,
_origin.Value.Y + pos.Y - _anchor.Y);
}
_anchor = pos;
_points = Slicing.IntersectPaths(canvas.Layer, _origin.Value.ToVector2(), _anchor.ToVector2());
canvas.Invalidate();
}
Cursor = args.KeyModifiers.HasFlag(VirtualKeyModifiers.Menu) ? Cursors.KnifeWithPlus : DefaultCursor;
canvas.InvalidateCursor();
}
public override void OnPointerMoved(DesignCanvas canvas, PointerRoutedEventArgs args)
{
base.OnPointerMoved(canvas, args);
if (_origin.HasValue)
{
var pos = canvas.FromClientPosition(args.GetCurrentPoint(canvas).Position);
var snapAxis = UIBroker.Axis.XY;
if (args.KeyModifiers.HasFlag(VirtualKeyModifiers.Shift))
{
snapAxis = ClampToOrigin(pos, _origin.Value, out pos);
}
pos = UIBroker.SnapPointDirect(canvas.Layer, pos, 1f / canvas.ScaleFactor, snapAxis)
.ToPoint();
if (_shouldMoveOrigin)
{
_origin = new Point(
_origin.Value.X + pos.X - _anchor.X,
_origin.Value.Y + pos.Y - _anchor.Y);
}
_anchor = pos;
_points = GetPointsWithEndpoints(canvas.Layer, addIntersections: !args.KeyModifiers.HasFlag(VirtualKeyModifiers.Menu));
canvas.Invalidate();
}
}
public override void OnKeyDown(DesignCanvas canvas, KeyRoutedEventArgs args)
{
if (args.Key == VirtualKey.Menu)
{
if (TrySetLastOnCurveSmoothness(_path, false))
{
((App)Application.Current).InvalidateData();
}
}
else if (args.Key == VirtualKey.Space && _path != null)
{
_shouldMoveOnCurve = true;
}
else if (args.Key == VirtualKey.Escape)
{
var layer = canvas.Layer;
TryRemoveTrailingOffCurve(layer);
layer.ClearSelection();
((App)Application.Current).InvalidateData();
}
else
{
base.OnKeyDown(canvas, args);
return;
}
args.Handled = true;
}
public virtual void OnDrawCompleted(DesignCanvas canvas, DrawEventArgs args)
{
if (_snapResult != null)
{
var ds = args.DrawingSession;
var rescale = args.InverseScale;
var color = (Color)FindResource(canvas, DesignCanvas.SnapLineColorKey);
var halfSize = 2.5f * rescale;
var refPos = _snapResult.Position;
if (_snapResult.IsHighlightPosition)
{
ds.DrawCircle(refPos, 5.5f * rescale, color, strokeWidth: rescale);
}
else
{
foreach (var(p1, p2) in _snapResult.GetSnapLines())
{
ds.DrawLine(p1, p2, color, strokeWidth: rescale);
if (p1 != refPos)
{
ds.DrawLine(p1.X - halfSize, p1.Y - halfSize, p1.X + halfSize, p1.Y + halfSize, color, strokeWidth: rescale);
ds.DrawLine(p1.X - halfSize, p1.Y + halfSize, p1.X + halfSize, p1.Y - halfSize, color, strokeWidth: rescale);
}
if (p2 != refPos)
{
ds.DrawLine(p2.X - halfSize, p2.Y - halfSize, p2.X + halfSize, p2.Y + halfSize, color, strokeWidth: rescale);
ds.DrawLine(p2.X - halfSize, p2.Y + halfSize, p2.X + halfSize, p2.Y - halfSize, color, strokeWidth: rescale);
}
}
}
}
}
private async void OpenTabItem(Layout layout)
{
var canvas = await DesignCanvas.LoadLayout(layout);
var grid = new ScrollViewer
{
Background = Application.Current.Resources["RegionBrush"] as Brush,
Content = canvas,
HorizontalScrollBarVisibility = ScrollBarVisibility.Visible,
VerticalScrollBarVisibility = ScrollBarVisibility.Visible
};
var tabItem = new HandyControl.Controls.TabItem
{
Header = layout.DisplayName,
Content = grid,
ShowCloseButton = true,
IsSelected = true
};
tabItem.KeyUp += (sender, e) =>
{
if (e.Key != Key.F5)
{
return;
}
DesignCanvas.RefershDataSoure(canvas, layout);
};
tabControl.Items.Add(tabItem);
}
public override void OnPointerReleased(DesignCanvas canvas, PointerRoutedEventArgs args)
{
if (_origin.HasValue && _anchor != _origin.Value)
{
var rect = Rectangle;
var x1 = (float)rect.Left;
var y1 = (float)rect.Top;
var x2 = (float)rect.Right;
var y2 = (float)rect.Bottom;
Data.Path path;
if (_drawRectangle)
{
path = new Data.Path(
new List <Data.Point>()
{
new Data.Point(x1, y1, Data.PointType.Line),
new Data.Point(x2, y1, Data.PointType.Line),
new Data.Point(x2, y2, Data.PointType.Line),
new Data.Point(x1, y2, Data.PointType.Line),
}
);
}
else
{
var dx = x2 - x1;
var dy = y2 - y1;
var dot225dx = Outline.RoundToGrid(.225f * dx);
var dot5dx = Outline.RoundToGrid(.5f * dx);
var dot775dx = Outline.RoundToGrid(.775f * dx);
var dot225dy = Outline.RoundToGrid(.225f * dy);
var dot5dy = Outline.RoundToGrid(.5f * dy);
var dot775dy = Outline.RoundToGrid(.775f * dy);
path = new Data.Path(
new List <Data.Point>()
{
new Data.Point(x1 + dot225dx, y2),
new Data.Point(x1, y1 + dot775dy),
new Data.Point(x1, y1 + dot5dy, Data.PointType.Curve, isSmooth: true),
new Data.Point(x1, y1 + dot225dy),
new Data.Point(x1 + dot225dx, y1),
new Data.Point(x1 + dot5dx, y1, Data.PointType.Curve, isSmooth: true),
new Data.Point(x1 + dot775dx, y1),
new Data.Point(x2, y1 + dot225dy),
new Data.Point(x2, y1 + dot5dy, Data.PointType.Curve, isSmooth: true),
new Data.Point(x2, y1 + dot775dy),
new Data.Point(x1 + dot775dx, y2),
new Data.Point(x1 + dot5dx, y2, Data.PointType.Curve, isSmooth: true),
}
);
}
canvas.Layer.Paths.Add(path);
path.IsSelected = true;
}
base.OnPointerReleased(canvas, args);
}
public override object FindResource(DesignCanvas canvas, string resourceKey)
{
if (resourceKey == DesignCanvas.DrawCoordinatesKey)
{
return(true);
}
return(base.FindResource(canvas, resourceKey));
}
protected override void CompleteMove(DesignCanvas canvas)
{
base.CompleteMove(canvas);
_previousPoint = null;
Cursor = DefaultCursor;
canvas.InvalidateCursor();
}
public virtual void OnKeyDown(DesignCanvas canvas, KeyRoutedEventArgs args)
{
var control = Window.Current.CoreWindow.GetKeyState(VirtualKey.Control);
// TODO: batch and use the undoGroup reset thing on close enough keyboard moves
if (args.Key == VirtualKey.Left ||
args.Key == VirtualKey.Up ||
args.Key == VirtualKey.Right ||
args.Key == VirtualKey.Down)
{
int dx = 0, dy = 0;
if (args.Key == VirtualKey.Left)
{
dx = -1;
}
else if (args.Key == VirtualKey.Up)
{
dy = 1;
}
else if (args.Key == VirtualKey.Right)
{
dx = 1;
}
else if (args.Key == VirtualKey.Down)
{
dy = -1;
}
var shift = Window.Current.CoreWindow.GetKeyState(VirtualKey.Shift);
if (shift.HasFlag(CoreVirtualKeyStates.Down))
{
dx *= 10;
dy *= 10;
if (control.HasFlag(CoreVirtualKeyStates.Down))
{
dx *= 10;
dy *= 10;
}
}
var layer = canvas.Layer;
using (var group = layer.CreateUndoGroup())
{
Outline.MoveSelection(layer, dx, dy, GetMoveMode());
var selection = layer.Selection;
if (selection.Count == 1 && selection.First() is Data.Point point && Outline.TryJoinPath(layer, point))
{
DisplaySnapResult(
canvas, UIBroker.GetSnapHighlight(point));
}
else if (selection.OfType <Data.Point>().LastOrDefault() is Data.Point focusPoint)
{
DisplaySnapResult(
canvas, UIBroker.GetSnapLines(layer, focusPoint.ToVector2().ToPoint()));
}
}
public override void OnDisabled(DesignCanvas canvas, ActivationEventArgs args)
{
base.OnDisabled(canvas, args);
if (args.ActivationKind != ActivationKind.TemporarySwitch &&
TryRemoveTrailingOffCurve(canvas.Layer))
{
((App)Application.Current).InvalidateData();
}
}
protected override void CompleteMove(DesignCanvas canvas)
{
base.CompleteMove(canvas);
if (_points != null)
{
_points = null;
canvas.Invalidate();
}
_origin = null;
}
public override void OnPointerPressed(DesignCanvas canvas, PointerRoutedEventArgs args)
{
base.OnPointerPressed(canvas, args);
if (args.GetCurrentPoint(canvas).Properties.IsLeftButtonPressed)
{
_previousPoint = args.GetCurrentPoint(canvas).Position;
Cursor = Cursors.HandGrab;
canvas.InvalidateCursor();
}
}
public override void OnPointerReleased(DesignCanvas canvas, PointerRoutedEventArgs args)
{
if (_points != null)
{
var layer = canvas.Layer;
layer.ClearSelection();
Slicing.SlicePaths(layer, _origin.Value.ToVector2(), _anchor.ToVector2(),
breakPaths: !args.KeyModifiers.HasFlag(VirtualKeyModifiers.Menu));
}
base.OnPointerReleased(canvas, args);
}
protected override void CompleteMove(DesignCanvas canvas)
{
base.CompleteMove(canvas);
if (_undoGroup != null)
{
_undoGroup.Dispose();
_undoGroup = null;
((App)Application.Current).InvalidateData();
}
_origin = null;
}
public override void OnKeyUp(DesignCanvas canvas, KeyRoutedEventArgs args)
{
if (args.Key == VirtualKey.Space)
{
_shouldMoveOrigin = false;
}
else
{
base.OnKeyUp(canvas, args);
return;
}
args.Handled = true;
}
public override void OnPointerPressed(DesignCanvas canvas, PointerRoutedEventArgs args)
{
base.OnPointerPressed(canvas, args);
var ptPoint = args.GetCurrentPoint(canvas);
if (ptPoint.Properties.IsLeftButtonPressed && canvas.Layer is Data.Layer layer)
{
_undoGroup = layer.CreateUndoGroup();
_origin = _anchor = canvas.FromClientPosition(ptPoint.Position);
layer.ClearSelection();
((App)Application.Current).InvalidateData();
}
}
public override void OnPointerMoved(DesignCanvas canvas, PointerRoutedEventArgs args)
{
base.OnPointerMoved(canvas, args);
if (_previousPoint.HasValue)
{
var point = args.GetCurrentPoint(canvas).Position;
canvas.ScrollBy(
_previousPoint.Value.X - point.X,
_previousPoint.Value.Y - point.Y);
_previousPoint = point;
}
}
public override void OnPointerPressed(DesignCanvas canvas, PointerRoutedEventArgs args)
{
base.OnPointerPressed(canvas, args);
var ptPoint = args.GetCurrentPoint(canvas);
if (ptPoint.Properties.IsLeftButtonPressed)
{
var pos = canvas.FromClientPosition(ptPoint.Position);
_origin = _anchor = UIBroker.SnapPointDirect(canvas.Layer, pos, 1f / canvas.ScaleFactor)
.ToPoint();
canvas.Invalidate();
}
}
public override void OnPointerMoved(DesignCanvas canvas, PointerRoutedEventArgs args)
{
base.OnPointerMoved(canvas, args);
if (_origin.HasValue)
{
var pos = canvas.FromClientPosition(args.GetCurrentPoint(canvas).Position);
if (_shouldMoveOrigin)
{
var origin = _origin.Value;
origin.X += pos.X - _anchor.X;
origin.Y += pos.Y - _anchor.Y;
_origin = origin;
}
_anchor = pos;
canvas.Invalidate();
}
}
public override void OnDraw(DesignCanvas canvas, DrawEventArgs args)
{
base.OnDraw(canvas, args);
if (_points != null)
{
var ds = args.DrawingSession;
var rescale = args.InverseScale;
var color = Color.FromArgb(120, 38, 38, 38);
var radius = 3.5f * rescale;
foreach (var point in _points)
{
ds.FillCircle(point, radius, color);
}
ds.DrawLine(_origin.Value.ToVector2(), _anchor.ToVector2(), Color.FromArgb(120, 60, 60, 60), strokeWidth: rescale);
}
}
public override object FindResource(DesignCanvas canvas, string resourceKey)
{
if (resourceKey == DesignCanvas.DrawAnchorsKey ||
resourceKey == DesignCanvas.DrawGuidelinesKey ||
resourceKey == DesignCanvas.DrawLayersKey ||
resourceKey == DesignCanvas.DrawMetricsKey ||
resourceKey == DesignCanvas.DrawPointsKey ||
resourceKey == DesignCanvas.DrawSelectionKey ||
resourceKey == DesignCanvas.DrawStrokeKey)
{
return(false);
}
else if (resourceKey == DesignCanvas.ComponentColorKey ||
resourceKey == DesignCanvas.FillColorKey)
{
return(Colors.Black);
}
return(base.FindResource(canvas, resourceKey));
}
public override void OnKeyUp(DesignCanvas canvas, KeyRoutedEventArgs args)
{
if (args.Key == VirtualKey.Menu)
{
if (TrySetLastOnCurveSmoothness(_path, true))
{
((App)Application.Current).InvalidateData();
}
}
else if (args.Key == VirtualKey.Space)
{
_shouldMoveOnCurve = false;
}
else
{
base.OnKeyUp(canvas, args);
return;
}
args.Handled = true;
}
public override void OnKeyDown(DesignCanvas canvas, KeyRoutedEventArgs args)
{
if (args.Key == VirtualKey.Space && _origin != null)
{
_shouldMoveOrigin = true;
}
else if (args.Key == VirtualKey.Escape && _origin != null)
{
_origin = null;
_points = null;
canvas.Invalidate();
}
else
{
base.OnKeyDown(canvas, args);
return;
}
args.Handled = true;
}
public override void OnKeyDown(DesignCanvas canvas, KeyRoutedEventArgs args)
{
if (args.Key == VirtualKey.Menu)
{
_drawRectangle = true;
Cursor = Cursors.CrossWithRectangle;
canvas.InvalidateCursor();
}
else if (args.Key == VirtualKey.Shift)
{
_linkAxes = true;
}
else if (args.Key == VirtualKey.Control)
{
_originAtCenter = true;
}
else if (args.Key == VirtualKey.Space && _origin.HasValue)
{
_shouldMoveOrigin = true;
}
else if (args.Key == VirtualKey.Escape && _origin.HasValue)
{
_undoGroup.Reset();
_undoGroup.Dispose();
_undoGroup = null;
_origin = null;
((App)Application.Current).InvalidateData();
}
else
{
base.OnKeyDown(canvas, args);
return;
}
args.Handled = true;
canvas.Invalidate();
}
public virtual void OnDraw(DesignCanvas canvas, DrawEventArgs args)
{
}
public override void OnPointerPressed(DesignCanvas canvas, PointerRoutedEventArgs args)
{
base.OnPointerPressed(canvas, args);
var ptPoint = args.GetCurrentPoint(canvas);
if (ptPoint.Properties.IsLeftButtonPressed && canvas.Layer is Data.Layer layer)
{
var pos = canvas.FromClientPosition(ptPoint.Position);
// TODO: should we ignore Anchor/Component etc. here?
var tappedItem = canvas.HitTest(pos, testSegments: true);
var selPoint = GetSelectedPoint(layer);
_screenOrigin = ptPoint.Position;
_undoGroup = layer.CreateUndoGroup();
if (tappedItem is Data.Point tappedPoint && tappedPoint.Type != Data.PointType.None)
{
var tappedPath = tappedPoint.Parent;
if (Is.AtOpenBoundary(tappedPoint))
{
// If we click a boundary from another boundary, join the paths
if (selPoint != null && Is.AtOpenBoundary(selPoint) && AreVisiblyDistinct(canvas, selPoint, tappedPoint))
{
var selPath = selPoint.Parent;
var selPoints = selPath.Points;
if (selPoint.Type == Data.PointType.None)
{
selPoint.IsSelected = false;
selPoints.Pop();
var lastOn = selPoints.Last();
_stashedOffCurve = (selPoint, lastOn.IsSmooth);
lastOn.IsSmooth = false;
}
Outline.JoinPaths(selPath, selPoints[0] == selPoint,
tappedPath, tappedPath.Points[0] == tappedPoint);
// Drag a control point, except if we're joining a different path (as we're not at boundary
// of the resulting path)
if (selPath == tappedPath)
{
_path = selPath;
}
}
// Otherwise reverse the path if needed and we'll drag the boundary point
else
{
if (tappedPoint == tappedPath.Points.First())
{
tappedPath.Reverse();
}
_path = tappedPath;
}
}
// If we clicked on an inside point, just break its path open.
else
{
TryRemoveTrailingOffCurve(layer);
layer.ClearSelection();
Outline.BreakPath(tappedPath, tappedPath.Points.IndexOf(tappedPoint));
}
if (selPoint != null)
{
selPoint.IsSelected = false;
}
tappedPoint.IsSelected = true;
}
else if (tappedItem is Data.Segment segment)
{
var result = segment.ProjectPoint(pos.ToVector2());
if (result.HasValue)
{
var t = result.Value.Item2;
if (!args.KeyModifiers.HasFlag(VirtualKeyModifiers.Shift))
{
layer.ClearSelection();
}
var otherSegment = segment.SplitAt(t);
foreach (var point in Enumerable.Concat(segment.Points, otherSegment.OffCurves))
{
point.X = Outline.RoundToGrid(point.X);
point.Y = Outline.RoundToGrid(point.Y);
}
_point = segment.OnCurve;
_point.IsSelected = true;
_undoGroup.Dispose();
_undoGroup = layer.CreateUndoGroup();
}
}
else
{
ObserverList <Data.Point> points;
Data.PointType type;
// Add a point to the current path, if any
if (selPoint != null && Is.AtOpenBoundary(selPoint))
{
_path = selPoint.Parent;
points = _path.Points;
var lastPoint = points.Last();
lastPoint.IsSelected = false;
if (lastPoint.Type == Data.PointType.None)
{
points.Pop();
var lastOn = points.Last();
_stashedOffCurve = (lastPoint, lastOn.IsSmooth);
lastOn.IsSmooth = false;
// For shift origin, always use an onCurve
lastPoint = lastOn;
}
if (args.KeyModifiers.HasFlag(VirtualKeyModifiers.Shift))
{
pos = ClampToOrigin(pos, new Point(lastPoint.X, lastPoint.Y));
}
type = Data.PointType.Line;
}
// Else just create a new one
else
{
_path = new Data.Path();
points = _path.Points;
layer.Paths.Add(_path);
type = Data.PointType.Move;
}
// In any case, unselect all points (*click*) and enable new point
layer.ClearSelection();
var x = Outline.RoundToGrid((float)pos.X);
var y = Outline.RoundToGrid((float)pos.Y);
points.Add(new Data.Point(x, y, type)
{
IsSelected = true
});
}
((App)Application.Current).InvalidateData();
}
public override void OnDrawCompleted(DesignCanvas canvas, DrawEventArgs args)
{
base.OnDrawCompleted(canvas, args);
if (_points != null)
{
var ds = args.DrawingSession;
var rescale = args.InverseScale;
var backplateColor = Color.FromArgb(210, 60, 121, 100);
var color = Color.FromArgb(170, 60, 121, 100);
var radius = 3.5f * rescale;
var origin = _origin.Value.ToVector2();
var anchor = _anchor.ToVector2();
foreach (var point in _points)
{
ds.FillCircle(point, radius, color);
}
ds.DrawLine(origin, anchor, Color.FromArgb(170, 100, 161, 140), strokeWidth: rescale);
foreach (var(p1, p2) in _points.Zip(_points.Skip(1), (one, two) => (one, two)))
{
var delta = p2 - p1;
var length = MathF.Round(delta.Length(), 1);
if (length > 0)
{
Drawing.DrawText(ds, length.ToString(), p1 + .5f * delta, Colors.White, rescale: rescale, fontSize: 11,
backplateColor: backplateColor);
}
}
var vector = anchor - origin;
var angle = Conversion.FromVector(vector);
var deg = MathF.Round(Conversion.ToDegrees(angle), 1);
CanvasHorizontalAlignment hAlignment;
if (angle > Ops.PI_1_2 || angle < -Ops.PI_1_2)
{
hAlignment = CanvasHorizontalAlignment.Right;
}
else
{
hAlignment = CanvasHorizontalAlignment.Left;
}
CanvasVerticalAlignment vAlignment;
if (angle < -Ops.PI_1_2)
{
vAlignment = CanvasVerticalAlignment.Top;
}
else
{
if (angle < 0)
{
vector.Y = -vector.Y;
}
vAlignment = CanvasVerticalAlignment.Bottom;
}
Drawing.DrawText(ds, $"{deg}°", anchor + 20 * Vector2.Normalize(vector), Colors.White, rescale: rescale, fontSize: 11,
hAlignment: hAlignment, vAlignment: vAlignment, backplateColor: backplateColor);
}
}
