private void OnMoved()
{
if (Moved != null)
{
Moved.Invoke(this);
}
}
/// <summary>
/// Move Items[i] downward until it is less than or equal to its children.
/// </summary>
/// <param name="i"></param>
public void SiftDown(int i)
{
int left = Left(i);
int right = Right(i);
int smallest;
// find the smallest of i and its two children.
if ((left < Count) && LessThan(left, i))
{
smallest = left;
}
else
{
smallest = i;
}
if ((right < Count) && LessThan(right, smallest))
{
smallest = right;
}
if (smallest != i)
{
T item = Items[i];
Items[i] = Items[smallest];
Items[smallest] = item;
SiftDown(smallest);
}
Moved?.Invoke(Items[i], i);
}
private void CenterKnob_Completed(object sender, object e)
{
Angle = Distance = previousAngle = previousDistance = 0;
Moved?.Invoke(this, new JoypadEventArgs {
Angle = Angle, Distance = Distance
});
}
public void NotifyMovement(double deltaX, double deltaY)
{
Moved?.Invoke(new MovedEventArgs()
{
DeltaX = deltaX, DeltaY = deltaY
});
}
private void Knob_MouseMove(object sender, MouseEventArgs e)
{
if (!Knob.IsMouseCaptured)
{
return;
}
Point newPos = e.GetPosition(Base);
Point deltaPos = new Point(newPos.X - _startPos.X, newPos.Y - _startPos.Y);
double distance = Math.Round(Math.Sqrt(deltaPos.X * deltaPos.X + deltaPos.Y * deltaPos.Y));
if (distance >= canvasWidth / 2 || distance >= canvasHeight / 2)
{
return;
}
Aileron = Math.Round(-deltaPos.Y / 124, 2);
Elevator = Math.Round(deltaPos.X / 124, 2);
knobPosition.X = deltaPos.X;
knobPosition.Y = deltaPos.Y;
if (Moved == null ||
(!(Math.Abs(_prevAileron - Aileron) > AileronStep) && !(Math.Abs(_prevElevator - Elevator) > ElevatorStep)))
{
return;
}
Moved?.Invoke(this, new VirtualJoystickEventArgs {
Aileron = Aileron, Elevator = Elevator
});
_prevAileron = Aileron;
_prevElevator = Elevator;
}
private void Knob_MouseMove(object sender, MouseEventArgs e)
{
if (!Knob.IsMouseCaptured) return;
Point newPos = e.GetPosition(Base);
Point deltaPos = new Point(newPos.X - _startPos.X, newPos.Y - _startPos.Y);
double distance = Math.Round(Math.Sqrt(deltaPos.X * deltaPos.X + deltaPos.Y * deltaPos.Y));
if (distance >= canvasWidth / 2 || distance >= canvasHeight / 2)
return;
Elevator = -deltaPos.Y / 124;
Aileron = deltaPos.X / 124;
string setElevator = "set controls/flight/elevator " + Elevator;
Model.Client.getInstance().Write(setElevator);
string setAileron = "set controls/flight/aileron " + Aileron;
Model.Client.getInstance().Write(setAileron);
knobPosition.X = deltaPos.X;
knobPosition.Y = deltaPos.Y;
if (Moved == null ||
(!(Math.Abs(_prevAileron - Aileron) > AileronStep) && !(Math.Abs(_prevElevator - Elevator) > ElevatorStep)))
return;
Moved?.Invoke(this, new VirtualJoystickEventArgs { Aileron = Aileron, Elevator = Elevator });
_prevAileron = Aileron;
_prevElevator = Elevator;
}
protected override void OnDragDelta(double horizontalChange, double verticalChange)
{
if (!ParentLayer.IsLoaded)
{
this.ReleaseMouseCapture();
return;
}
ParentLayer.CancelNextSelect();
if (ParentLayer.Parent is IStoryboard)
{
Point canvasPosition = ApplyPositionDelta(
new Point(horizontalChange, verticalChange));
Canvas.SetLeft(Target, canvasPosition.X);
Canvas.SetTop(Target, canvasPosition.Y);
}
else
{
Thickness margin = ApplyMarginDelta(
new Point(horizontalChange, verticalChange));
// Snap with Set
ParentLayer.SetMargin(margin);
}
Moved?.Invoke(this, null);
}
protected override void positionUpdated()
{
if (Moved != null)
{
Moved.Invoke(this.Owner.Translation);
}
}
internal void _fireWindowMoved()
{
if (Moved != null)
{
Moved.Invoke(this);
}
}
protected override void Awake()
{
base.Awake();
disc.EndDragging += () =>
{
dragBack = true;
Moved?.Invoke(this, 0);
lines.Reset();
currentAngle = null;
};
disc.StartDragging += () =>
{
dragBack = false;
};
link.Color = Color.cyan.WithAlpha(0.8f);
link.EmissiveColor = Color.cyan;
ringUp.Color = Color.cyan.WithAlpha(0.5f);
ringUp.EmissiveColor = Color.cyan;
ringDown.Color = Color.cyan.WithAlpha(0.5f);
ringDown.EmissiveColor = Color.cyan;
lines = ResourcePool.RentDisplay <LineResource>(transform);
lines.ElementScale = 0.02f;
lines.RenderType = LineResource.LineRenderType.AlwaysCapsule;
}
private void OnMoved(Move i_Move)
{
if (Moved != null)
{
Moved.Invoke(i_Move);
}
}
private void Knob_MouseMove(object sender, MouseEventArgs e)
{
if (!Knob.IsMouseCaptured)
{
return;
}
Point newPos = e.GetPosition(Base);
Point deltaPos = new Point(newPos.X - _startPos.X, newPos.Y - _startPos.Y);
double distance = Math.Round(Math.Sqrt(deltaPos.X * deltaPos.X + deltaPos.Y * deltaPos.Y));
if (distance >= canvasWidth / 2 || distance >= canvasHeight / 2)
{
return;
}
Rudder = this.normelize((canvasWidth / 2), 1, deltaPos.X);
Elevator = this.normelize((canvasWidth / 2), 1, -deltaPos.Y);
knobPosition.X = deltaPos.X;
knobPosition.Y = deltaPos.Y;
if (Moved == null || (!(Math.Abs(_prevRudder - Rudder) > RudderStep) &&
!(Math.Abs(_prevElevator - Elevator) > ElevatorStep)))
{
return;
}
Moved?.Invoke(this, new VirtualJoystickEventArgs {
Rudder = Rudder, Elevator = Elevator
});
_prevRudder = Rudder;
_prevElevator = Elevator;
}
private void Knob_MouseMove(object sender, System.Windows.Input.MouseEventArgs e)
{
if (!Knob.IsMouseCaptured)
{
return;
}
knob_point.X = e.GetPosition(this).X - knob_first_point.X;
knob_point.Y = e.GetPosition(this).Y - knob_first_point.Y;
double knob_dist = Math.Round(Math.Sqrt(knob_point.X * knob_point.X + knob_point.Y * knob_point.Y));
if (knob_dist >= canvasHeight / 2 || knob_dist >= canvasWidth / 2)
{
return;
}
knobPosition.X = knob_point.X;
knobPosition.Y = knob_point.Y;
// convert the X,Y coordinates to range [-1,1]
X = knobPosition.X / 123;
Y = -knobPosition.Y / 123;
if (Moved == null)
{
return;
}
Moved?.Invoke(this, new JoystickEventArgs {
X = X, Y = Y
});
}
void OnAnchorsChanged(ARAnchorsChangedEventArgs args)
{
if (args.updated.Contains(Anchor))
{
Moved?.Invoke(Pose);
}
}
public void ConsumeMouseMove(MouseMoveEventArgs obj)
{
if (_window.MouseState.IsButtonDown(MouseButton.Left))
{
Moved?.Invoke(this, CreateFinger(FingerStatus.Moving));
}
}
public void Move(double left, double top)
{
void MoveAnimation(double value, DependencyProperty property, Action <UIElement, double> setter)
{
MoveStarted?.Invoke(this, EventArgs.Empty);
var anim = new DoubleAnimation(value, new Duration(TimeSpan.FromSeconds(0.5)))
{
FillBehavior = FillBehavior.Stop
};
anim.Completed += (sender, args) =>
{
setter(this, value);
Moved?.Invoke(this, args);
};
BeginAnimation(property, anim);
}
if (Math.Abs(Canvas.GetLeft(this) - left) > double.Epsilon)
{
MoveAnimation(left, Canvas.LeftProperty, Canvas.SetLeft);
}
if (Math.Abs(Canvas.GetTop(this) - top) > double.Epsilon)
{
MoveAnimation(top, Canvas.TopProperty, Canvas.SetTop);
}
}
public void Update()
{
if (!IsEnabled)
{
return;
}
if (Input.GetKeyDown(_key))
{
Begin?.Invoke(this, _lastPosition = Input.mousePosition);
}
else if (Input.GetKey(_key))
{
Vector3 currentMousePosition = Input.mousePosition;
if (_lastPosition != currentMousePosition)
{
Moved?.Invoke(this, currentMousePosition);
_lastPosition = currentMousePosition;
}
Pressed?.Invoke(this, currentMousePosition);
}
else if (Input.GetKeyUp(_key))
{
Ended?.Invoke(this, Input.mousePosition);
_lastPosition = Vector3.zero;
}
}
private void CenterSlider_Completed(object sender, object e)
{
Distance = previousDistance = 0;
Moved?.Invoke(this, new SliderEventArgs {
Distance = Distance
});
}
public void Move(Direction direction)
{
MazeLocation oldLocation = Location.Clone();
switch (direction)
{
case Direction.Right:
Location.Column++;
break;
case Direction.Down:
Location.Row++;
break;
case Direction.Left:
Location.Column--;
break;
case Direction.Up:
Location.Row--;
break;
}
SetPosition();
Moved?.Invoke(this, oldLocation);
}
public void MovePolygon(int x, int y)
{
if (!isMoveable)
{
return;
}
int xDiff = 0;
int yDiff = 0;
foreach (var vertex in vertexes)
{
vertex.X += x;
vertex.Y += y;
if (vertex.X <= xDiff)
{
xDiff = vertex.X;
}
if (vertex.Y <= yDiff)
{
yDiff = vertex.Y;
}
}
foreach (var vertex in vertexes)
{
vertex.X -= xDiff;
vertex.Y -= yDiff;
}
Moved?.Invoke(x + xDiff, y + yDiff);
}
void Update()
{
if (_enabled)
{
if (_jumpCooldown == 0)
{
var horiz = Input.GetAxis("Horizontal");
var force = Vector3.right * horiz * _magnitude * Time.deltaTime;
_rb.AddForce(force, ForceMode.VelocityChange);
if (horiz > 0.1)
{
Moved?.Invoke(this, EventArgs.Empty);
}
}
if (_jumpCooldown > 0)
{
_jumpCooldown -= Time.deltaTime;
if (_jumpCooldown < 0)
{
_jumpCooldown = 0;
}
}
if (_jumpEnabled && _jumpCooldown == 0 && (Input.GetButtonDown("Fire1") || Input.GetButtonDown("Fire2")))
{
_jumpCooldown = 1;
_rb.AddForce(Vector3.up * _magnitude / 2, ForceMode.Impulse);
}
}
}
private void OnLocationUpdated(MvxGeoLocation newLocation)
{
Moved?.Invoke(this,
new LocationMovedEventArgs
{
Location = newLocation
});
}
public void OnDrag(MouseEventArgs e)
{
if (Moving)
{
Position += e.DistanceMoved;
Moved?.Invoke(this, e);
}
}
public override void Move(int Position_x_new, int Position_y_new)
{
base.Move(Position_x_new, Position_y_new);
if (Moved != null)
{
Moved.Invoke();
}
}
private void Watcher_Renamed(object sender, RenamedEventArgs e)
{
if (Moved != null)
{
var Args = new MovedArticleEventArgs(this, e.OldFullPath, e.FullPath);
Moved.Invoke(this, Args);
}
}
protected override void OnValueChanged(double oldValue, double newValue)
{
base.OnValueChanged(oldValue, newValue);
if (IsUnison && _canDrag && (_isDragStarting || _thumb.IsDragging))
{
Moved?.Invoke(this, newValue - oldValue);
}
}
public void MoveTo(Point vector)
{
var position = Position;
position.X = vector.X;
position.Y = vector.Y;
Position = position;
Moved.Invoke();
}
protected void OnCollectionChangedMove(object value, int index, int oldIndex)
{
var eventArgs = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move, value, index, oldIndex);
using (BlockReentrancy()) {
CollectionChanged?.Invoke(this, eventArgs);
Moved?.Invoke(this, eventArgs);
}
}
internal void fireWheel(int z)
{
absMouse.z += z;
if (Moved != null)
{
Moved.Invoke(this);
}
}
protected override void OnValueChanged(double oldValue, double newValue)
{
base.OnValueChanged(oldValue, newValue);
if (this.IsFocused && IsUnison)
{
Moved?.Invoke(this, newValue - oldValue);
}
}
