private void OnShaftPoint2Changed(object sender, PointChangedEventArgs e)
{
if (_enablePointChangeEvents)
{
EventsHelper.Fire(_endPointChanged, this, new PointChangedEventArgs(e.Point, e.CoordinateSystem));
}
}
private void _lineGraphic_Point1Changed(object sender, PointChangedEventArgs e)
{
if (_enableInternalEvent && _pointCount > 0)
{
this.NotifyPointChanged(0);
}
}
protected virtual void Line_PointChanged(object sender, PointChangedEventArgs e)
{
ResizeHandles.ForEach(h => h.Dispose());
ResizeHandles.Clear();
InitializeResizeHandle(provider);
IsGraphicsPathChanged = true;
}
private void OnSubjectPoint2Changed(object sender, PointChangedEventArgs e)
{
this.SuspendControlPointEvents();
this.CoordinateSystem = CoordinateSystem.Source;
try
{
this.ControlPoints[1] = this.Subject.Point2;
}
finally
{
this.ResetCoordinateSystem();
this.ResumeControlPointEvents();
}
}
private void OnSubjectBottomRightChanged(object sender, PointChangedEventArgs e)
{
this.SuspendControlPointEvents();
this.CoordinateSystem = CoordinateSystem.Source;
try
{
RectangleF rect = this.Subject.Rectangle;
this[_topRight] = new PointF(rect.Right, rect.Top);
this[_bottomRight] = new PointF(rect.Right, rect.Bottom);
this[_bottomLeft] = new PointF(rect.Left, rect.Bottom);
}
finally
{
this.ResetCoordinateSystem();
this.ResumeControlPointEvents();
}
}
private void OnSubjectChanged(object sender, PointChangedEventArgs e)
{
this.SuspendControlPointEvents();
this.CoordinateSystem = CoordinateSystem.Source;
try
{
RectangleF rect = this.Subject.Rectangle;
float halfWidth = rect.Width / 2;
float halfHeight = rect.Height / 2;
this[_top] = new PointF(rect.Left + halfWidth, rect.Top);
this[_bottom] = new PointF(rect.Left + halfWidth, rect.Bottom);
this[_left] = new PointF(rect.Left, rect.Top + halfHeight);
this[_right] = new PointF(rect.Right, rect.Top + halfHeight);
}
finally
{
this.ResetCoordinateSystem();
this.ResumeControlPointEvents();
}
}
/// <summary>
/// Invoked when a point has changed.
/// </summary>
/// <param name="source">The source of the event.</param>
/// <param name="args">The event arguments.</param>
void OnPointChanged(Point2D source, PointChangedEventArgs args)
{
OnChanged();
}
/// <summary>
/// Invoked when a dependent point has changed in order
/// to update the dependency.
/// </summary>
/// <param name="source">The source of the change.</param>
/// <param name="args">The event arguments.</param>
void OnDependentPointChanged(TouchPoint source, PointChangedEventArgs args)
{
Point oldPosition = this._position;
Point newPosition = new Point(oldPosition.X + args.DeltaX, oldPosition.Y + args.DeltaY);
//this.X = this.X + args.DeltaX;
//this.Y = this.Y + args.DeltaY;
this._position = newPosition;
OnPropertyChanged(() => X);
OnPropertyChanged(() => Y);
OnChanged(oldPosition, newPosition);
}
/// <summary>
/// Invoked when a point has changed.
/// </summary>
/// <param name="source">The source of the change.</param>
/// <param name="args">The event arguments.</param>
private void OnPointChanged(TouchPoint source, PointChangedEventArgs args)
{
// Manually update the disconnected point
var disconnectedPoint = DisconnectedPoint;
// Check whether the disconnectedPoint is not the source of the event, as the event will be raised when the point has just been disconnected.
// Furthermore, we need two touch points to update the third disconnected point.
if (disconnectedPoint != null && disconnectedPoint != source)
{
// We need to update one of the other two points that define the bottom line of the tangible object.
// One of the known touch points is the source.
// Now we need to find the other touch point that has contact.
var knownPoint = Points.Single(p => p != source && p != disconnectedPoint);
Windows.Foundation.Point reconstructedPoint;
Tuple<Windows.Foundation.Point, Windows.Foundation.Point> reconstructedPoints;
if (source.IsDirectionPoint)
{
// We know the direction point (source) and one of the points from the bottom line (knownPoint).
// As both points are symmetric we only need to consider one case.
reconstructedPoints = MathHelper.GetThirdPointOfTriangle(source, knownPoint, DistanceToDirectionPoint, BottomLineLength);
}
else
{
// We have one known point from the bottom line and the direction point.
if (disconnectedPoint.IsDirectionPoint)
{
// We know the points from the bottom line (source, knownPoint).
// We search for the direction point.
reconstructedPoints = MathHelper.GetThirdPointOfTriangle(source, knownPoint, DistanceToDirectionPoint, DistanceToDirectionPoint);
}
else
{
// We know one point from the bottom line (source) and the direction point (knownPoint)
reconstructedPoints = MathHelper.GetThirdPointOfTriangle(source, knownPoint, BottomLineLength, DistanceToDirectionPoint);
}
}
// As we have two solutions, we need the one that is closer to the previous value
// of the disconnected point.
reconstructedPoint = new List<Windows.Foundation.Point>()
{
reconstructedPoints.Item1, reconstructedPoints.Item2
}.MinDistanceTo(disconnectedPoint);
// Update the disconnected point.
// NOT WORKING !!!
// disconnectedPoint.UpdateDisconnectedPoint(reconstructedPoint.X, reconstructedPoint.Y);
}
// Update the top line.
var directionPoint = Points.Single(p => p.IsDirectionPoint);
var bottomLinePoints = Points.Where(p => !p.IsDirectionPoint).ToArray();
if (bottomLinePoints.Count() > 2)
throw new InvalidOperationException("The tangible object has unsufficient points.");
var topLine = CalculateTopLine(bottomLinePoints[0], bottomLinePoints[1], directionPoint);
_topLine.Update(topLine);
}