private void mInputDevice_NoteOn(NoteOnMessage msg)
{
LaunchpadButton button = GetButton(msg.Pitch);
if (button == null)
{
return;
}
button.State = (ButtonPressState)msg.Velocity;
if (ButtonPressed == null)
{
return;
}
var pressEventArgs = (int)msg.Pitch % 16 == 8 ? new ButtonPressEventArgs((SideButton)((int)msg.Pitch / 16), button) : new ButtonPressEventArgs((int)msg.Pitch % 16, (int)msg.Pitch / 16, button);
if (button.State == ButtonPressState.Up)
{
ButtonPressed?.Invoke(this, pressEventArgs);
ButtonUp?.Invoke(this, pressEventArgs);
}
else
{
ButtonDown?.Invoke(this, pressEventArgs);
}
}
void Reset()
{
Axis.Reset();
ButtonDown.Reset();
Button.Reset();
ButtonUp.Reset();
}
void GrabUpdate(CustomHand hand)
{
if ((rightHand || leftHand) && GetMyGrabPoserTransform(hand))
{
hand.SkeletonUpdate();
GetComponentInChildren <MeshRenderer>().material.color = Color.grey;
float tempDistance = Mathf.Clamp(StartButtonPosition - (StartButtonPosition - transform.InverseTransformPoint(hand.PivotPoser.position).z) * DistanceMultiply, StartButtonPosition, distanseToPress);
if (tempDistance >= distanseToPress)
{
GetComponentInChildren <MeshRenderer>().material.color = Color.blue;
if (!press)
{
ButtonDown.Invoke();
}
press = true;
ButtonUpdate.Invoke();
}
else
{
if (press)
{
ButtonUp.Invoke();
}
press = false;
}
MoveObject.localPosition = new Vector3(0, 0, tempDistance);
MoveObject.rotation = Quaternion.LookRotation(GetMyGrabPoserTransform(hand).forward, hand.PivotPoser.up);
hand.GrabUpdateCustom();
}
}
private void OnButtonUp(int button)
{
if (ButtonUp != null)
{
ButtonUp.Invoke(null, new MouseEventArgs(button));
}
}
public void UpdateSensorValues(string[] rawValues)
{
if (rawValues == null || rawValues.Length == 0)
{
throw new Exception("Incomming data is incomplete");
}
Slider.UpdateValue(Convert.ToInt16(rawValues[SensorValuesOrderTable.SliderOrder]));
LightSensor.UpdateValue(Convert.ToInt16(rawValues[SensorValuesOrderTable.LightSensorOrder]));
Temperature.UpdateValue(Convert.ToInt16(rawValues[SensorValuesOrderTable.TemperatureOrder]));
Microphone.UpdateValue(Convert.ToInt16(rawValues[SensorValuesOrderTable.MicrophoneOrder]));
JoystickSwitch.UpdateValue(Convert.ToInt16(rawValues[SensorValuesOrderTable.JoystickSwitchOrder]));
JoystickButton.UpdateValue(rawValues[SensorValuesOrderTable.JoystickButtonOrder] != "1");
AccelerometerX.UpdateValue(Convert.ToInt16(rawValues[SensorValuesOrderTable.AccelerometerXOrder]));
AccelerometerY.UpdateValue(Convert.ToInt16(rawValues[SensorValuesOrderTable.AccelerometerYOrder]));
AccelerometerZ.UpdateValue(Convert.ToInt16(rawValues[SensorValuesOrderTable.AccelerometerZOrder]));
ButtonDown.UpdateValue(rawValues[SensorValuesOrderTable.ButtonDownOrder] != "1");
ButtonLeft.UpdateValue(rawValues[SensorValuesOrderTable.ButtonLeftOrder] != "1");
ButtonUp.UpdateValue(rawValues[SensorValuesOrderTable.ButtonUpOrder] != "1");
ButtonRight.UpdateValue(rawValues[SensorValuesOrderTable.ButtonRightOrder] != "1");
JoystickX.UpdateValue(Convert.ToInt16(rawValues[SensorValuesOrderTable.JoystickXOrder]));
JoystickY.UpdateValue(Convert.ToInt16(rawValues[SensorValuesOrderTable.JoystickYOrder]));
LedRed.UpdateValue(Convert.ToByte(rawValues[SensorValuesOrderTable.LedRedOrder]));
LedGreen.UpdateValue(Convert.ToByte(rawValues[SensorValuesOrderTable.LedGreenOrder]));
LedBlue.UpdateValue(Convert.ToByte(rawValues[SensorValuesOrderTable.LedBlueOrder]));
}
/// <summary>
/// Raises the button up event.
/// </summary>
/// <param name="button">The button.</param>
protected virtual void OnButtonUp(LogitechF710Button button)
{
if (_disposed)
{
throw new ObjectDisposedException(nameof(LogitechF710));
}
ButtonUp?.Invoke(this, new LogitechF710ButtonEventArgs(button));
}
// =====================================
#endregion
#region Draw
public override void DrawCore(IRenderer Renderer)
{
Background.Draw(Renderer);
ButtonUp.Draw(Renderer);
ButtonDown.Draw(Renderer);
if (GetScrollAreaSize() > 1)
{
Thumb.Draw(Renderer);
}
}
void Start()
{
input = new InputControls();
input.Enable();
input.Gameplay.HitStraight.started += ctrl => ButtonDown?.Invoke(Buttons.HitStraight);
input.Gameplay.HitStraight.canceled += ctrl => ButtonUp?.Invoke(Buttons.HitStraight);
input.Gameplay.HitLob.started += ctrl => ButtonDown?.Invoke(Buttons.HitLob);
input.Gameplay.HitLob.canceled += ctrl => ButtonUp?.Invoke(Buttons.HitLob);
}
private void CheckButtonUpdate(MouseButtons button)
{
if (IsButtonPressed(button))
{
ButtonDown?.Invoke(new MouseEventArgs(this, Position, button));
}
else if (IsButtonReleased(button))
{
ButtonUp?.Invoke(new MouseEventArgs(this, Position, button));
}
}
public void ResetButton()
{
if (switchMode && buttenDown == true)
{
if (ButtonUp != null)
{
ButtonUp.Invoke(this, new EventArgs());
}
buttenDown = false;
this.Invalidate();
}
}
public override int GetHashCode()
{
unchecked
{
int hashCode = base.GetHashCode();
hashCode = (hashCode * 397) ^ ButtonDown.GetHashCode();
hashCode = (hashCode * 397) ^ ButtonUp.GetHashCode();
hashCode = (hashCode * 397) ^ ButtonRight.GetHashCode();
hashCode = (hashCode * 397) ^ ButtonLeft.GetHashCode();
hashCode = (hashCode * 397) ^ MinusButton.GetHashCode();
hashCode = (hashCode * 397) ^ CaptureButton.GetHashCode();
return(hashCode);
}
}
private void Button_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
{
if (args.Edge == GpioPinEdge.FallingEdge)
{
pushStatus = PushStatus.DOWN;
ValueChanged?.Invoke(this, pushStatus, args);
ButtonDown?.Invoke(this, args);
}
else
{
pushStatus = PushStatus.UP;
ValueChanged?.Invoke(this, pushStatus, args);
ButtonUp?.Invoke(this, args);
}
}
public void Detect()
{
if (device.TryGetFeatureValue(button, out bool value))
{
if (!lastValue && value)
{
ButtonDown?.Invoke(this);
}
else if (lastValue && !value)
{
ButtonUp?.Invoke(this);
}
lastValue = value;
}
}
public void Tick()
{
if (Input.GetMouseButtonDown(MouseButtonIndex))
{
ButtonDown?.Invoke(ScreenToWorld(Input.mousePosition));
}
if (Input.GetMouseButton(MouseButtonIndex))
{
ButtonHold?.Invoke(ScreenToWorld(Input.mousePosition));
}
if (Input.GetMouseButtonUp(MouseButtonIndex))
{
ButtonUp?.Invoke(ScreenToWorld(Input.mousePosition));
}
}
public void Tick()
{
var touch = Input.GetTouch(TouchIndex);
if (touch.phase == TouchPhase.Began)
{
ButtonDown?.Invoke(ScreenToWorld(touch.position));
}
if (touch.phase == TouchPhase.Moved || touch.phase == TouchPhase.Stationary)
{
ButtonHold?.Invoke(ScreenToWorld(touch.position));
}
if (touch.phase == TouchPhase.Ended || touch.phase == TouchPhase.Canceled)
{
ButtonUp?.Invoke(ScreenToWorld(Input.mousePosition));
}
}
internal void fireButtonUp(MouseButtonCode button)
{
int index = (int)button;
//Make sure the button is down
if (buttonDownStatus[index])
{
buttonDownStatus[index] = false;
if (pressedThisFrame[index])
{
downAndUpThisFrame[index] = true;
}
if (ButtonUp != null)
{
ButtonUp.Invoke(this, button);
}
}
}
/// <summary>
/// Handler for releasing the button.
/// </summary>
protected void HandleButtonReleased()
{
if (_debounceTime.Ticks > 0 && !IsPressed)
{
return;
}
_debounceStartTicks = DateTime.UtcNow.Ticks;
_holdingTimer?.Dispose();
_holdingTimer = null;
IsPressed = false;
ButtonUp?.Invoke(this, new EventArgs());
Press?.Invoke(this, new EventArgs());
if (IsHoldingEnabled && _holdingState == ButtonHoldingState.Started)
{
_holdingState = ButtonHoldingState.Completed;
Holding?.Invoke(this, new ButtonHoldingEventArgs {
HoldingState = ButtonHoldingState.Completed
});
}
if (IsDoublePressEnabled)
{
if (_lastPress == DateTime.MinValue.Ticks)
{
_lastPress = DateTime.UtcNow.Ticks;
}
else
{
if (DateTime.UtcNow.Ticks - _lastPress <= _doublePressTicks)
{
DoublePress?.Invoke(this, new EventArgs());
}
_lastPress = DateTime.MinValue.Ticks;
}
}
}
protected override void OnMouseDown(MouseEventArgs e)
{
base.OnMouseDown(e);
mode = 2;
base.OnMouseClick(e);
if (switchMode)
{
buttenDown = !buttenDown;
if (buttenDown == true && ButtonDown != null)
{
ButtonDown.Invoke(this, new EventArgs());
}
else if (ButtonUp != null)
{
ButtonUp.Invoke(this, new EventArgs());
}
}
this.Invalidate();
}
public override void OnUpdate()
{
var value = !pin.Value;
if (IsPressed == value)
{
return;
}
IsPressed = value;
if (IsPressed)
{
tracer.Verbose("Buton Down");
ButtonDown?.Invoke();
}
else
{
tracer.Verbose("Buton Up");
ButtonUp?.Invoke();
Clicked?.Invoke();
}
}
/// <inheritdoc />
public void Update(TimeSpan total, TimeSpan elapsed, bool isRunningSlowly)
{
if (!IsWithinGameWindow(core.Location.X, core.Location.Y))
{
return;
}
lastLocation = core.Location;
PreUpdate?.Invoke(this, new UpdateEventArgs(total, elapsed, isRunningSlowly));
if (Left == MouseButtonState.Released && leftPrevious == MouseButtonState.Pressed)
{
ButtonUp?.Invoke(this, new MouseButtonClickEventArgs(X, Y, MouseButton.Left));
}
else if (Middle == MouseButtonState.Released && middlePrevious == MouseButtonState.Pressed)
{
ButtonUp?.Invoke(this, new MouseButtonClickEventArgs(X, Y, MouseButton.Middle));
}
else if (Right == MouseButtonState.Released && rightPrevious == MouseButtonState.Pressed)
{
ButtonUp?.Invoke(this, new MouseButtonClickEventArgs(X, Y, MouseButton.Right));
}
else if (X1 == MouseButtonState.Released && x1Previous == MouseButtonState.Pressed)
{
ButtonUp?.Invoke(this, new MouseButtonClickEventArgs(X, Y, MouseButton.X1));
}
else if (X2 == MouseButtonState.Released && x2Previous == MouseButtonState.Pressed)
{
ButtonUp?.Invoke(this, new MouseButtonClickEventArgs(X, Y, MouseButton.X2));
}
leftPrevious = Left;
middlePrevious = Middle;
rightPrevious = Right;
x1Previous = X1;
x2Previous = X2;
PostUpdate?.Invoke(this, new UpdateEventArgs(total, elapsed, isRunningSlowly));
}
private void mInputDevice_ControlChange(ControlChangeMessage msg)
{
ToolbarButton toolbarButton = (ToolbarButton)(msg.Control - 104);
LaunchpadButton button = GetButton(toolbarButton);
if (button == null)
{
return;
}
button.State = (ButtonPressState)msg.Value;
var pressEventArgs = new ButtonPressEventArgs(toolbarButton, button);
if (button.State == ButtonPressState.Up)
{
ButtonPressed?.Invoke(this, pressEventArgs);
ButtonUp?.Invoke(this, pressEventArgs);
}
else
{
ButtonDown?.Invoke(this, pressEventArgs);
}
}
public void EnterSelection()
{
EnteringSelection = !EnteringSelection;
if (EnteringSelection)
{
if (LevelManager.stage == 2 && LevelManager.isInstruction)
{
StartCoroutine(LevelManager.EnterMatch_Tut_S3());
}
int idx = matchedNPCIdx[stationNum][tabNum];
ProfileUsageState[idx] = "";
EnterSelectionButton.GetComponent <Image>().sprite = afterEnter;
ButtonDown.SetActive(true);
ButtonUp.SetActive(true);
}
else
{
//确定选择
if (LevelManager.stage == 2 && LevelManager.isInstruction)
{
LevelManager.EndMatch_Tut_S3();
}
int idx = matchedNPCIdx[stationNum][tabNum];
if (ProfileUsageState[idx] != "")
{
EnteringSelection = !EnteringSelection;
}
else
{
ProfileUsageState[idx] = BagsController.stationBagOwners[stationNum][tabNum];
EnterSelectionButton.GetComponent <Image>().sprite = beforeEnter;
ButtonDown.SetActive(false);
ButtonUp.SetActive(false);
}
}
}
public void ButtonU()
{
ButtonUp.Play();
}
/// <summary>
/// Disposes all disposable objects in this object.
/// </summary>
public override void Dispose()
{
ButtonUp.Dispose();
ButtonDown.Dispose();
}
private void UpdateTimer(Keys key, Buttons button, float directionX, float directionY, float elapsedTime, ButtonDown downAction, ButtonUp upAction, ButtonPressed pressAction, ref float downTimer, ref float upTimer)
{
if (IsKeyDown(key) || currentGamePadState.IsButtonDown(button))
{
if (downAction != null && downTimer == 0)
{
downAction.Invoke(directionX, directionY, upTimer, PlayerIndex);
}
downTimer += elapsedTime;
upTimer = 0;
}
else if (IsKeyUp(key) || currentGamePadState.IsButtonUp(button))
{
//Check if it was a press of key
if (this.oldKeyboardState.IsKeyDown(key) || oldGamePadState.IsButtonDown(button))
{
if (pressAction != null)
{
pressAction.Invoke(PlayerIndex);
}
if (upAction != null)
{
upAction.Invoke(downTimer, PlayerIndex);
}
}
upTimer += elapsedTime;
downTimer = 0;
}
}
public void DoEvent(Event @event)
{
switch ((EventType)@event.Type)
{
case EventType.Controlleraxismotion:
{
switch ((GameControllerAxis)@event.Caxis.Axis)
{
case GameControllerAxis.ControllerAxisLeftx:
{
_thumbsticksChanged[0] = true;
_thumbsticks[0] = new Thumbstick
(0, (float)@event.Caxis.Value / short.MaxValue, _thumbsticks[0].Y);
break;
}
case GameControllerAxis.ControllerAxisLefty:
{
_thumbsticksChanged[0] = true;
_thumbsticks[0] = new Thumbstick
(0, _thumbsticks[0].X, (float)@event.Caxis.Value / short.MaxValue);
break;
}
case GameControllerAxis.ControllerAxisRightx:
{
_thumbsticksChanged[1] = true;
_thumbsticks[1] = new Thumbstick
(1, (float)@event.Caxis.Value / short.MaxValue, _thumbsticks[1].Y);
break;
}
case GameControllerAxis.ControllerAxisRighty:
{
_thumbsticksChanged[1] = true;
_thumbsticks[1] = new Thumbstick
(1, _thumbsticks[1].X, (float)@event.Caxis.Value / short.MaxValue);
break;
}
case GameControllerAxis.ControllerAxisTriggerleft:
{
TriggerMoved?.Invoke
(this, _triggers[0] = new Trigger(0, (float)@event.Caxis.Value / short.MaxValue));
break;
}
case GameControllerAxis.ControllerAxisTriggerright:
{
TriggerMoved?.Invoke
(this, _triggers[1] = new Trigger(1, (float)@event.Caxis.Value / short.MaxValue));
break;
}
}
break;
}
case EventType.Controllerbuttondown:
{
var ogBtn = _buttons[@event.Cbutton.Button];
ButtonDown?.Invoke
(this, _buttons[@event.Cbutton.Button] = new Button(ogBtn.Name, ogBtn.Index, true));
break;
}
case EventType.Controllerbuttonup:
{
var ogBtn = _buttons[@event.Cbutton.Button];
ButtonUp?.Invoke
(this, _buttons[@event.Cbutton.Button] = new Button(ogBtn.Name, ogBtn.Index, false));
break;
}
case EventType.Controllerdeviceadded:
{
_ctx.ChangeConnection(this, true);
break;
}
case EventType.Controllerdeviceremoved:
{
_ctx.ChangeConnection(this, false);
break;
}
}
for (var i = 0; i < _thumbsticksChanged.Length; i++)
{
if (_thumbsticksChanged[i])
{
ThumbstickMoved?.Invoke(this, _thumbsticks[i]);
_thumbsticksChanged[i] = false;
}
}
}
protected override void OnButtonUp(XTouchMiniMcButton button)
{
base.OnButtonUp(button);
ButtonUp?.Invoke(this, new DeviceButtonEventArgs(_buttons[button.MidiCode]));
}
public MouseEvent(Wait Wait, MouseMove Move, ButtonScroll ButtonScroll, ButtonDown ButtonDown, ButtonUp ButtonUp, ButtonClick ButtonClick, ButtonClickHold ButtonClickHold, ButtonDoubleClick ButtonDoubleClick, IReadOnlyCollection <DragStart> DragStarted, IReadOnlyCollection <DragDrop> DragFinished)
{
this.Wait = Wait;
this.Move = Move;
this.ButtonScroll = ButtonScroll;
this.ButtonDown = ButtonDown;
this.ButtonUp = ButtonUp;
this.ButtonClick = ButtonClick;
this.ButtonClickHold = ButtonClickHold;
this.ButtonDoubleClick = ButtonDoubleClick;
this.DragStart = DragStarted;
this.DragStop = DragFinished;
{
var PotentialEvents = new List <IEvent>();
PotentialEvents.Add(Wait);
PotentialEvents.Add(Move);
PotentialEvents.Add(ButtonScroll);
PotentialEvents.Add(ButtonDown);
PotentialEvents.Add(ButtonUp);
PotentialEvents.Add(ButtonClick);
PotentialEvents.Add(ButtonClickHold);
PotentialEvents.Add(ButtonDoubleClick);
if (DragStart is { })
private void OnButtonUp(int buttonNo)
{
ButtonUp?.Invoke(this, new DevJoystickButtonEventArgs(buttonNo));
}
public void DoEvent(Event @event)
{
switch ((EventType)@event.Type)
{
case EventType.Joyaxismotion:
{
if (_axes.Length < @event.Jaxis.Axis + 1)
{
Array.Resize(ref _axes, @event.Jaxis.Axis + 1);
}
AxisMoved?.Invoke
(
this,
_axes[@event.Jaxis.Axis] = new Axis
(@event.Jaxis.Axis, (float)@event.Jaxis.Value / short.MaxValue)
);
break;
}
case EventType.Joyballmotion:
{
// todo investigate adding balls to the input spec later down the line
break;
}
case EventType.Joyhatmotion:
{
if (_hats.Length < @event.Jhat.Hat + 1)
{
Array.Resize(ref _hats, @event.Jhat.Hat + 1);
}
var val = @event.Jhat.Value;
HatMoved?.Invoke
(
this,
_hats[@event.Jhat.Hat] = new Hat
(
@event.Jhat.Hat, (Position2D)((val & 0x01) * (int)Position2D.Up +
(val & 0x02) * (int)Position2D.Right +
(val & 0x04) * (int)Position2D.Down +
(val & 0x08) * (int)Position2D.Left)
)
);
break;
}
case EventType.Joybuttondown:
{
if (_buttons.Length < @event.Jbutton.Button + 1)
{
Array.Resize(ref _buttons, @event.Jbutton.Button + 1);
}
ButtonDown?.Invoke
(
this,
_buttons[@event.Jbutton.Button] = new Button
((ButtonName)@event.Jbutton.Button, @event.Jbutton.Button, true)
);
break;
}
case EventType.Joybuttonup:
{
if (_buttons.Length < @event.Jbutton.Button + 1)
{
Array.Resize(ref _buttons, @event.Jbutton.Button + 1);
}
ButtonUp?.Invoke
(
this,
_buttons[@event.Jbutton.Button] = new Button
((ButtonName)@event.Jbutton.Button, @event.Jbutton.Button, false)
);
break;
}
case EventType.Joydeviceadded:
{
_ctx.ChangeConnection(this, true);
break;
}
case EventType.Joydeviceremoved:
{
_ctx.ChangeConnection(this, false);
break;
}
}
}
private void UpdateTimer(Keys key, Buttons button, float directionX, float directionY, float elapsedTime, ButtonDown downAction, ButtonUp upAction, ButtonPressed pressAction, ref float downTimer, ref float upTimer)
{
if (IsKeyDown(key) || currentGamePadState.IsButtonDown(button))
{
if(downAction != null && downTimer == 0)
downAction.Invoke(directionX, directionY, upTimer, PlayerIndex);
downTimer += elapsedTime;
upTimer = 0;
}
else if (IsKeyUp(key) || currentGamePadState.IsButtonUp(button))
{
//Check if it was a press of key
if(this.oldKeyboardState.IsKeyDown(key) || oldGamePadState.IsButtonDown(button)){
if (pressAction != null)
pressAction.Invoke(PlayerIndex);
if (upAction != null)
upAction.Invoke(downTimer, PlayerIndex);
}
upTimer += elapsedTime;
downTimer = 0;
}
}
