/// <summary> /// Refreshes the current state. Triggers <see cref="InputChanged"/> event. /// </summary> /// <returns>if the input was available</returns> public bool RefreshInput() { foreach (var type in XInputHelper.Instance.Values) { var mapping = mapper.GetMapping(type); if (mapping != null) { double value = 0; if (mapping.InputType != null) { value = source.Get(mapping.InputType); } values[type] = mapping.GetValue(value); } } if (mapper.SelectedDPad != -1) { dPads[0] = source.DPads.ElementAt(mapper.SelectedDPad); } else { dPads[0] = DPadHelper.GetDirection(GetBool(XInputTypes.UP), GetBool(XInputTypes.DOWN), GetBool(XInputTypes.LEFT), GetBool(XInputTypes.RIGHT)); } var changedDPads = state.SetDPads(dPads); var changedValues = state.SetValues(values.Where(t => !t.Key.IsDPad()).ToDictionary(x => (Enum)x.Key, x => x.Value)); if (changedDPads.Any() || changedValues.Any()) { InputChanged?.Invoke(this, new DeviceInputChangedEventArgs(changedValues, changedDPads)); } return(true); }
private void ReadLoop() { if (!inputReceiver.IsRunning) { return; } Report report; Dictionary <Usage, DataValue> changedIndexes = new Dictionary <Usage, DataValue>(); for (int i = 0; i < limit && inputReceiver.TryRead(inputReportBuffer, 0, out report); i++) { if (inputParser.TryParseReport(inputReportBuffer, 0, report)) { while (inputParser.HasChanged) { int changedIndex = inputParser.GetNextChangedIndex(); var dataValue = inputParser.GetValue(changedIndex); if (dataValue.Usages.Count() > 0) { changedIndexes[(Usage)dataValue.Usages.FirstOrDefault()] = dataValue; } } } } var changedSources = sources.Where(s => s.Refresh(changedIndexes)).ToArray(); inputChangedEventArgs.Refresh(changedSources); if (inputChangedEventArgs.ChangedValues.Any()) { InputChanged?.Invoke(this, inputChangedEventArgs); } }
protected void OnInputChanged() { if (InputChanged != null) { InputChanged.Invoke(); } }
private void PollRegistersOk() { if (_newProcessImage.Length != _pollCount) { Trace.TraceError($"PollRegisters: Read returns {_newProcessImage.Length} registers, {_pollCount} expected"); } else { var message = "ProcessImage:"; var ctx = GetPollContext(); for (var offset = 0; offset < _pollCount; offset++) { message += $" {_newProcessImage[offset]:X4}"; if (_newProcessImage[offset] == ProcessImage[offset]) { continue; } ProcessImageChanged?.Invoke(new ProcessImageChangeEventParams(ctx, offset, ProcessImage[offset], _newProcessImage[offset])); for (var bit = 0; bit < 16; bit++) { var bitMask = 1 << bit; if ((_newProcessImage[offset] & bitMask) != (ProcessImage[offset] & bitMask)) { InputChanged?.Invoke(ctx, offset * 16 + bit, (_newProcessImage[offset] & bitMask) != 0); } } } Trace.TraceInformation(message); ProcessImage = _newProcessImage; } Thread.Sleep(PollInterval); GoState(PollRegisters); }
private void OnKeyDown(object sender, KeyEventArgs e) { timer.Stop(); var pressedKey = new ConsoleKeyInfo(e.KeyChar, e.Key, false, false, false); if (char.IsLetterOrDigit(e.KeyChar)) { pressedKeys.Enqueue(pressedKey); StringBuilder builder = new StringBuilder(); foreach (var key in pressedKeys) { builder.Append(key.KeyChar); } InputChanged?.Invoke(this, new ConsoleInputEventArgs(pressedKey, builder.ToString())); } else { InputChanged?.Invoke(this, new ConsoleInputEventArgs(pressedKey)); pressedKeys.Clear(); } timer.Start(); }
/// <summary> /// Refreshes the current state. Triggers <see cref="InputChanged"/> event. /// </summary> /// <returns>if the input was available</returns> public bool RefreshInput() { state.ResetChanges(); foreach (var s in sources) { if (s.Refresh(source, mapper)) { state.MarkChanged(s); } } var changes = state.GetChanges(); if (mapper.SelectedDPad != -1) { dPads[0] = source.DPads.ElementAt(mapper.SelectedDPad); } else { dPads[0] = DPadHelper.GetDirection(GetBool(XInputTypes.UP), GetBool(XInputTypes.DOWN), GetBool(XInputTypes.LEFT), GetBool(XInputTypes.RIGHT)); } state.SetDPad(0, dPads[0]); var changedDPads = state.GetChangedDpads(); if (changedDPads.Any() || changes.Any()) { InputChanged?.Invoke(this, new DeviceInputChangedEventArgs(changes, changedDPads)); } return(true); }
private void ReadLoop() { var changedSources = sources.Where(s => s.Refresh(hook.IsPressed((MouseButton)s.Offset))).ToList(); inputChangedEventArgs.Refresh(changedSources); if (inputChangedEventArgs.ChangedValues.Any()) { InputChanged?.Invoke(this, inputChangedEventArgs); } }
private void ReadLoop() { JoystickState state = joystick.GetCurrentState(); var changedSources = sources.Where(s => s.Refresh(state)).ToArray(); inputChangedEventArgs.Refresh(changedSources); if (inputChangedEventArgs.ChangedValues.Any()) { InputChanged?.Invoke(this, inputChangedEventArgs); } }
public char this[int i] { get { return(_inputBuffer[i]); } set { if (_inputBuffer[i] != value) { _inputBuffer[i] = value; SetDirty(); InputChanged?.Invoke(this, EventArgs.Empty); } } }
public void Clear() { if (_inputBuffer.Length == 0) { return; } _inputBuffer.Clear(); Caret.MoveBy(int.MinValue); SetDirty(); InputChanged?.Invoke(this, EventArgs.Empty); }
public void Remove(int startIndex, int length) { if (length <= 0) { return; } Caret.Index = startIndex; _inputBuffer.Remove(startIndex, length); SetDirty(); InputChanged?.Invoke(this, EventArgs.Empty); }
public void Append(string value) { if (string.IsNullOrEmpty(value)) { return; } _inputBuffer.Insert(Caret.Index, value); Caret.MoveBy(value.Length); SetDirty(); InputChanged?.Invoke(this, EventArgs.Empty); }
/// <summary> /// Refreshes the current state. /// </summary> /// <returns></returns> public bool RefreshInput() { if (!disposed) { Result result = joystick.Poll(); if (result.IsSuccess) { InputChanged?.Invoke(); } return(result.IsSuccess); } return(false); }
/// <summary> /// Override to set the value from EventMonitor /// </summary> protected sealed override bool SetValue(object value) { int newValue = Convert.ToInt32(value); bool hasChanged = (Value != newValue); if (hasChanged) { Value = newValue; if (MonitorEvents) { InputChanged?.Invoke(this, newValue); } } return(hasChanged); }
public void Handle(InputChanged message) { this.log.Information("Input {0} on {1} set to {2}", message.Input, this.name, message.Value); if (message.Input.StartsWith("d")) { int inputId; if (int.TryParse(message.Input.Substring(1), out inputId)) { if (inputId >= 0 && inputId <= 7) { this.DigitalInputs[inputId].Trigger(message.Value != 0.0); } } } }
/// <summary> /// Refreshes the current state. Triggers <see cref="InputChanged"/> event. /// </summary> private void InputRefresher() { try { while (true) { var newValues = buttons.ToDictionary(t => t, t => Get(t)); var changedValues = state.SetValues(newValues); if (changedValues.Any()) { InputChanged?.Invoke(this, new DeviceInputChangedEventArgs(changedValues, new int[0])); } Thread.Sleep(ReadDelayMs); } } catch (ThreadAbortException) { } }
public void SetData(Dictionary <int, double> newValues) { var changedValues = new HashSet <InputDeviceSourceWithValue>(); foreach (var newValue in newValues) { var source = FindSource(newValue.Key); if (source == null) { logger.Warn($"Failed to find source {newValue.Key} for device {id}"); continue; } source.Value = newValue.Value; changedValues.Add(source); } InputChanged?.Invoke(this, new InputDeviceInputChangedEventArgs(changedValues)); }
public Keyboard() { inputRefresher = new Thread(() => { try { while (true) { InputChanged?.Invoke(); Thread.Sleep(1); } } catch (ThreadAbortException) { } }); inputRefresher.SetApartmentState(ApartmentState.STA); inputRefresher.IsBackground = true; inputRefresher.Start(); }
/// <summary> /// Refreshes the current state. Triggers <see cref="InputChanged"/> event. /// </summary> /// <returns>if the input was available</returns> public bool RefreshInput() { state.ResetChanges(); foreach (var source in sources) { if (source.Refresh()) { state.MarkChanged(source); } } var changes = state.GetChanges(); if (changes.Any()) { InputChanged?.Invoke(this, new DeviceInputChangedEventArgs(changes, new int[0])); } return(true); }
/// <summary> /// Refreshes the current state. Triggers <see cref="InputChanged"/> event. /// </summary> /// <returns>if the input was available</returns> public bool RefreshInput(bool force = false) { state.ResetChanges(); foreach (var source in sources) { if (source.Refresh()) { state.MarkChanged(source); } } var changes = state.GetChanges(force); if (changes.Any()) { deviceInputChangedEventArgs.Refresh(changes); InputChanged?.Invoke(this, deviceInputChangedEventArgs); } return(true); }
/// <summary> /// Parse the specified CAN data /// </summary> /// <param name="data">The data to parse.</param> protected internal override void Parse(byte[] data) { if (data[3] > 0x7F) { Position = -((~data[3] & 0x000000FF) << 32 | (~data[2] & 0x000000FF) << 16 | (~data[1] & 0x000000FF) << 8 | (~data[0] & 0x000000FF)); } else { Position = data[3] << 32 | data[2] << 16 | data[1] << 8 | data[0]; } Disabled = (data[5] & 0x80) > 0; SpeedSet = !((data[5] & 0x40) > 0); CurrentSet = !((data[5] & 0x20) > 0); HomeSet = !((data[5] & 0x10) > 0); OverTemperature = (data[5] & 0x82) > 0; // set inputs and invoke input changed event where applicable foreach (var args in Inputs.Parse(data[4])) { InputChanged?.Invoke(this, args); } // set outputs and invoke output changed event where applicable foreach (var args in Outputs.Parse(data[6])) { OutputChanged?.Invoke(this, args); } // set running value and invoke stop/start events if (Running != (data[5] & 0x01) > 0) { Running = (data[5] & 0x01) > 0; if (Running) { MotorStarted?.Invoke(this, new MotorStartedEventArgs()); } else { MotorStopped?.Invoke(this, new MotorStoppedEventArgs()); } } }
private void CharacterTyped(object sender, KeyboardInput.CharacterEventArgs e, KeyboardState ks) { if (Active && !KeyboardInput.CtrlDown) { if (IsLegalCharacter(Renderer.Font, e.Character) && !e.Character.Equals('\r') && !e.Character.Equals('\n')) { DelSelection(); if (Text.Length < Text.MaxLength) { if (InputAllowed == InputType.NumbersOnly && (e.Character > 57 || e.Character < 48)) { return; } Text.InsertCharacter(Cursor.TextCursor, e.Character); Cursor.TextCursor++; InputChanged?.Invoke(this, Text.String); } } } }
/// <summary> /// Refreshes the current state. /// </summary> /// <returns></returns> public bool RefreshInput() { foreach (var type in (XInputTypes[])Enum.GetValues(typeof(XInputTypes))) { var mapping = mapper.GetMapping(type); if (mapping != null) { double value = 0; if (mapping.InputType != null) { value = source.Get(mapping.InputType); } values[type] = mapping.GetValue(value); } else { } } dPad = source.DPad; InputChanged?.Invoke(); return(true); }
/// <summary> /// Refreshes the current state. Triggers <see cref="InputChanged"/> event. /// </summary> /// <returns>if the input was available</returns> public bool RefreshInput(bool force = false) { state.ResetChanges(); foreach (var s in sources) { if (s.Refresh(mapper)) { state.MarkChanged(s); } } var changes = state.GetChanges(force); dPads[0] = DPadHelper.GetDirection(GetBool(XInputTypes.UP), GetBool(XInputTypes.DOWN), GetBool(XInputTypes.LEFT), GetBool(XInputTypes.RIGHT)); state.SetDPad(0, dPads[0]); var changedDPads = state.GetChangedDpads(force); if (changedDPads.Any() || changes.Any()) { InputChanged?.Invoke(this, new DeviceInputChangedEventArgs(this, changes, changedDPads)); } return(true); }
/// <summary> /// Refreshes the current state. Triggers <see cref="InputChanged"/> event. /// </summary> /// <returns>if the input was available</returns> public bool RefreshInput(bool force = false) { state.ResetChanges(); foreach (var s in sources) { if (s.Refresh()) { state.MarkChanged(s); } } var changes = state.GetChanges(force); dPads[0] = DPadHelper.GetDirection(GetBool(XInputTypes.UP), GetBool(XInputTypes.DOWN), GetBool(XInputTypes.LEFT), GetBool(XInputTypes.RIGHT)); state.SetDPad(0, dPads[0]); var changedDPads = state.GetChangedDpads(force); if (changedDPads.Any() || changes.Any()) { deviceInputChangedEventArgs.Refresh(changes, changedDPads); InputChanged?.Invoke(this, deviceInputChangedEventArgs); xOutputManager.XOutputDevice.Report(controllerCount, GetValues()); } return(true); }
protected void RaiseInputChanged(byte interruptPins, byte currentStates) { InputChanged?.Invoke(this, new IOExpanderInputChangedEventArgs(interruptPins, currentStates)); }
private void TcpClient_DataReceived(object sender, DataReceivedArgs e) { /* * Parse the data sent by the display, check for changes * in properties that the IDisplay interfaces uses, and * raise events accordingly */ //example response: "MULTI.VIEW:QUAD" string[] ResponseValues = e.DataString.ToUpper().Split(':'); string PropThatChanged = ResponseValues[0]; string NewValue = ResponseValues[1]; if (PropThatChanged.IndexOf("DISPLAY.POWER") >= 0) { _power = (NewValue.IndexOf("ON") >= 0); PowerStateChanged?.Invoke(this, new PowerEventArgs { State = _power, uState = _power ? (ushort)1 : (ushort)0 }); } else if (PropThatChanged.IndexOf("AUDIO.VOLUME") >= 0) { int sentValue = int.Parse(NewValue); //convert string value to int double scaledPercentage = (sentValue / 100) * ushort.MaxValue; //scale int to proportion of ushort value (65535) _volume = (ushort)Math.Floor(scaledPercentage); //convert to ushort VolumeChanged?.Invoke(this, new VolumeEventArgs() { CurrentLevel = _volume }); } else if (PropThatChanged.IndexOf("MULTI.VIEW") >= 0) { _quadDisplay = (NewValue.IndexOf("QUAD") >= 0); QuadViewChanged?.Invoke(this, new QuadViewEventArgs() { State = _quadDisplay, uState = _quadDisplay ? (ushort)1 : (ushort)0 }); } else if (PropThatChanged.IndexOf("SOURCE.SELECT(ZONE.1)") >= 0) { switch (NewValue) { case ("OPS"): { _input = eDisplayInput.OpsSlot; break; } case ("HDMI.1"): { _input = eDisplayInput.Hdmi1; break; } case ("HDMI.2"): { _input = eDisplayInput.Hdmi2; break; } case ("HDMI.3"): { _input = eDisplayInput.Hdmi3; break; } case ("HDMI.4"): { _input = eDisplayInput.Hdmi4; break; } case ("DP"): { _input = eDisplayInput.DisplayPort1; break; } } InputChanged?.Invoke(this, new InputEventArgs() { CurrentInput = _input, uCurrentInput = (ushort)_input }); } }
protected void InvokeChange() { InputChanged?.Invoke(this, null); }
private void OnInputChanged(PathChangedArgs e) { InputChanged?.Invoke(this, e); }
private void Display_InputChanged(object sender, InputEventArgs e) { InputChanged?.Invoke(sender, e); }