mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-11-15 05:47:56 -07:00
84467d2ff1
Current master (d17db57b9d4354752e0af42f5f33007a42ef2906) because Android support was added after the current release (0.8.0-rc1).
533 lines
15 KiB
C++
533 lines
15 KiB
C++
/*******************************************************
|
|
Demo Program for HIDAPI
|
|
|
|
Alan Ott
|
|
Signal 11 Software
|
|
|
|
2010-07-20
|
|
|
|
Copyright 2010, All Rights Reserved
|
|
|
|
This contents of this file may be used by anyone
|
|
for any reason without any conditions and may be
|
|
used as a starting point for your own applications
|
|
which use HIDAPI.
|
|
********************************************************/
|
|
|
|
|
|
#include <fx.h>
|
|
|
|
#include "hidapi.h"
|
|
#include "mac_support.h"
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <limits.h>
|
|
|
|
#ifdef _WIN32
|
|
// Thanks Microsoft, but I know how to use strncpy().
|
|
#pragma warning(disable:4996)
|
|
#endif
|
|
|
|
class MainWindow : public FXMainWindow {
|
|
FXDECLARE(MainWindow)
|
|
|
|
public:
|
|
enum {
|
|
ID_FIRST = FXMainWindow::ID_LAST,
|
|
ID_CONNECT,
|
|
ID_DISCONNECT,
|
|
ID_RESCAN,
|
|
ID_SEND_OUTPUT_REPORT,
|
|
ID_SEND_FEATURE_REPORT,
|
|
ID_GET_FEATURE_REPORT,
|
|
ID_CLEAR,
|
|
ID_TIMER,
|
|
ID_MAC_TIMER,
|
|
ID_LAST,
|
|
};
|
|
|
|
private:
|
|
FXList *device_list;
|
|
FXButton *connect_button;
|
|
FXButton *disconnect_button;
|
|
FXButton *rescan_button;
|
|
FXButton *output_button;
|
|
FXLabel *connected_label;
|
|
FXTextField *output_text;
|
|
FXTextField *output_len;
|
|
FXButton *feature_button;
|
|
FXButton *get_feature_button;
|
|
FXTextField *feature_text;
|
|
FXTextField *feature_len;
|
|
FXTextField *get_feature_text;
|
|
FXText *input_text;
|
|
FXFont *title_font;
|
|
|
|
struct hid_device_info *devices;
|
|
hid_device *connected_device;
|
|
size_t getDataFromTextField(FXTextField *tf, char *buf, size_t len);
|
|
int getLengthFromTextField(FXTextField *tf);
|
|
|
|
|
|
protected:
|
|
MainWindow() {};
|
|
public:
|
|
MainWindow(FXApp *a);
|
|
~MainWindow();
|
|
virtual void create();
|
|
|
|
long onConnect(FXObject *sender, FXSelector sel, void *ptr);
|
|
long onDisconnect(FXObject *sender, FXSelector sel, void *ptr);
|
|
long onRescan(FXObject *sender, FXSelector sel, void *ptr);
|
|
long onSendOutputReport(FXObject *sender, FXSelector sel, void *ptr);
|
|
long onSendFeatureReport(FXObject *sender, FXSelector sel, void *ptr);
|
|
long onGetFeatureReport(FXObject *sender, FXSelector sel, void *ptr);
|
|
long onClear(FXObject *sender, FXSelector sel, void *ptr);
|
|
long onTimeout(FXObject *sender, FXSelector sel, void *ptr);
|
|
long onMacTimeout(FXObject *sender, FXSelector sel, void *ptr);
|
|
};
|
|
|
|
// FOX 1.7 changes the timeouts to all be nanoseconds.
|
|
// Fox 1.6 had all timeouts as milliseconds.
|
|
#if (FOX_MINOR >= 7)
|
|
const int timeout_scalar = 1000*1000;
|
|
#else
|
|
const int timeout_scalar = 1;
|
|
#endif
|
|
|
|
FXMainWindow *g_main_window;
|
|
|
|
|
|
FXDEFMAP(MainWindow) MainWindowMap [] = {
|
|
FXMAPFUNC(SEL_COMMAND, MainWindow::ID_CONNECT, MainWindow::onConnect ),
|
|
FXMAPFUNC(SEL_COMMAND, MainWindow::ID_DISCONNECT, MainWindow::onDisconnect ),
|
|
FXMAPFUNC(SEL_COMMAND, MainWindow::ID_RESCAN, MainWindow::onRescan ),
|
|
FXMAPFUNC(SEL_COMMAND, MainWindow::ID_SEND_OUTPUT_REPORT, MainWindow::onSendOutputReport ),
|
|
FXMAPFUNC(SEL_COMMAND, MainWindow::ID_SEND_FEATURE_REPORT, MainWindow::onSendFeatureReport ),
|
|
FXMAPFUNC(SEL_COMMAND, MainWindow::ID_GET_FEATURE_REPORT, MainWindow::onGetFeatureReport ),
|
|
FXMAPFUNC(SEL_COMMAND, MainWindow::ID_CLEAR, MainWindow::onClear ),
|
|
FXMAPFUNC(SEL_TIMEOUT, MainWindow::ID_TIMER, MainWindow::onTimeout ),
|
|
FXMAPFUNC(SEL_TIMEOUT, MainWindow::ID_MAC_TIMER, MainWindow::onMacTimeout ),
|
|
};
|
|
|
|
FXIMPLEMENT(MainWindow, FXMainWindow, MainWindowMap, ARRAYNUMBER(MainWindowMap));
|
|
|
|
MainWindow::MainWindow(FXApp *app)
|
|
: FXMainWindow(app, "HIDAPI Test Application", NULL, NULL, DECOR_ALL, 200,100, 425,700)
|
|
{
|
|
devices = NULL;
|
|
connected_device = NULL;
|
|
|
|
FXVerticalFrame *vf = new FXVerticalFrame(this, LAYOUT_FILL_Y|LAYOUT_FILL_X);
|
|
|
|
FXLabel *label = new FXLabel(vf, "HIDAPI Test Tool");
|
|
title_font = new FXFont(getApp(), "Arial", 14, FXFont::Bold);
|
|
label->setFont(title_font);
|
|
|
|
new FXLabel(vf,
|
|
"Select a device and press Connect.", NULL, JUSTIFY_LEFT);
|
|
new FXLabel(vf,
|
|
"Output data bytes can be entered in the Output section, \n"
|
|
"separated by space, comma or brackets. Data starting with 0x\n"
|
|
"is treated as hex. Data beginning with a 0 is treated as \n"
|
|
"octal. All other data is treated as decimal.", NULL, JUSTIFY_LEFT);
|
|
new FXLabel(vf,
|
|
"Data received from the device appears in the Input section.",
|
|
NULL, JUSTIFY_LEFT);
|
|
new FXLabel(vf,
|
|
"Optionally, a report length may be specified. Extra bytes are\n"
|
|
"padded with zeros. If no length is specified, the length is \n"
|
|
"inferred from the data.",
|
|
NULL, JUSTIFY_LEFT);
|
|
new FXLabel(vf, "");
|
|
|
|
// Device List and Connect/Disconnect buttons
|
|
FXHorizontalFrame *hf = new FXHorizontalFrame(vf, LAYOUT_FILL_X);
|
|
//device_list = new FXList(new FXHorizontalFrame(hf,FRAME_SUNKEN|FRAME_THICK, 0,0,0,0, 0,0,0,0), NULL, 0, LISTBOX_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_FIX_WIDTH|LAYOUT_FIX_HEIGHT, 0,0,300,200);
|
|
device_list = new FXList(new FXHorizontalFrame(hf,FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0,0,0,0, 0,0,0,0), NULL, 0, LISTBOX_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0,0,300,200);
|
|
FXVerticalFrame *buttonVF = new FXVerticalFrame(hf);
|
|
connect_button = new FXButton(buttonVF, "Connect", NULL, this, ID_CONNECT, BUTTON_NORMAL|LAYOUT_FILL_X);
|
|
disconnect_button = new FXButton(buttonVF, "Disconnect", NULL, this, ID_DISCONNECT, BUTTON_NORMAL|LAYOUT_FILL_X);
|
|
disconnect_button->disable();
|
|
rescan_button = new FXButton(buttonVF, "Re-Scan devices", NULL, this, ID_RESCAN, BUTTON_NORMAL|LAYOUT_FILL_X);
|
|
new FXHorizontalFrame(buttonVF, 0, 0,0,0,0, 0,0,50,0);
|
|
|
|
connected_label = new FXLabel(vf, "Disconnected");
|
|
|
|
new FXHorizontalFrame(vf);
|
|
|
|
// Output Group Box
|
|
FXGroupBox *gb = new FXGroupBox(vf, "Output", FRAME_GROOVE|LAYOUT_FILL_X);
|
|
FXMatrix *matrix = new FXMatrix(gb, 3, MATRIX_BY_COLUMNS|LAYOUT_FILL_X);
|
|
new FXLabel(matrix, "Data");
|
|
new FXLabel(matrix, "Length");
|
|
new FXLabel(matrix, "");
|
|
|
|
//hf = new FXHorizontalFrame(gb, LAYOUT_FILL_X);
|
|
output_text = new FXTextField(matrix, 30, NULL, 0, TEXTFIELD_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_COLUMN);
|
|
output_text->setText("1 0x81 0");
|
|
output_len = new FXTextField(matrix, 5, NULL, 0, TEXTFIELD_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_COLUMN);
|
|
output_button = new FXButton(matrix, "Send Output Report", NULL, this, ID_SEND_OUTPUT_REPORT, BUTTON_NORMAL|LAYOUT_FILL_X);
|
|
output_button->disable();
|
|
//new FXHorizontalFrame(matrix, LAYOUT_FILL_X);
|
|
|
|
//hf = new FXHorizontalFrame(gb, LAYOUT_FILL_X);
|
|
feature_text = new FXTextField(matrix, 30, NULL, 0, TEXTFIELD_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_COLUMN);
|
|
feature_len = new FXTextField(matrix, 5, NULL, 0, TEXTFIELD_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_COLUMN);
|
|
feature_button = new FXButton(matrix, "Send Feature Report", NULL, this, ID_SEND_FEATURE_REPORT, BUTTON_NORMAL|LAYOUT_FILL_X);
|
|
feature_button->disable();
|
|
|
|
get_feature_text = new FXTextField(matrix, 30, NULL, 0, TEXTFIELD_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_COLUMN);
|
|
new FXWindow(matrix);
|
|
get_feature_button = new FXButton(matrix, "Get Feature Report", NULL, this, ID_GET_FEATURE_REPORT, BUTTON_NORMAL|LAYOUT_FILL_X);
|
|
get_feature_button->disable();
|
|
|
|
|
|
// Input Group Box
|
|
gb = new FXGroupBox(vf, "Input", FRAME_GROOVE|LAYOUT_FILL_X|LAYOUT_FILL_Y);
|
|
FXVerticalFrame *innerVF = new FXVerticalFrame(gb, LAYOUT_FILL_X|LAYOUT_FILL_Y);
|
|
input_text = new FXText(new FXHorizontalFrame(innerVF,LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, 0,0,0,0, 0,0,0,0), NULL, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y);
|
|
input_text->setEditable(false);
|
|
new FXButton(innerVF, "Clear", NULL, this, ID_CLEAR, BUTTON_NORMAL|LAYOUT_RIGHT);
|
|
|
|
|
|
}
|
|
|
|
MainWindow::~MainWindow()
|
|
{
|
|
if (connected_device)
|
|
hid_close(connected_device);
|
|
hid_exit();
|
|
delete title_font;
|
|
}
|
|
|
|
void
|
|
MainWindow::create()
|
|
{
|
|
FXMainWindow::create();
|
|
show();
|
|
|
|
onRescan(NULL, 0, NULL);
|
|
|
|
|
|
#ifdef __APPLE__
|
|
init_apple_message_system();
|
|
#endif
|
|
|
|
getApp()->addTimeout(this, ID_MAC_TIMER,
|
|
50 * timeout_scalar /*50ms*/);
|
|
}
|
|
|
|
long
|
|
MainWindow::onConnect(FXObject *sender, FXSelector sel, void *ptr)
|
|
{
|
|
if (connected_device != NULL)
|
|
return 1;
|
|
|
|
FXint cur_item = device_list->getCurrentItem();
|
|
if (cur_item < 0)
|
|
return -1;
|
|
FXListItem *item = device_list->getItem(cur_item);
|
|
if (!item)
|
|
return -1;
|
|
struct hid_device_info *device_info = (struct hid_device_info*) item->getData();
|
|
if (!device_info)
|
|
return -1;
|
|
|
|
connected_device = hid_open_path(device_info->path);
|
|
|
|
if (!connected_device) {
|
|
FXMessageBox::error(this, MBOX_OK, "Device Error", "Unable To Connect to Device");
|
|
return -1;
|
|
}
|
|
|
|
hid_set_nonblocking(connected_device, 1);
|
|
|
|
getApp()->addTimeout(this, ID_TIMER,
|
|
5 * timeout_scalar /*5ms*/);
|
|
|
|
FXString s;
|
|
s.format("Connected to: %04hx:%04hx -", device_info->vendor_id, device_info->product_id);
|
|
s += FXString(" ") + device_info->manufacturer_string;
|
|
s += FXString(" ") + device_info->product_string;
|
|
connected_label->setText(s);
|
|
output_button->enable();
|
|
feature_button->enable();
|
|
get_feature_button->enable();
|
|
connect_button->disable();
|
|
disconnect_button->enable();
|
|
input_text->setText("");
|
|
|
|
|
|
return 1;
|
|
}
|
|
|
|
long
|
|
MainWindow::onDisconnect(FXObject *sender, FXSelector sel, void *ptr)
|
|
{
|
|
hid_close(connected_device);
|
|
connected_device = NULL;
|
|
connected_label->setText("Disconnected");
|
|
output_button->disable();
|
|
feature_button->disable();
|
|
get_feature_button->disable();
|
|
connect_button->enable();
|
|
disconnect_button->disable();
|
|
|
|
getApp()->removeTimeout(this, ID_TIMER);
|
|
|
|
return 1;
|
|
}
|
|
|
|
long
|
|
MainWindow::onRescan(FXObject *sender, FXSelector sel, void *ptr)
|
|
{
|
|
struct hid_device_info *cur_dev;
|
|
|
|
device_list->clearItems();
|
|
|
|
// List the Devices
|
|
hid_free_enumeration(devices);
|
|
devices = hid_enumerate(0x0, 0x0);
|
|
cur_dev = devices;
|
|
while (cur_dev) {
|
|
// Add it to the List Box.
|
|
FXString s;
|
|
FXString usage_str;
|
|
s.format("%04hx:%04hx -", cur_dev->vendor_id, cur_dev->product_id);
|
|
s += FXString(" ") + cur_dev->manufacturer_string;
|
|
s += FXString(" ") + cur_dev->product_string;
|
|
usage_str.format(" (usage: %04hx:%04hx) ", cur_dev->usage_page, cur_dev->usage);
|
|
s += usage_str;
|
|
FXListItem *li = new FXListItem(s, NULL, cur_dev);
|
|
device_list->appendItem(li);
|
|
|
|
cur_dev = cur_dev->next;
|
|
}
|
|
|
|
if (device_list->getNumItems() == 0)
|
|
device_list->appendItem("*** No Devices Connected ***");
|
|
else {
|
|
device_list->selectItem(0);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
size_t
|
|
MainWindow::getDataFromTextField(FXTextField *tf, char *buf, size_t len)
|
|
{
|
|
const char *delim = " ,{}\t\r\n";
|
|
FXString data = tf->getText();
|
|
const FXchar *d = data.text();
|
|
size_t i = 0;
|
|
|
|
// Copy the string from the GUI.
|
|
size_t sz = strlen(d);
|
|
char *str = (char*) malloc(sz+1);
|
|
strcpy(str, d);
|
|
|
|
// For each token in the string, parse and store in buf[].
|
|
char *token = strtok(str, delim);
|
|
while (token) {
|
|
char *endptr;
|
|
long int val = strtol(token, &endptr, 0);
|
|
buf[i++] = val;
|
|
token = strtok(NULL, delim);
|
|
}
|
|
|
|
free(str);
|
|
return i;
|
|
}
|
|
|
|
/* getLengthFromTextField()
|
|
Returns length:
|
|
0: empty text field
|
|
>0: valid length
|
|
-1: invalid length */
|
|
int
|
|
MainWindow::getLengthFromTextField(FXTextField *tf)
|
|
{
|
|
long int len;
|
|
FXString str = tf->getText();
|
|
size_t sz = str.length();
|
|
|
|
if (sz > 0) {
|
|
char *endptr;
|
|
len = strtol(str.text(), &endptr, 0);
|
|
if (endptr != str.text() && *endptr == '\0') {
|
|
if (len <= 0) {
|
|
FXMessageBox::error(this, MBOX_OK, "Invalid length", "Enter a length greater than zero.");
|
|
return -1;
|
|
}
|
|
return len;
|
|
}
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
long
|
|
MainWindow::onSendOutputReport(FXObject *sender, FXSelector sel, void *ptr)
|
|
{
|
|
char buf[256];
|
|
size_t data_len, len;
|
|
int textfield_len;
|
|
|
|
memset(buf, 0x0, sizeof(buf));
|
|
textfield_len = getLengthFromTextField(output_len);
|
|
data_len = getDataFromTextField(output_text, buf, sizeof(buf));
|
|
|
|
if (textfield_len < 0) {
|
|
FXMessageBox::error(this, MBOX_OK, "Invalid length", "Length field is invalid. Please enter a number in hex, octal, or decimal.");
|
|
return 1;
|
|
}
|
|
|
|
if (textfield_len > sizeof(buf)) {
|
|
FXMessageBox::error(this, MBOX_OK, "Invalid length", "Length field is too long.");
|
|
return 1;
|
|
}
|
|
|
|
len = (textfield_len)? textfield_len: data_len;
|
|
|
|
int res = hid_write(connected_device, (const unsigned char*)buf, len);
|
|
if (res < 0) {
|
|
FXMessageBox::error(this, MBOX_OK, "Error Writing", "Could not write to device. Error reported was: %ls", hid_error(connected_device));
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
long
|
|
MainWindow::onSendFeatureReport(FXObject *sender, FXSelector sel, void *ptr)
|
|
{
|
|
char buf[256];
|
|
size_t data_len, len;
|
|
int textfield_len;
|
|
|
|
memset(buf, 0x0, sizeof(buf));
|
|
textfield_len = getLengthFromTextField(feature_len);
|
|
data_len = getDataFromTextField(feature_text, buf, sizeof(buf));
|
|
|
|
if (textfield_len < 0) {
|
|
FXMessageBox::error(this, MBOX_OK, "Invalid length", "Length field is invalid. Please enter a number in hex, octal, or decimal.");
|
|
return 1;
|
|
}
|
|
|
|
if (textfield_len > sizeof(buf)) {
|
|
FXMessageBox::error(this, MBOX_OK, "Invalid length", "Length field is too long.");
|
|
return 1;
|
|
}
|
|
|
|
len = (textfield_len)? textfield_len: data_len;
|
|
|
|
int res = hid_send_feature_report(connected_device, (const unsigned char*)buf, len);
|
|
if (res < 0) {
|
|
FXMessageBox::error(this, MBOX_OK, "Error Writing", "Could not send feature report to device. Error reported was: %ls", hid_error(connected_device));
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
long
|
|
MainWindow::onGetFeatureReport(FXObject *sender, FXSelector sel, void *ptr)
|
|
{
|
|
char buf[256];
|
|
size_t len;
|
|
|
|
memset(buf, 0x0, sizeof(buf));
|
|
len = getDataFromTextField(get_feature_text, buf, sizeof(buf));
|
|
|
|
if (len != 1) {
|
|
FXMessageBox::error(this, MBOX_OK, "Too many numbers", "Enter only a single report number in the text field");
|
|
}
|
|
|
|
int res = hid_get_feature_report(connected_device, (unsigned char*)buf, sizeof(buf));
|
|
if (res < 0) {
|
|
FXMessageBox::error(this, MBOX_OK, "Error Getting Report", "Could not get feature report from device. Error reported was: %ls", hid_error(connected_device));
|
|
}
|
|
|
|
if (res > 0) {
|
|
FXString s;
|
|
s.format("Returned Feature Report. %d bytes:\n", res);
|
|
for (int i = 0; i < res; i++) {
|
|
FXString t;
|
|
t.format("%02hhx ", buf[i]);
|
|
s += t;
|
|
if ((i+1) % 4 == 0)
|
|
s += " ";
|
|
if ((i+1) % 16 == 0)
|
|
s += "\n";
|
|
}
|
|
s += "\n";
|
|
input_text->appendText(s);
|
|
input_text->setBottomLine(INT_MAX);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
long
|
|
MainWindow::onClear(FXObject *sender, FXSelector sel, void *ptr)
|
|
{
|
|
input_text->setText("");
|
|
return 1;
|
|
}
|
|
|
|
long
|
|
MainWindow::onTimeout(FXObject *sender, FXSelector sel, void *ptr)
|
|
{
|
|
unsigned char buf[256];
|
|
int res = hid_read(connected_device, buf, sizeof(buf));
|
|
|
|
if (res > 0) {
|
|
FXString s;
|
|
s.format("Received %d bytes:\n", res);
|
|
for (int i = 0; i < res; i++) {
|
|
FXString t;
|
|
t.format("%02hhx ", buf[i]);
|
|
s += t;
|
|
if ((i+1) % 4 == 0)
|
|
s += " ";
|
|
if ((i+1) % 16 == 0)
|
|
s += "\n";
|
|
}
|
|
s += "\n";
|
|
input_text->appendText(s);
|
|
input_text->setBottomLine(INT_MAX);
|
|
}
|
|
if (res < 0) {
|
|
input_text->appendText("hid_read() returned error\n");
|
|
input_text->setBottomLine(INT_MAX);
|
|
}
|
|
|
|
getApp()->addTimeout(this, ID_TIMER,
|
|
5 * timeout_scalar /*5ms*/);
|
|
return 1;
|
|
}
|
|
|
|
long
|
|
MainWindow::onMacTimeout(FXObject *sender, FXSelector sel, void *ptr)
|
|
{
|
|
#ifdef __APPLE__
|
|
check_apple_events();
|
|
|
|
getApp()->addTimeout(this, ID_MAC_TIMER,
|
|
50 * timeout_scalar /*50ms*/);
|
|
#endif
|
|
|
|
return 1;
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
FXApp app("HIDAPI Test Application", "Signal 11 Software");
|
|
app.init(argc, argv);
|
|
g_main_window = new MainWindow(&app);
|
|
app.create();
|
|
app.run();
|
|
return 0;
|
|
}
|