public InputEvent inputEvent; // DeviceID, key, velocity
public ListViewItem入力リスト用(InputDeviceType deviceType, InputEvent inputEvent)
{
this.割り当て可能 = true;
this.deviceType = deviceType;
this.inputEvent = inputEvent;
switch (deviceType)
{
case InputDeviceType.Keyboard:
this.Text = $"Keyboard, {inputEvent.Key}, '{(Keys)inputEvent.Key}'";
break;
case InputDeviceType.GameController:
this.Text = $"GamePad, 0x{inputEvent.Key:X8}, '{HID.GetUsageName( (uint)inputEvent.Key )}'";
break;
case InputDeviceType.MidiIn:
if (inputEvent.押された)
{
if (255 != inputEvent.Key)
{
this.Text =
$"MidiIn[{inputEvent.DeviceID}], " +
$"{inputEvent.Extra}, " +
$"{Properties.Resources.TXT_ノートオン}, " +
$"Note={inputEvent.Key}, " +
$"Velocity={inputEvent.Velocity}";
this.割り当て可能 = true; // 割り当て可
this.ForeColor = System.Drawing.Color.Black; // 黒
}
else
{
// フットペダル
this.Text =
$"MidiIn[{inputEvent.DeviceID}], " +
$"{inputEvent.Extra}, " +
$"{Properties.Resources.TXT_コントロールチェンジ}, " +
$"Control={inputEvent.Control}(0x{inputEvent.Control:X2}), " +
$"Value={inputEvent.Velocity}";
this.割り当て可能 = false; // 割り当て不可
this.ForeColor = System.Drawing.Color.Green; // 緑
}
}
else if (inputEvent.離された)
{
this.Text =
$"MidiIn[{inputEvent.DeviceID}], " +
$"{inputEvent.Extra}, " +
$"{Properties.Resources.TXT_ノートオフ}, " +
$"Note={inputEvent.Key}, " +
$"Velocity={inputEvent.Velocity}";
this.割り当て可能 = false; // 割り当て不可
this.ForeColor = System.Drawing.Color.Gray; // 灰
}
break;
default:
throw new ArgumentException("未対応のデバイスです。");
}
}
private void WindowClosing(object sender, System.ComponentModel.CancelEventArgs e)
{
foreach (var device in foundDevices)
{
HID.CloseHidDevice(device);
}
}
public static void CreateOrShowExisting(HID device)
{
// See if we have an existing window for the device and if so pop it
// in front.
if (s_OpenWindows != null)
{
for (var i = 0; i < s_OpenWindows.Count; ++i)
{
var existingWindow = s_OpenWindows[i];
if (existingWindow.m_DeviceId == device.id)
{
existingWindow.Show();
existingWindow.Focus();
return;
}
}
}
// No, so create a new one.
var window = CreateInstance <HIDDescriptorWindow>();
window.InitializeWith(device);
window.minSize = new Vector2(270, 200);
window.Show();
window.titleContent = new GUIContent("HID Descriptor");
}
public BinaryData GetHeapItem(NID[] nodePath, HID hid)
{
var externalBlock = dataTreeReader.Read(nodePath, hid.BlockIndex)[0];
int pageMapOffset;
if (hid.BlockIndex == 0)
{
var hnHDR = HNHDR.OfValue(externalBlock.Take(12));
pageMapOffset = hnHDR.PageMapOffset;
}
else if (hid.BlockIndex == 8 || (hid.BlockIndex - 8) % 128 == 0)
{
var hnBitmapHDR = HNBITMAPHDR.OfValue(externalBlock.Take(66));
pageMapOffset = hnBitmapHDR.PageMapOffset;
}
else
{
var hnPageHDR = HNPAGEHDR.OfValue(externalBlock.Take(2));
pageMapOffset = hnPageHDR.PageMapOffset;
}
var pageMap = GetPageMapFromExternalDataBlock(externalBlock, pageMapOffset);
var items = heapOnNodeItemsLoader.Load(hid.BlockIndex, pageMap, externalBlock);
return(items[hid]);
}
static public int GetReaderPID(out byte[] PID)
{
PID = null;
//if(_IsOpen == false) return -1;
//if (_CommMode != UsbMode.ACM)
//{
// PID = InstanceofHID.GetReaderPID();
// Array.Reverse(PID);
// return 0;
//}
//else if (_CommMode == UsbMode.ACM)
//{
// PID = InstanceofVC.GetReaderPID();
// if (PID == null) return -1;
// return 0;
//}
//else return -1;
PID = HID.GetReaderPID();
if (PID != null)
{
Array.Reverse(PID);
return(0);
}
PID = VirtualCom.GetReaderPID();
if (PID != null)
{
return(0);
}
return(-1);
}
private void TestDevClick(object sender, RoutedEventArgs e)
{
if (Devices.SelectedIndex != -1)
{
HID.Write(foundDevices[Devices.SelectedIndex]);
}
}
private void Button1_Click(object sender, EventArgs e)
{
Button b = ((Button)sender);
this.WindowState = FormWindowState.Minimized;
HID.Start();
}
public BTHHEADER(int type, int key, int sizeOfDataValue, int indexDepth, HID root)
{
Type = type;
Key = key;
SizeOfDataValue = sizeOfDataValue;
IndexDepth = indexDepth;
Root = root;
}
void RefreshDevices()
{
Devices.Items.Clear();
foreach (var device in foundDevices)
{
HID.CloseHidDevice(device);
}
foundDevices.Clear();
var devices = HID.FindKnownHidDevices();
var vendor = int.Parse(Constants.Config.IniReadValue("Controller", "VendorID", "1118"));
foreach (var device in devices)
{
if (device.Attributes.VendorID == vendor)
{
var split = device.DevicePath.Split('\\');
var split2 = split.Last();
var split3 = split2.Split('#');
var devicePath = string.Join(@"\", split3, 0, 3).ToUpper();
var name = HID.GetProductString(device);
if (Constants.ControllerIDs.ContainsKey(device.Attributes.ProductID))
{
name = Constants.ControllerIDs[device.Attributes.ProductID];
}
var split4 = split3[1].Split('&');
foreach (var test in split4)
{
if (test.StartsWith("ig"))
{
var split5 = test.Split('_');
if (uint.TryParse(split5[1], NumberStyles.HexNumber, null, out uint id) && id > 0)
{
name += $" ({id / 2})";
}
}
}
var dev = new ListBoxItem()
{
ToolTip = new ToolTip {
Content = devicePath
},
Content = name,
};
foundDevices.Add(device);
Devices.Items.Add(dev);
}
}
}
public void Utilities_CanRecognizeVendorDefinedUsages()
{
string usagePage;
string usage;
HID.UsageToString((HID.UsagePage) 0xff01, 0x33, out usagePage, out usage);
Assert.That(usagePage, Is.EqualTo("Vendor-Defined"));
Assert.That(usage, Is.EqualTo("Vendor-Defined"));
}
static void SaveDeviceDescription(int deviceId, InputDeviceDescription deviceDescription)
{
var hidDescriptor = HID.ReadHIDDeviceDescriptor(ref deviceDescription, (ref InputDeviceCommand command) => InputRuntime.s_Instance.DeviceCommand(deviceId, ref command));
var json = EditorJsonUtility.ToJson(hidDescriptor, true);
var path = $"Assets/{deviceDescription}.json";
var fullPath = System.IO.Path.GetFullPath(path).Replace("\\", "/");
Debug.Log($"Saved ({deviceDescription}) (at {path}:1)\n\n{json}");
System.IO.File.WriteAllText(path, json);
}
void timer_Tick(object sender, EventArgs e)
{
if (_firstReader.GetStatusChange(out _status) == 0)
{
timer.Stop();
_firstReader.Connect(out _status);
_AtrString = _firstReader.getATR();
HID.Beep(3000, 200);
Thread.Sleep(2000);
}
}
public static BTHHEADER OfValue(BinaryData encodedData)
{
var parser = BinaryDataParser.OfValue(encodedData);
return
(new BTHHEADER(
parser.TakeAndSkip(1).ToInt32(),
parser.TakeAndSkip(1).ToInt32(),
parser.TakeAndSkip(1).ToInt32(),
parser.TakeAndSkip(1).ToInt32(),
HID.OfValue(parser.TakeAndSkip(4))));
}
public LectorHID()
{
uint pcchReaders = 0;
int nullindex = -1;
char nullchar = (char)0;
dwscope = 2;
// Establish context.
retval = HID.SCardEstablishContext(dwscope, IntPtr.Zero, IntPtr.Zero, out hContext);
retval = HID.SCardListReaders(hContext, null, null, ref pcchReaders);
byte[] mszReaders = new byte[pcchReaders];
// Fill readers buffer with second call.
retval = HID.SCardListReaders(hContext, null, mszReaders, ref pcchReaders);
// Populate List with readers.
string currbuff = Encoding.ASCII.GetString(mszReaders);
int len = (int)pcchReaders;
if (len > 0)
{
nullindex = currbuff.IndexOf(nullchar); // Get null end character.
string reader = currbuff.Substring(0, nullindex);
len = len - (reader.Length + 1);
currbuff = currbuff.Substring(nullindex + 1, len);
readerName = currbuff;
}
try
{
dwscope = 2;
if (readerName != "" && readerName != null)
{
retval = HID.SCardEstablishContext(dwscope, IntPtr.Zero, IntPtr.Zero, out hContext);
if (retval == 0)
{
Console.WriteLine("Contexto Establecido");
}
else
{
Console.WriteLine("Error Numero:{0}!!!", retval);
}
}
else
{
Console.WriteLine("Error Numero:{0}!!!", retval);
}
}
catch { }
}
private TreeViewItem BuildElementItem(int index, TreeViewItem parent, HID.HIDElementDescriptor element, ref int id, ref int runningBitOffset, ref HID.HIDReportType currentReportType)
{
var item = AddChild(parent, string.Format("Element {0} ({1})", index, element.reportType), ref id);
string usagePageString;
string usageString;
HID.UsageToString(element.usagePage, element.usage, out usagePageString, out usageString);
AddChild(item, string.Format("Usage Page: 0x{0:X} ({1})", (uint)element.usagePage, usagePageString), ref id);
if (usageString != null)
{
AddChild(item, string.Format("Usage: 0x{0:X} ({1})", element.usage, usageString), ref id);
}
else
{
AddChild(item, string.Format("Usage: 0x{0:X}", element.usage), ref id);
}
AddChild(item, "Report Type: " + element.reportType, ref id);
AddChild(item, "Report ID: " + element.reportId, ref id);
AddChild(item, "Report Size in Bits: " + element.reportSizeInBits, ref id);
AddChild(item, "Report Count: " + element.reportCount, ref id);
AddChild(item, "Collection Index: " + element.collectionIndex, ref id);
AddChild(item, string.Format("Unit: {0:X}", element.unit), ref id);
AddChild(item, string.Format("Unit Exponent: {0:X}", element.unitExponent), ref id);
AddChild(item, "Logical Min: " + element.logicalMin, ref id);
AddChild(item, "Logical Max: " + element.logicalMax, ref id);
AddChild(item, "Physical Min: " + element.physicalMin, ref id);
AddChild(item, "Physical Max: " + element.physicalMax, ref id);
AddChild(item, "Has Null State?: " + element.hasNullState, ref id);
AddChild(item, "Has Preferred State?: " + element.hasPreferredState, ref id);
AddChild(item, "Is Array?: " + element.isArray, ref id);
AddChild(item, "Is Non-Linear?: " + element.isNonLinear, ref id);
AddChild(item, "Is Relative?: " + element.isRelative, ref id);
AddChild(item, "Is Virtual?: " + element.isVirtual, ref id);
AddChild(item, "Is Wrapping?: " + element.isWrapping, ref id);
if (currentReportType != element.reportType)
{
currentReportType = element.reportType;
runningBitOffset = 0;
}
AddChild(item,
string.Format("Inferred Offset: byte #{0}, bit #{1}", runningBitOffset / 8, runningBitOffset % 8),
ref id);
runningBitOffset += element.reportSizeInBits;
return(item);
}
private void InitializeWith(HID device)
{
m_Device = device;
m_DeviceId = device.id;
if (m_TreeViewState == null)
{
m_TreeViewState = new TreeViewState();
}
m_TreeView = new HIDDescriptorTreeView(m_TreeViewState, m_Device.hidDescriptor);
m_TreeView.SetExpanded(1, true);
m_Label = new GUIContent(string.Format("HID Descriptor for '{0} {1}'", m_Device.description.manufacturer,
m_Device.description.product));
}
private void HIDHook_KeyboardAction(object sender, KeyboardEventArgs e)
{
var E = e.KeyInput;
if (E.Key == Keys.Escape)
{
HID.stop();
this.WindowState = FormWindowState.Normal;
return;
}
this.dataGridView1.Rows.Add(this.dataGridView1.Rows.Count, E.Status, E.Key, string.Empty, E.Time);
dataGridView1.FirstDisplayedScrollingRowIndex = dataGridView1.RowCount - 1;
}
public async Task <IActionResult> EditRequestCode(int id, string hid)
{
var uLog = HttpContext.Items["User"] as User;
var l = await _db.Licenses
.Include(ll => ll.ProductKey)
.Include(ll => ll.Hid)
.Where(ll => ll.Id == id).FirstOrDefaultAsync();
if (l == null)
{
return(RedirectToAction("Index"));
}
if (l.ProductKey == null)
{
return(RedirectToAction("Index"));
}
if (string.IsNullOrEmpty(hid))
{
return(View(new RequestCodeGetModel {
License = l, Error = 1
}));
}
if (!l.Active)
{
return(View(new RequestCodeGetModel {
License = l, Error = 2
}));
}
var hids = await _db.Hids.Select(hh => hh.Value).ToListAsync();
if (hids.Contains(hid))
{
return(View(new RequestCodeGetModel {
License = l, Error = 3
}));
}
var cnfc = GetConfirmCode(l.ProductKey.Key, hid);
var h = new HID {
Value = hid, AddedUser = uLog
};
_db.Hids.Remove(l.Hid);
l.Hid = h;
l.ConfirmCode = cnfc;
await _db.SaveChangesAsync();
return(RedirectToAction("Details", new { id = id }));
}
private BinaryData EncodeFirstBlock(
ExternalDataBlockForHeapOnNode block,
HID userRoot,
BinaryData fillLevelsForTheFirst8Blocks,
int clientSignature)
{
var hnHDR =
new HNHDR(
block.RawByteCountWithoutPageMapWithPadding,
0xEC,
clientSignature,
userRoot,
fillLevelsForTheFirst8Blocks);
return(EncodeBlock(block, headerEncoder.Encode(hnHDR)));
}
public TCINFO(
int type,
int numberOfColumns,
int[] groupsOffsets,
HID rowIndex,
BinaryData rowMatrix,
BinaryData deprecated,
TCOLDESC[] columnDescriptors)
{
Type = type;
NumberOfColumns = numberOfColumns;
GroupsOffsets = groupsOffsets;
RowIndex = rowIndex;
RowMatrix = rowMatrix;
Deprecated = deprecated;
ColumnDescriptors = columnDescriptors;
}
public IDictionary <HID, BinaryData> Load(int pageIndex, HNPAGEMAP pageMap, BinaryData pageData)
{
var items = new Dictionary <HID, BinaryData>();
var offsets = GetOffsetsFromPageMap(pageMap);
for (int i = 0; i < offsets.Length - 1; i++)
{
var itemData = pageData.Take(offsets[i], offsets[i + 1] - offsets[i]);
var hid = new HID(Constants.NID_TYPE_HID, i + 1, pageIndex);
items.Add(hid, itemData);
}
return(items);
}
private void OpenHIDDevice()
{
string[] devicePathName = new string[0];
if (HID.FindDevices(vid, pid, ref devicePathName) > 0)
{
hidDevice.pathName = devicePathName[0];
if (HID.OpenDevice(ref hidDevice))
{
hidDevice.readStream.BeginRead(hidReceivedBuffer, 0, hidReceivedBuffer.Length, new AsyncCallback(hidDevice_DataReceived), null);
ReadConfig();
}
}
UpdateUI();
}
private void usbMenuItem_Click(object sender, EventArgs e)
{
if (hidDevice.connected)
{
return;
}
commuTypeLbl.Text = "USB";
HID.RegisterDeviceNotification(this.Handle, ref notificationHandle);
OpenHIDDevice();
// close COM port
if ((serialPort != null) && (serialPort.IsOpen))
{
serialPort.Close();
serialPort = null;
}
}
private void InitializeWith(int deviceId, InputDeviceDescription deviceDescription)
{
m_DeviceId = deviceId;
m_DeviceDescription = deviceDescription;
m_Initialized = true;
// Set up tree view for HID desctiptor.
var hidDescriptor = HID.ReadHIDDeviceDescriptor(deviceId, ref m_DeviceDescription, InputRuntime.s_Instance);
if (m_TreeViewState == null)
{
m_TreeViewState = new TreeViewState();
}
m_TreeView = new HIDDescriptorTreeView(m_TreeViewState, hidDescriptor);
m_TreeView.SetExpanded(1, true);
m_Label = new GUIContent(string.Format("HID Descriptor for '{0} {1}'", deviceDescription.manufacturer,
deviceDescription.product));
}
private void Enumerate(
NID[] nodePath,
HID nodeId,
int keySize,
int dataSize,
int currentDepth,
List <DataRecord> dataRecords)
{
var node =
heapOnNodeReader.GetHeapItem(nodePath, nodeId);
if (currentDepth > 0)
{
var items = node.Slice(keySize + 4);
Array.ForEach(
items,
item =>
{
Enumerate(
nodePath,
HID.OfValue(item.Take(keySize, 4)),
keySize,
dataSize,
currentDepth - 1,
dataRecords);
});
}
else
{
var items = node.Slice(keySize + dataSize);
Array.ForEach(
items,
item =>
{
dataRecords.Add(
new DataRecord(
item.Take(keySize),
item.Take(keySize, dataSize)));
});
}
}
private void InitializeWith(int deviceId, InputDeviceDescription deviceDescription)
{
m_DeviceId = deviceId;
m_DeviceDescription = deviceDescription;
m_Initialized = true;
// Set up tree view for HID descriptor.
var hidDescriptor = HID.ReadHIDDeviceDescriptor(ref m_DeviceDescription,
(ref InputDeviceCommand command) => InputRuntime.s_Instance.DeviceCommand(m_DeviceId, ref command));
if (m_TreeViewState == null)
{
m_TreeViewState = new TreeViewState();
}
m_TreeView = new HIDDescriptorTreeView(m_TreeViewState, hidDescriptor);
m_TreeView.SetExpanded(1, true);
m_Label = new GUIContent(
$"HID Descriptor for '{deviceDescription.manufacturer} {deviceDescription.product}'");
}
protected override void WndProc(ref Message m)
{
if (m.Msg == Win32.WM_DEVICECHANGE)
{
if (m.WParam.ToInt32() == Win32.DBT_DEVICEARRIVAL)
{
OpenHIDDevice();
}
else if (m.WParam.ToInt32() == Win32.DBT_DEVICEREMOVECOMPLETE)
{
if (HID.DeviceNameMatch(m, hidDevice.pathName))
{
CloseHIDDevice();
}
}
UpdateUI();
}
base.WndProc(ref m);
}
public Maybe <DataRecord> ReadDataRecord(NID[] nodePath, HID userRoot, TKey key)
{
var userRootHeapItem = heapOnNodeReader.GetHeapItem(nodePath, userRoot);
var bthHeader =
BTHHEADER.OfValue(userRootHeapItem);
if (bthHeader.Root.Value == 0)
{
return(Maybe <DataRecord> .NoValue());
}
return
(FindDataRecord(
nodePath,
bthHeader.Root,
key,
bthHeader.Key,
bthHeader.SizeOfDataValue,
bthHeader.IndexDepth));
}
public static TCINFO OfValue(BinaryData encodedData)
{
var parser = BinaryDataParser.OfValue(encodedData);
var type = parser.TakeAndSkip(1).ToInt32();
var numberOfColumns = parser.TakeAndSkip(1).ToInt32();
var groupsOffsets = parser.Slice(4, 2).Select(s => s.ToInt32()).ToArray();
var rowIndex = HID.OfValue(parser.TakeAndSkip(4));
var rowMatrix = parser.TakeAndSkip(4);
var deprecated = parser.TakeAndSkip(4);
var columnDescriptors = parser.TakeAndSkip(numberOfColumns, 8, new FuncBasedDecoder <TCOLDESC>(TCOLDESC.OfValue));
return
(new TCINFO(
type,
numberOfColumns,
groupsOffsets,
rowIndex,
rowMatrix,
deprecated,
columnDescriptors));
}
private TreeViewItem BuildElementItem(int index, TreeViewItem parent, HID.HIDElementDescriptor element, ref int id)
{
var item = AddChild(parent, string.Format("Element {0} ({1})", index, element.reportType), ref id);
string usagePageString = HID.UsagePageToString(element.usagePage);
string usageString = HID.UsageToString(element.usagePage, element.usage);
AddChild(item, string.Format("Usage Page: 0x{0:X} ({1})", (uint)element.usagePage, usagePageString), ref id);
if (usageString != null)
{
AddChild(item, string.Format("Usage: 0x{0:X} ({1})", element.usage, usageString), ref id);
}
else
{
AddChild(item, string.Format("Usage: 0x{0:X}", element.usage), ref id);
}
AddChild(item, "Report Type: " + element.reportType, ref id);
AddChild(item, "Report ID: " + element.reportId, ref id);
AddChild(item, "Report Size in Bits: " + element.reportSizeInBits, ref id);
AddChild(item, "Report Bit Offset: " + element.reportOffsetInBits, ref id);
AddChild(item, "Collection Index: " + element.collectionIndex, ref id);
AddChild(item, string.Format("Unit: {0:X}", element.unit), ref id);
AddChild(item, string.Format("Unit Exponent: {0:X}", element.unitExponent), ref id);
AddChild(item, "Logical Min: " + element.logicalMin, ref id);
AddChild(item, "Logical Max: " + element.logicalMax, ref id);
AddChild(item, "Physical Min: " + element.physicalMin, ref id);
AddChild(item, "Physical Max: " + element.physicalMax, ref id);
AddChild(item, "Has Null State?: " + element.hasNullState, ref id);
AddChild(item, "Has Preferred State?: " + element.hasPreferredState, ref id);
AddChild(item, "Is Array?: " + element.isArray, ref id);
AddChild(item, "Is Non-Linear?: " + element.isNonLinear, ref id);
AddChild(item, "Is Relative?: " + element.isRelative, ref id);
AddChild(item, "Is Constant?: " + element.isConstant, ref id);
AddChild(item, "Is Wrapping?: " + element.isWrapping, ref id);
return(item);
}
