private async Task DeleteControllerEventAsync(ControllerEvent controllerEvent)
{
try
{
if (await _dialogService.ShowQuestionDialogAsync(
Translate("Confirm"),
$"{Translate("AreYouSureToDeleteControllerEvent")} {controllerEvent.EventCode}?",
Translate("Yes"),
Translate("No"),
_disappearingTokenSource.Token))
{
await _dialogService.ShowProgressDialogAsync(
false,
async (progressDialog, token) =>
{
await _creationManager.DeleteControllerEventAsync(controllerEvent);
PopulateControllerEvents();
},
Translate("Deleting"),
token : _disappearingTokenSource.Token);
}
}
catch (OperationCanceledException)
{
}
}
private async Task AddControllerEventAsync()
{
try
{
if (_deviceManager.Devices?.Count == 0)
{
await _dialogService.ShowMessageBoxAsync("Warning", "Please scan for devices before adding controller events!", "Ok", _disappearingTokenSource.Token);
return;
}
var result = await _dialogService.ShowGameControllerEventDialogAsync("Controller", "Press a button or move a joy on the game controller", "Cancel", _disappearingTokenSource.Token);
if (result.IsOk)
{
ControllerEvent controllerEvent = null;
await _dialogService.ShowProgressDialogAsync(
false,
async (progressDialog, token) => controllerEvent = await _creationManager.AddOrGetControllerEventAsync(ControllerProfile, result.EventType, result.EventCode),
"Creating...");
await NavigationService.NavigateToAsync <ControllerActionPageViewModel>(new NavigationParameters(("controllerevent", controllerEvent)));
}
}
catch (OperationCanceledException)
{
}
}
void SerialPort_DataReceived(object sender, ControllerEvent <string> e)
{
lock (SerialPort_DataReceivedLockObject)
{
ProcessReceivedSerialData((IDeviceSerialPort)sender);
}
}
internal void _Call(ControllerEvent ev, Controller controller)
{
if (ev != null && isActiveAndEnabled)
{
try { ev(controller); } catch (Exception e) { Report(e); }
}
}
public async Task SendControllerEventAsync(ControllerEventType controllerType,
byte controllerIndex)
{
var packet = new ControllerEvent(controllerType, controllerIndex);
await SendControlPacket(packet);
}
ControllerTracker HandleButtonDown(EControllerButton btn, EEventSet event_set)
{
if ((bitmask_buttons_down & (1U << (int)btn)) == 0)
{
return(null); /* not actually pressing this button */
}
ControllerTracker tracker = FindHandler(event_set);
if (tracker != null)
{
if (tracker == tracker_hover && btn != EControllerButton.Menu)
{
tracker_hover_lock |= 1U << (int)btn;
}
ControllerEvent ev = null;
switch (btn)
{
case EControllerButton.Trigger: ev = tracker._i_onTriggerDown; break;
case EControllerButton.Grip: ev = tracker._i_onGripDown; break;
case EControllerButton.Menu: ev = tracker._i_onMenuClick; break;
}
tracker._Call(ev, this);
}
return(tracker);
}
public void InvokeIfNotNull(ControllerEvent evt)
{
if (evt != null)
{
evt(this);
}
}
public ControllerEventViewModel(ControllerEvent controllerEvent, IDeviceManager deviceManager)
{
ControllerEvent = controllerEvent;
_deviceManager = deviceManager;
PopulateGroup(controllerEvent, deviceManager);
controllerEvent.ControllerActions.CollectionChanged += OnCollectionChanged;
}
private void HandleMessage(ControllerEvent @event)
{
if (@event is NotificatorControllerEvent notificator)
{
child.AddInfo(notificator);
StateHasChanged();
}
}
private void PopulateGroup(ControllerEvent controllerEvent, IDeviceManager deviceManager, ITranslationService translationService)
{
Clear();
foreach (var controllerAction in controllerEvent.ControllerActions)
{
Add(new ControllerActionViewModel(controllerAction, deviceManager, translationService));
}
}
protected override void OnControllerInput(ControllerEvent controllerInput)
{
switch(controllerInput)
{
case ControllerEvent.B_Button:
ScreenManager.instance.Pop();
break;
}
}
public ControllerEventViewModel(ControllerEvent controllerEvent, IDeviceManager deviceManager, ITranslationService translationService)
{
ControllerEvent = controllerEvent;
_deviceManager = deviceManager;
_translationService = translationService;
PopulateGroup(controllerEvent, deviceManager, translationService);
controllerEvent.ControllerActions.CollectionChanged += OnCollectionChanged;
}
protected override void OnControllerInput(ControllerEvent controllerInput)
{
switch(controllerInput)
{
case ControllerEvent.A_Button:
playButton.ShowPress();
OnPlayButton();
break;
}
}
public ControllerEventViewModel(
ControllerEvent controllerEvent,
IDeviceManager deviceManager,
IPlayLogic playLogic,
ITranslationService translationService)
{
ControllerEvent = controllerEvent;
AddRange(controllerEvent.ControllerActions.Select(ca => new ControllerActionViewModel(ca, deviceManager, playLogic, translationService)));
}
void gameController_MoveText(object sender, ControllerEvent e)
{
if (gameController.position.whiteMove)
{
SetPawnGameText("White To Move");
}
else
{
SetPawnGameText("Black To Move");
}
}
private void _read()
{
_vTime = new VlqBase128Be(m_io);
_eventHeader = m_io.ReadU1();
if (EventHeader == 255)
{
_metaEventBody = new MetaEventBody(m_io, this, m_root);
}
if (EventHeader == 240)
{
_sysexBody = new SysexEventBody(m_io, this, m_root);
}
switch (EventType)
{
case 224: {
_eventBody = new PitchBendEvent(m_io, this, m_root);
break;
}
case 144: {
_eventBody = new NoteOnEvent(m_io, this, m_root);
break;
}
case 208: {
_eventBody = new ChannelPressureEvent(m_io, this, m_root);
break;
}
case 192: {
_eventBody = new ProgramChangeEvent(m_io, this, m_root);
break;
}
case 160: {
_eventBody = new PolyphonicPressureEvent(m_io, this, m_root);
break;
}
case 176: {
_eventBody = new ControllerEvent(m_io, this, m_root);
break;
}
case 128: {
_eventBody = new NoteOffEvent(m_io, this, m_root);
break;
}
}
}
void gameController_MoveText(object sender, ControllerEvent e)
{
if (gameController.position.whiteMove)
{
SetGameInfoText("White To Move");
}
else
{
SetGameInfoText("Black To Move");
}
if ((new MoveGenerator()).legalMoves(gameController.position).Count == 0)
{
SetGameInfoText("Checkmate! " + (gameController.position.whiteMove ? "Black wins!" : "White wins!"));
}
}
public void Update()
{
if (m_controller != null)
{
m_button = m_controller.Button;
m_stick = m_controller.Stick;
for (int i = 0; i < m_controllerEvents.Count; i++)
{
ControllerEvent e = m_controllerEvents[i];
if (m_button.JudgeButton(e.m_buttonName, e.m_buttonMode))
{
e.m_onEvent.Invoke();
}
}
}
}
private async Task DeleteControllerEventAsync(ControllerEvent controllerEvent)
{
try
{
if (await _dialogService.ShowQuestionDialogAsync("Confirm", $"Are you sure to delete controller event {controllerEvent.EventCode}?", "Yes", "No", _disappearingTokenSource.Token))
{
await _dialogService.ShowProgressDialogAsync(
false,
async (progressDialog, token) => await _creationManager.DeleteControllerEventAsync(controllerEvent),
"Deleting...");
}
}
catch (OperationCanceledException)
{
}
}
public static new bool TryDecode(byte[] data, Encoding encoding, out ControllerEvent @event)
{
if (data == null || data.Length == 0)
{
@event = new NotificatorControllerEvent(null, null, 0);
return(false);
}
byte[][] tokens = data.Split(0, 3);
byte sender = tokens[0][0];
string name = encoding.GetString(tokens[1]);
string button = encoding.GetString(tokens[2]);
@event = new NotificatorControllerEvent(name, button, sender);
return(true);
}
private void AddEvent(ControllerEvent mevent)
{
if (dual_state == dualstate.ready)
{
if (mevent.hDevice == mlog1.hDevice)
{
mlog1.Events.Add(mevent);
}
else if (mevent.hDevice == mlog2.hDevice)
{
mlog2.Events.Add(mevent);
}
}
else
{
this.mlog.Add(mevent);
}
}
protected virtual void Awake()
{
if (controller == null)
{
controller = GetComponent <ControllerEvent>();
}
if (controller == null)
{
Debug.Log("");
return;
}
//Utilities
headset = DeviceFinder.HeadsetTransform();
playArea = DeviceFinder.PlayAreaTransform();
playAreaCursorBoundaries = new GameObject[4];
}
public static new bool TryDecode(byte[] data, Encoding encoding, out ControllerEvent @event)
{
if (data == null || data.Length == 0)
{
@event = new TextBoxControllerEvent(null, 0);
return(false);
}
byte sender = data[0];
string text = null;
if (data.Length > 1)
{
text = encoding.GetString(data, 1, data.Length - 1);
}
@event = new TextBoxControllerEvent(text, sender);
return(true);
}
protected override void OnControllerInput(ControllerEvent controllerInput)
{
if( _receiveEvents == false)
return;
switch(controllerInput)
{
case ControllerEvent.Up:
SelectElement(_currentlySelected - 1);
break;
case ControllerEvent.Down:
SelectElement(_currentlySelected +1);
break;
case ControllerEvent.A_Button:
PressElement();
break;
case ControllerEvent.X_Button:
ScreenManager.instance.Pop();
break;
}
}
private async Task AddControllerEventAsync()
{
try
{
if (_deviceManager.Devices?.Count == 0)
{
await _dialogService.ShowMessageBoxAsync(
Translate("Warning"),
Translate("ScanForDevicesFirst"),
Translate("Ok"),
_disappearingTokenSource.Token);
return;
}
var result = await _dialogService.ShowGameControllerEventDialogAsync(
Translate("Controller"),
Translate("PressButtonOrMoveJoy"),
Translate("Cancel"),
_disappearingTokenSource.Token);
if (result.IsOk)
{
ControllerEvent controllerEvent = null;
await _dialogService.ShowProgressDialogAsync(
false,
async (progressDialog, token) => controllerEvent = await _creationManager.AddOrGetControllerEventAsync(ControllerProfile, result.EventType, result.EventCode),
Translate("Creating"),
token : _disappearingTokenSource.Token);
await NavigationService.NavigateToAsync <ControllerActionPageViewModel>(new NavigationParameters(("controllerevent", controllerEvent)));
}
}
catch (OperationCanceledException)
{
}
}
void OnControllerInput(ControllerEvent controllerInput)
{
Debug.Log(controllerInput);
switch(controllerInput)
{
case ControllerEvent.A_Button:
PressButton();
break;
case ControllerEvent.B_Button:
BackSpace();
break;
case ControllerEvent.X_Button:
EndKeyboardInput();
break;
case ControllerEvent.Up:
SelectButton(NavigateKeys(new KeyPos(0,-1)));
break;
case ControllerEvent.Down:
SelectButton(NavigateKeys(new KeyPos(0,1)));
break;
case ControllerEvent.Right:
SelectButton(NavigateKeys(new KeyPos(1,0)));
break;
case ControllerEvent.Left:
SelectButton(NavigateKeys(new KeyPos(-1,0)));
break;
}
}
public void Add(ControllerEvent e)
{
this.events.Add(e);
}
private static Tuple <Option <MidiEvent>, int, byte> NextEvent(List <byte> trackData, int startIndex, byte lastMidiChannel)
{
var i = startIndex - 1;
MidiEvent midiEvent = null;
{
int deltaTime;
{
var lengthTemp = new List <byte>();
do
{
i += 1;
lengthTemp.Add(trackData.ElementAt(i));
} while (trackData.ElementAt(i) > 0x7F);
deltaTime = VariableLengthUtil.decode_to_int(lengthTemp);
}
i += 1;
var eventTypeValue = trackData.ElementAt(i);
// MIDI Channel Events
if ((eventTypeValue & 0xF0) < 0xF0)
{
var midiChannelEventType = (byte)(eventTypeValue & 0xF0);
var midiChannel = (byte)(eventTypeValue & 0x0F);
i += 1;
var parameter1 = trackData.ElementAt(i);
byte parameter2;
// One or two parameter type
switch (midiChannelEventType)
{
// One parameter types
case 0xC0:
midiEvent = new ProgramChangeEvent(deltaTime, midiChannel, parameter1);
lastMidiChannel = midiChannel;
break;
case 0xD0:
midiEvent = new ChannelAftertouchEvent(deltaTime, midiChannel, parameter1);
lastMidiChannel = midiChannel;
break;
// Two parameter types
case 0x80:
i += 1;
parameter2 = trackData.ElementAt(i);
midiEvent = new NoteOffEvent(deltaTime, midiChannel, parameter1, parameter2);
lastMidiChannel = midiChannel;
break;
case 0x90:
i += 1;
parameter2 = trackData.ElementAt(i);
midiEvent = new NoteOnEvent(deltaTime, midiChannel, parameter1, parameter2);
lastMidiChannel = midiChannel;
break;
case 0xA0:
i += 1;
parameter2 = trackData.ElementAt(i);
midiEvent = new NoteAftertouchEvent(deltaTime, midiChannel, parameter1, parameter2);
lastMidiChannel = midiChannel;
break;
case 0xB0:
i += 1;
parameter2 = trackData.ElementAt(i);
midiEvent = new ControllerEvent(deltaTime, midiChannel, parameter1, parameter2);
lastMidiChannel = midiChannel;
break;
case 0xE0:
i += 1;
parameter2 = trackData.ElementAt(i);
midiEvent = new PitchBendEvent(deltaTime, midiChannel, parameter1, parameter2);
lastMidiChannel = midiChannel;
break;
// Might be a Control Change Messages LSB
default:
midiEvent = new ControllerEvent(deltaTime, lastMidiChannel, eventTypeValue, parameter1);
break;
}
i += 1;
}
// Meta Events
else if (eventTypeValue == 0xFF)
{
i += 1;
var metaEventType = trackData.ElementAt(i);
i += 1;
var metaEventLength = trackData.ElementAt(i);
i += 1;
var metaEventData = Enumerable.Range(i, metaEventLength).Select(trackData.ElementAt).ToArray();
switch (metaEventType)
{
case 0x00:
midiEvent = new SequenceNumberEvent(BitConverter.ToUInt16(metaEventData.Reverse().ToArray(), 0));
break;
case 0x01:
midiEvent = new TextEvent(deltaTime, StringEncoder.GetString(metaEventData));
break;
case 0x02:
midiEvent = new CopyrightNoticeEvent(StringEncoder.GetString(metaEventData));
break;
case 0x03:
midiEvent = new SequenceOrTrackNameEvent(StringEncoder.GetString(metaEventData));
break;
case 0x04:
midiEvent = new InstrumentNameEvent(deltaTime, StringEncoder.GetString(metaEventData));
break;
case 0x05:
midiEvent = new LyricsEvent(deltaTime, StringEncoder.GetString(metaEventData));
break;
case 0x06:
midiEvent = new MarkerEvent(deltaTime, StringEncoder.GetString(metaEventData));
break;
case 0x07:
midiEvent = new CuePointEvent(deltaTime, StringEncoder.GetString(metaEventData));
break;
case 0x20:
midiEvent = new MIDIChannelPrefixEvent(deltaTime, metaEventData[0]);
break;
case 0x2F:
midiEvent = new EndOfTrackEvent(deltaTime);
break;
case 0x51:
var tempo =
(metaEventData[2] & 0x0F) +
((metaEventData[2] & 0xF0) * 16) +
((metaEventData[1] & 0x0F) * 256) +
((metaEventData[1] & 0xF0) * 4096) +
((metaEventData[0] & 0x0F) * 65536) +
((metaEventData[0] & 0xF0) * 1048576);
midiEvent = new SetTempoEvent(deltaTime, tempo);
break;
case 0x54:
midiEvent = new SMPTEOffsetEvent(deltaTime, metaEventData[0], metaEventData[1], metaEventData[2], metaEventData[3], metaEventData[4]);
break;
case 0x58:
midiEvent = new TimeSignatureEvent(deltaTime, metaEventData[0], metaEventData[1], metaEventData[2], metaEventData[3]);
break;
case 0x59:
midiEvent = new KeySignatureEvent(deltaTime, metaEventData[0], metaEventData[1]);
break;
case 0x7F:
midiEvent = new SequencerSpecificEvent(deltaTime, metaEventData);
break;
}
i += metaEventLength;
}
// System Exclusive Events
else if (eventTypeValue == 0xF0 || eventTypeValue == 0xF7)
{
var lengthTemp = new List <byte>();
do
{
i += 1;
lengthTemp.Add(trackData.ElementAt(i));
} while (trackData.ElementAt(i) > 0x7F);
var eventLength = VariableLengthUtil.decode_to_int(lengthTemp);
i += 1;
var eventData = Enumerable.Range(i, eventLength).Select(trackData.ElementAt);
midiEvent = new SysexEvent(deltaTime, eventTypeValue, eventData);
i += eventLength;
}
}
return(midiEvent != null
? new Tuple <Option <MidiEvent>, int, byte>(new Some <MidiEvent>(midiEvent), i - startIndex, lastMidiChannel)
: new Tuple <Option <MidiEvent>, int, byte>(new None <MidiEvent>(), i - startIndex, lastMidiChannel));
}
public void ProcessRawInput(Message m)
{
if (m.Msg == WM_INPUT)
{
uint dwSize = 0;
GetRawInputData(m.LParam,
RID_INPUT, IntPtr.Zero,
ref dwSize,
(uint)Marshal.SizeOf(typeof(RAWINPUTHEADER)));
IntPtr buffer = Marshal.AllocHGlobal((int)dwSize);
try
{
if (buffer != IntPtr.Zero &&
GetRawInputData(m.LParam,
RID_INPUT,
buffer,
ref dwSize,
(uint)Marshal.SizeOf(typeof(RAWINPUTHEADER))) == dwSize)
{
RAWINPUT raw = (RAWINPUT)Marshal.PtrToStructure(buffer, typeof(RAWINPUT));
if (raw.header.dwType == RIM_TYPEHID)
{
if (hidevent != null)
{
if (!(raw.hid.dwSizeHid > 1 && //Make sure our HID msg size more than 1. In fact the first ushort is irrelevant to us for now
raw.hid.dwCount > 0)) //Check that we have at least one HID msg
{
return;
}
//Allocate a buffer for one HID input
byte[] InputReport = new byte[raw.hid.dwSizeHid];
//Debug.WriteLine("Raw input contains " + raw.hid.dwCount + " HID input report(s)");
//For each HID input report in our raw input
for (int i = 0; i < raw.hid.dwCount; i++)
{
//Compute the address from which to copy our HID input
int hidInputOffset = 0;
unsafe
{
byte *source = (byte *)buffer;
source += sizeof(RAWINPUTHEADER) + sizeof(RAWHID) + (raw.hid.dwSizeHid * i);
hidInputOffset = (int)source;
}
//Copy HID input into our buffer
Marshal.Copy(new IntPtr(hidInputOffset), InputReport, 0, (int)raw.hid.dwSizeHid);
//
//for (int j = 0; j < InputReport.Length; j++)
//{
// Debug.WriteLine("Input report " + j.ToString() + ": " + InputReport[j].ToString());
//}
int xval = InputReport[2] * 256 + InputReport[1];
int yval = InputReport[4] * 256 + InputReport[3];
//Debug.WriteLine("Input report: " + yval.ToString());
ControllerEvent hideventinfo = new ControllerEvent(raw.header.hDevice, 0, xval, yval,
stopWatch.ElapsedTicks * 1e3 / Stopwatch.Frequency);
hidevent(this, hideventinfo);
//ProcessInputReport(InputReport);
}
//Debug.WriteLine("received something: " + raw.header.hDevice.ToString() /*+ raw.hid.bRawData[0].ToString()*/);
}
//Debug.WriteLine((stopWatch.ElapsedTicks * 1e3 / Stopwatch.Frequency).ToString() + ", " +
// raw.mouse.lLastX.ToString() + ", " +
// raw.mouse.lLastY.ToString());
}
}
}
finally
{
Marshal.FreeHGlobal(buffer);
}
}
}
public PointingAction(ControllerEvent evnt, Action <GameTime, PointingEvent> action)
: base(evnt, action)
{
}
void gameController_RaiseControllerEvent(object sender, ControllerEvent e)
{
if (!isWhite)
{
switch (e.p)
{
case (PieceType.P):
foreach (Border b in PawnList)
{
if (b.Visibility == Visibility.Hidden)
{
b.Visibility = Visibility.Visible;
return;
}
}
break;
case (PieceType.R):
foreach (Border b in RookList)
{
if (b.Visibility == Visibility.Hidden)
{
b.Visibility = Visibility.Visible;
return;
}
}
break;
case (PieceType.B):
foreach (Border b in BishopList)
{
if (b.Visibility == Visibility.Hidden)
{
b.Visibility = Visibility.Visible;
return;
}
}
break;
case (PieceType.N):
foreach (Border b in KnightList)
{
if (b.Visibility == Visibility.Hidden)
{
b.Visibility = Visibility.Visible;
return;
}
}
break;
case (PieceType.Q):
Queen.Visibility = Visibility.Visible;
break;
default:
break;
}
}
else
{
switch (e.p)
{
case (PieceType.p):
foreach (Border b in PawnList)
{
if (b.Visibility == Visibility.Hidden)
{
b.Visibility = Visibility.Visible;
return;
}
}
break;
case (PieceType.r):
foreach (Border b in RookList)
{
if (b.Visibility == Visibility.Hidden)
{
b.Visibility = Visibility.Visible;
return;
}
}
break;
case (PieceType.b):
foreach (Border b in BishopList)
{
if (b.Visibility == Visibility.Hidden)
{
b.Visibility = Visibility.Visible;
return;
}
}
break;
case (PieceType.n):
foreach (Border b in KnightList)
{
if (b.Visibility == Visibility.Hidden)
{
b.Visibility = Visibility.Visible;
return;
}
}
break;
case (PieceType.q):
Queen.Visibility = Visibility.Visible;
break;
default:
break;
}
}
}
void Arduino_MessageSend(object sender, ControllerEvent <string> e)
{
Simulator.Send(e.GetData);
Log("MessageSend " + e.GetData);
}
void Arduino_MessageReceived(object sender, ControllerEvent <string> e)
{
Log("MessageReceived " + e.GetData);
}
void _Arduino_ErrorOccurred(object sender, ControllerEvent <Exception> e)
{
Log("Error " + e.GetData.ToString());
MessageBox.Show(e.GetData.Message, "Error");
}
protected override void OnControllerInput(ControllerEvent controllerInput)
{
}
private void ControllerHandler(ControllerEvent e)
{
_IsActive = e.IsActive;
_Controller.IsActive = e.IsActive;
}
void Arduino_TimoutReceived(object sender, ControllerEvent <string> e)
{
Log(e.GetData);
}
protected abstract void OnControllerInput(ControllerEvent controllerInput);
void Arduino_JobFinished(object sender, ControllerEvent <bool> e)
{
Log("JobFinished");
}
void SendControllerEvent(ControllerEvent controllerEvent)
{
if(OnControllerEvent != null)
OnControllerEvent(controllerEvent);
}
