private void RaiseButtonDown(Buttons button)
{
ButtonDown.Raise(this, MakeArgs(button));
ButtonRepeated.Raise(this, MakeArgs(button));
_lastButton = button;
_repeatedButtonTimer = 0;
}
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 Start()
{
deleteButton.gameObject.SetActive(false);
toolbarSlider.gameObject.SetActive(false);
trigger = triggerButton.GetComponent <ButtonDown> ();
wcache = workBench.transform.localPosition;
wcache3 = workBench.transform.localScale;
wcache2 = workBench.transform.rotation;
addShaderObject(menuMan);
previewLine = new GameObject();
LineRenderer lineRenderer;
lineRenderer = previewLine.AddComponent <LineRenderer>();
lineRenderer.useWorldSpace = true;
lineRenderer.startWidth = 1.0f;
lineRenderer.material = blackMaterial;
lineRenderer.widthMultiplier = 0.3f;
// lineRenderer.material = new Material(Shader.Find("Particles/Additive"));
lineRenderer.SetColors(Color.black, Color.black);
lineRenderer.numPositions = 2;
previewLine.transform.parent = this.gameObject.transform;
previewLine.SetActive(false);
groundIndicator.SetActive(false);
travelCanvas.gameObject.SetActive(false);
}
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 OnButtonDown(int button)
{
if (ButtonDown != null)
{
ButtonDown.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]));
}
//按钮事件 执行事件中的方法
public void RunBtnEvent(ButtonDown _event)
{
if (_event != null)
{
_event();
}
}
void Reset()
{
Axis.Reset();
ButtonDown.Reset();
Button.Reset();
ButtonUp.Reset();
}
public void AskOpenFile(string defaultfile)
{
SelOpenDialog sod = new SelOpenDialog();
//if (null != defaultfile)
{
sod.TextBoxFile.Text = defaultfile;
}
if (DialogResult.OK == sod.ShowDialog())
{
if (sod.RadioLineMode.Checked)
{
SetMode(Mode.LINE);
}
else if (sod.RadioZblockMode.Checked)
{
SetMode(Mode.INT32);
}
else
{
SetMode(Mode.GENERIC);
}
OpenFile(sod.TextBoxFile.Text);
}
sod.Dispose();
ButtonDown.Select();
}
/// <summary>
/// Raises the button down event.
/// </summary>
/// <param name="button">The button.</param>
protected virtual void OnButtonDown(LogitechF710Button button)
{
if (_disposed)
{
throw new ObjectDisposedException(nameof(LogitechF710));
}
ButtonDown?.Invoke(this, new LogitechF710ButtonEventArgs(button));
}
public override void Draw(SpriteBatch spriteBatch)
{
base.Draw(spriteBatch);
ButtonUp.Draw(spriteBatch);
ButtonRight.Draw(spriteBatch);
ButtonDown.Draw(spriteBatch);
ButtonLeft.Draw(spriteBatch);
ButtonChange.Draw(spriteBatch);
}
// =====================================
#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()
{
Buttonname = this.gameObject.name;
cell = GameObject.FindObjectOfType <CellManager>();
_image = this.GetComponent <Image>();
_color = _image.color;
_color.a *= -1;
_image.color = _color;
downfunction = GetComponentInParent <ButtonDown>();
}
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));
}
}
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);
}
internal void fireButtonDown(MouseButtonCode button)
{
int index = (int)button;
buttonDownStatus[index] = true;
pressedThisFrame[index] = true;
if (ButtonDown != null)
{
ButtonDown.Invoke(this, button);
}
}
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);
}
}
public Input()
{
PressedKeys = new ButtonDown();
keyBindings[Key.W] = ButtonDown.UP;
keyBindings[Key.A] = ButtonDown.LEFT;
keyBindings[Key.S] = ButtonDown.DOWN;
keyBindings[Key.D] = ButtonDown.RIGHT;
keyBindings[Key.Up] = ButtonDown.UP;
keyBindings[Key.Left] = ButtonDown.LEFT;
keyBindings[Key.Down] = ButtonDown.DOWN;
keyBindings[Key.Right] = ButtonDown.RIGHT;
keyBindings[Key.Space] = ButtonDown.SHOOT;
keyBindings[debugKey] = ButtonDown.DEBUG;
}
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);
}
}
/// <summary>
/// Handler for pressing the button.
/// </summary>
protected void HandleButtonPressed()
{
if (DateTime.UtcNow.Ticks - _debounceStartTicks < _debounceTime.Ticks)
{
return;
}
IsPressed = true;
ButtonDown?.Invoke(this, new EventArgs());
if (IsHoldingEnabled)
{
_holdingTimer = new Timer(StartHoldingHandler, null, (int)_holdingMs, Timeout.Infinite);
}
}
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));
}
}
public static void applyInput()
{
ButtonDown input = Input.queryInput();
if (!GameController.IsPlayerDead)
{
IMoveable shape = GameController.Player.PlayerShip;
shape.RPM =
((int)(input & ButtonDown.LEFT) >> 2) * shape.MaxRPM -
(int)(input & ButtonDown.RIGHT) * shape.MaxRPM;
shape.Velocity =
((int)(input & ButtonDown.UP) >> 1) * shape.MaxVelocity -
((int)(input & ButtonDown.DOWN) >> 3) * shape.MaxVelocity;
bool shootPressed = (int)(input & ButtonDown.SHOOT) >> 4 > 0;
if (shootPressed && !shootFlag && (!shootTimer.IsRunning || shootTimer.Elapsed.TotalSeconds >= 1))
{
shootTimer.Restart();
Task.Run(() => NetworkController.GameService.playerShoots(Constants.standardShotDamage));
shootFlag = true;
}
else if (!shootPressed)
{
shootFlag = false;
}
}
// Only run timeings output when DebugFrameTimings is true
if (GameController.DebugFrameTimings && (int)(input & ButtonDown.DEBUG) >> 5 > 0 && hasRun == false)
{
FrameDebugTimer.outpuFrameTimerResults();
FrameDebugTimer.outputMoveShapeTimerResults();
FrameDebugTimer.outputCollisionTimerResults();
FrameDebugTimer.outputFpsLimitTimerResults();
hasRun = true;
}
}
public ButtonDown queryInput()
{
try {
UIDispatcher.Invoke(() => {
PressedKeys &= 0;
try {
if (Application.Current != null && Application.Current.MainWindow.IsKeyboardFocused)
{
foreach (KeyValuePair <Key, ButtonDown> keyBinding in keyBindings)
{
PressedKeys |= Keyboard.IsKeyDown(keyBinding.Key) ? keyBinding.Value : 0;
}
}
} catch (NullReferenceException) {
}
});
return(PressedKeys);
} catch (TaskCanceledException) {
}
return(PressedKeys);
}
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();
}
}
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);
}
}
IEnumerator TwitchHandleForcedSolve()
{
while (_phraseActions[_selectedPhraseIx].ExpectedDigit != _phraseActions[_selectedPhraseIx].ShownDigit)
{
ButtonDown.OnInteract();
yield return(new WaitForSeconds(.1f));
}
// Wait for the right time to hold the button
while ((int)Bomb.GetTime() % 10 != _phraseActions[_selectedPhraseIx].Hold)
{
yield return(true);
}
ButtonScreen.OnInteract();
yield return(new WaitForSeconds(.1f));
// Wait for the right time to release the button
while ((int)Bomb.GetTime() % 10 != _phraseActions[_selectedPhraseIx].Release)
{
yield return(true);
}
ButtonScreen.OnInteractEnded();
yield return(new WaitForSeconds(.1f));
}
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;
}
}
/// <summary>
/// Disposes all disposable objects in this object.
/// </summary>
public override void Dispose()
{
ButtonUp.Dispose();
ButtonDown.Dispose();
}
