/// <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);
}
