568 lines
19 KiB
C++
568 lines
19 KiB
C++
#include "touch.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include <windows.h>
|
|
#include <versionhelpers.h>
|
|
|
|
#include "util/logging.h"
|
|
#include "util/time.h"
|
|
#include "touch/touch.h"
|
|
|
|
// std::min
|
|
#ifdef min
|
|
#undef min
|
|
#endif
|
|
|
|
// std::max
|
|
#ifdef max
|
|
#undef max
|
|
#endif
|
|
|
|
namespace rawinput::touch {
|
|
|
|
// settings
|
|
bool DISABLED = false;
|
|
bool INVERTED = false;
|
|
|
|
// state
|
|
static bool DISPLAY_INITIALIZED = false;
|
|
static DWORD DISPLAY_ORIENTATION = DMDO_DEFAULT;
|
|
static long DISPLAY_SIZE_X = 1920L;
|
|
static long DISPLAY_SIZE_Y = 1080L;
|
|
|
|
bool is_touchscreen(Device *device) {
|
|
|
|
// check if disabled
|
|
if (DISABLED) {
|
|
return false;
|
|
}
|
|
|
|
// check device type
|
|
if (device->type != HID) {
|
|
return false;
|
|
}
|
|
|
|
auto *hid = device->hidInfo;
|
|
auto &attributes = hid->attributes;
|
|
|
|
// filter by VID/PID
|
|
if (attributes.VendorID > 0) {
|
|
|
|
// P2418HT
|
|
// touch points apparently aren't released and will stay
|
|
if (attributes.VendorID == 0x1FD2 && attributes.ProductID == 0x6103) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// ignore the "Touch Pad" (0x05) usage under the "Digitizers" (0x0d) usage page
|
|
if (hid->caps.UsagePage == 0x0d && hid->caps.Usage == 0x05) {
|
|
return false;
|
|
}
|
|
|
|
// check description
|
|
if (device->desc == "HID-compliant touch screen") {
|
|
// TODO: this only works on english OS (?)
|
|
return true;
|
|
}
|
|
|
|
// we can also check if there's touch point values inside
|
|
for (const auto &value_name : hid->value_caps_names) {
|
|
if (value_name == "Contact identifier") {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// nope this one probably not
|
|
return false;
|
|
}
|
|
|
|
void enable(Device *device) {
|
|
if (device->type == HID) {
|
|
device->hidInfo->touch.valid = true;
|
|
log_info("rawinput", "enabled touchscreen device: {} ({})", device->desc, device->name);
|
|
} else {
|
|
log_fatal("rawinput", "tried to enable touch functionality on non HID device");
|
|
}
|
|
}
|
|
|
|
void disable(Device *device) {
|
|
if (device->type == HID) {
|
|
device->hidInfo->touch.valid = false;
|
|
log_info("rawinput", "disabled touchscreen device: {} ({})", device->desc, device->name);
|
|
} else
|
|
log_fatal("rawinput", "tried to disable touch functionality on non HID device");
|
|
}
|
|
|
|
void update_input(Device *device) {
|
|
|
|
// check type
|
|
if (device->type != HID) {
|
|
log_fatal("rawinput", "touch update called on non HID device");
|
|
return;
|
|
}
|
|
|
|
// get touch info
|
|
auto hid = device->hidInfo;
|
|
auto &touch = hid->touch;
|
|
if (!touch.valid) {
|
|
|
|
// not a registered touchscreen
|
|
return;
|
|
}
|
|
|
|
// parse elements
|
|
if (!touch.parsed_elements) {
|
|
log_info("rawinput", "parsing touch elements");
|
|
|
|
// clear lists first
|
|
touch.elements_contact_count.clear();
|
|
touch.elements_contact_identifier.clear();
|
|
touch.elements_x.clear();
|
|
touch.elements_y.clear();
|
|
touch.elements_width.clear();
|
|
touch.elements_height.clear();
|
|
touch.elements_pressed.clear();
|
|
touch.elements_pressure.clear();
|
|
|
|
// get value indices
|
|
for (int i = 0; i < (int) hid->value_caps_names.size(); i++) {
|
|
auto &name = hid->value_caps_names[i];
|
|
if (name == "Contact count") {
|
|
touch.elements_contact_count.push_back(i);
|
|
} else if (name == "X") {
|
|
touch.elements_x.push_back(i);
|
|
} else if (name == "Y") {
|
|
touch.elements_y.push_back(i);
|
|
} else if (name == "Width") {
|
|
touch.elements_width.push_back(i);
|
|
} else if (name == "Height") {
|
|
touch.elements_height.push_back(i);
|
|
} else if (name == "Contact identifier") {
|
|
touch.elements_contact_identifier.push_back(i);
|
|
} else if (name == "Pressure") {
|
|
touch.elements_pressure.push_back(i);
|
|
}
|
|
}
|
|
|
|
// get button indices
|
|
for (int i = 0; i < (int) hid->button_caps_names.size(); i++) {
|
|
auto &name = hid->button_caps_names[i];
|
|
if (name == "Tip Switch") {
|
|
touch.elements_pressed.push_back(i);
|
|
}
|
|
}
|
|
|
|
// check sizes
|
|
auto touch_size = touch.elements_contact_identifier.size();
|
|
if (touch_size != touch.elements_x.size() ||
|
|
touch_size != touch.elements_y.size() ||
|
|
touch_size != touch.elements_pressed.size())
|
|
{
|
|
log_info("rawinput", "touch element size mismatch: {}:contacts, {}:x, {}:y, {}:pressed",
|
|
touch.elements_contact_identifier.size(),
|
|
touch.elements_x.size(),
|
|
touch.elements_y.size(),
|
|
touch.elements_pressed.size());
|
|
disable(device);
|
|
return;
|
|
}
|
|
|
|
// mark as parsed
|
|
touch.parsed_elements = true;
|
|
log_info("rawinput", "touch elements parsed: {} status fields", touch.elements_x.size());
|
|
}
|
|
|
|
// check if display is initialized
|
|
if (!DISPLAY_INITIALIZED) {
|
|
display_update();
|
|
}
|
|
|
|
// update timeouts here as well so events are in the right order
|
|
update_timeouts(device);
|
|
|
|
// determine the number of touches contained in this report, defaulting to the size of `elements_x`
|
|
size_t touch_report_count = touch.elements_x.size();
|
|
if (!touch.elements_contact_count.empty()) {
|
|
|
|
// support devices that have multiple "Contact count" fields, for some reason
|
|
size_t contact_count = 0;
|
|
for (auto &index : touch.elements_contact_count) {
|
|
contact_count = std::max(contact_count, (size_t) hid->value_states_raw[index]);
|
|
}
|
|
|
|
// hybrid mode devices will report a contact count of 0 for subsequent reports that are
|
|
// part of the same initial frame
|
|
if (contact_count > 0) {
|
|
if (contact_count > touch_report_count) {
|
|
touch.remaining_contact_count = contact_count - touch_report_count;
|
|
} else {
|
|
touch_report_count = contact_count;
|
|
touch.remaining_contact_count = 0;
|
|
}
|
|
} else if (touch.remaining_contact_count > 0) {
|
|
if (touch.remaining_contact_count > touch_report_count) {
|
|
touch.remaining_contact_count -= touch_report_count;
|
|
} else {
|
|
touch_report_count = touch.remaining_contact_count;
|
|
touch.remaining_contact_count = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// iterate all input data and get touch points
|
|
std::vector<HIDTouchPoint> touch_points;
|
|
touch_points.reserve(touch.elements_x.size());
|
|
for (size_t i = 0; i < touch.elements_x.size(); i++) {
|
|
|
|
// build touch point
|
|
HIDTouchPoint hid_tp{};
|
|
auto pos_x = hid->value_states[touch.elements_x[i]];
|
|
auto pos_y = hid->value_states[touch.elements_y[i]];
|
|
switch (DISPLAY_ORIENTATION) {
|
|
case DMDO_DEFAULT:
|
|
hid_tp.x = pos_x;
|
|
hid_tp.y = pos_y;
|
|
break;
|
|
case DMDO_90:
|
|
hid_tp.x = 1.f - pos_y;
|
|
hid_tp.y = pos_x;
|
|
break;
|
|
case DMDO_180:
|
|
hid_tp.x = 1.f - pos_x;
|
|
hid_tp.y = 1.f - pos_y;
|
|
break;
|
|
case DMDO_270:
|
|
hid_tp.x = pos_y;
|
|
hid_tp.y = 1.f - pos_x;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// optionally invert
|
|
if (INVERTED) {
|
|
hid_tp.x = 1.f - hid_tp.x;
|
|
hid_tp.y = 1.f - hid_tp.y;
|
|
}
|
|
|
|
// check if this touch point should be considered valid
|
|
//
|
|
// If "Contact count" reports there are no touch reports remaining and the X and Y
|
|
// coordinates of this touch point are zero, then this report element should be
|
|
// skipped.
|
|
if (touch_report_count == 0 && hid_tp.x == 0.f && hid_tp.y == 0.f) {
|
|
continue;
|
|
} else if (touch_report_count > 0) {
|
|
touch_report_count--;
|
|
}
|
|
|
|
// generate ID (hopefully unique)
|
|
hid_tp.id = (DWORD) hid->value_states_raw[touch.elements_contact_identifier[i]];
|
|
hid_tp.id += (DWORD) (0xFFFFFF + device->id * 512);
|
|
|
|
//std::string src = "(none)";
|
|
|
|
// check if tip switch is down
|
|
size_t index_pressed = touch.elements_pressed[i];
|
|
for (auto &button_states : hid->button_states) {
|
|
if (index_pressed < button_states.size()) {
|
|
hid_tp.down = button_states[index_pressed];
|
|
|
|
/*
|
|
if (hid_tp.down)
|
|
src = "pressed (index: " + to_string(touch.elements_pressed[i]) + ", state: " + to_string(button_states[index_pressed]) +")";
|
|
*/
|
|
|
|
break;
|
|
} else
|
|
index_pressed -= button_states.size();
|
|
}
|
|
|
|
// check width/height of touch point to see if pressed
|
|
float width = 0.f, height = 0.f;
|
|
if (!hid_tp.down && i < touch.elements_width.size() && i < touch.elements_height.size()) {
|
|
width = hid->value_states[touch.elements_width[i]];
|
|
height = hid->value_states[touch.elements_height[i]];
|
|
hid_tp.down = width > 0.f && height > 0.f;
|
|
|
|
/*
|
|
if (hid_tp.down)
|
|
src = "width_height (width index: " + to_string(touch.elements_width[i]) + ", height index: " + to_string(touch.elements_height[i]) + ")";
|
|
*/
|
|
}
|
|
|
|
// so last thing we can check is the pressure
|
|
if (!hid_tp.down && i < touch.elements_pressure.size()) {
|
|
auto pressure = hid->value_states[touch.elements_pressure[i]];
|
|
hid_tp.down = pressure > 0.f;
|
|
|
|
/*
|
|
if (hid_tp.down)
|
|
src = "pressure (index: " + to_string(touch.elements_pressure[i]) + ")";
|
|
*/
|
|
}
|
|
|
|
/*
|
|
log_info("rawinput",
|
|
"touch i: " + to_string(i) +
|
|
" (id: " + to_string(hid_tp.id) +
|
|
"), ci: " + to_string(hid->value_states_raw[touch.elements_contact_identifier[i]]) +
|
|
", x: " + to_string(pos_x) +
|
|
", y: " + to_string(pos_y) +
|
|
", width: " + to_string(width) +
|
|
", height: " + to_string(height) +
|
|
", down: " + to_string(hid_tp.down) +
|
|
", src: " + src);
|
|
*/
|
|
|
|
// add to touch points
|
|
touch_points.emplace_back(hid_tp);
|
|
}
|
|
|
|
// process touch points
|
|
std::vector<DWORD> touch_removes;
|
|
std::vector<TouchPoint> touch_writes;
|
|
std::vector<DWORD> touch_modifications;
|
|
for (auto &hid_tp : touch_points) {
|
|
|
|
// check if existing
|
|
auto existing = std::find_if(
|
|
touch.touch_points.begin(),
|
|
touch.touch_points.end(),
|
|
[hid_tp] (const HIDTouchPoint &x) {
|
|
return x.id == hid_tp.id;
|
|
});
|
|
|
|
/*
|
|
ssize_t ttl = -1;
|
|
int64_t last_report = -1;
|
|
if (existing != touch.touch_points.end()) {
|
|
ttl = existing->ttl;
|
|
last_report = existing->last_report;
|
|
}
|
|
|
|
log_info("rawinput",
|
|
"id: " + to_string(hid_tp.id) +
|
|
", existing: " + to_string(existing != touch.touch_points.end()) +
|
|
", ttl: " + to_string(ttl) +
|
|
", last_report: " + to_string(last_report) +
|
|
", down: " + to_string(hid_tp.down));
|
|
*/
|
|
|
|
// check if pressed
|
|
if (!hid_tp.down) {
|
|
|
|
// only remove if it exists
|
|
if (existing != touch.touch_points.end()) {
|
|
|
|
// remove all touch points with this ID
|
|
touch_removes.push_back(hid_tp.id);
|
|
touch.touch_points.erase(std::remove_if(
|
|
touch.touch_points.begin(),
|
|
touch.touch_points.end(),
|
|
[hid_tp] (const HIDTouchPoint &x) {
|
|
return x.id == hid_tp.id;
|
|
}), touch.touch_points.end());
|
|
}
|
|
} else {
|
|
|
|
// write touch point
|
|
TouchPoint tp {
|
|
.id = hid_tp.id,
|
|
.x = (long) (hid_tp.x * DISPLAY_SIZE_X),
|
|
.y = (long) (hid_tp.y * DISPLAY_SIZE_Y),
|
|
.mouse = false,
|
|
};
|
|
touch_writes.push_back(tp);
|
|
touch_modifications.push_back(hid_tp.id);
|
|
|
|
// check if existing
|
|
if (existing == touch.touch_points.end()) {
|
|
|
|
// add new touch point
|
|
touch.touch_points.push_back(hid_tp);
|
|
|
|
} else {
|
|
|
|
// update existing touch point
|
|
*existing = hid_tp;
|
|
}
|
|
}
|
|
}
|
|
|
|
// set TTL and last report time
|
|
if (!touch.elements_x.empty() && !touch_modifications.empty()) {
|
|
auto ttl = touch.touch_points.size() / touch.elements_x.size() + 1;
|
|
auto system_time_ms = get_system_milliseconds();
|
|
for (auto &hid_tp_id : touch_modifications) {
|
|
for (auto &hid_tp : touch.touch_points) {
|
|
if (hid_tp.id == hid_tp_id) {
|
|
hid_tp.ttl = ttl;
|
|
hid_tp.last_report = system_time_ms;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// remove dead touch points
|
|
auto ttl_it = touch.touch_points.begin();
|
|
while (ttl_it != touch.touch_points.end()) {
|
|
auto &tp = *ttl_it;
|
|
if (tp.ttl == 0) {
|
|
touch_removes.push_back(tp.id);
|
|
ttl_it = touch.touch_points.erase(ttl_it);
|
|
} else {
|
|
tp.ttl--;
|
|
ttl_it++;
|
|
}
|
|
}
|
|
|
|
#ifndef SPICETOOLS_SPICECFG_STANDALONE
|
|
|
|
// update touch module
|
|
touch_remove_points(&touch_removes);
|
|
touch_write_points(&touch_writes);
|
|
#endif
|
|
}
|
|
|
|
void update_timeouts(Device *device) {
|
|
|
|
// check type
|
|
if (device->type != HID) {
|
|
log_fatal("rawinput", "touch timeout update called on non HID device");
|
|
return;
|
|
}
|
|
|
|
// get touch info
|
|
auto hid = device->hidInfo;
|
|
auto &touch = hid->touch;
|
|
if (!touch.valid) {
|
|
return; // not a registered touchscreen
|
|
}
|
|
|
|
// calculate deadline - we allow the devices 50ms of not sending shit
|
|
auto deadline = get_system_milliseconds() - 50;
|
|
|
|
// check touch points
|
|
std::vector<DWORD> touch_removes;
|
|
auto touch_it = touch.touch_points.begin();
|
|
while (touch_it != touch.touch_points.end()) {
|
|
auto &hid_tp = *touch_it;
|
|
|
|
// see if it's behind the deadline
|
|
if (hid_tp.last_report < deadline) {
|
|
|
|
// oops it's gone
|
|
touch_removes.push_back(hid_tp.id);
|
|
touch_it = touch.touch_points.erase(touch_it);
|
|
|
|
} else {
|
|
|
|
// check the next device
|
|
touch_it++;
|
|
}
|
|
}
|
|
|
|
#ifndef SPICETOOLS_SPICECFG_STANDALONE
|
|
|
|
// remove from touch module
|
|
touch_remove_points(&touch_removes);
|
|
#endif
|
|
}
|
|
|
|
void update_timeouts(RawInputManager *manager) {
|
|
|
|
// iterate all devices
|
|
for (auto &device : manager->devices_get()) {
|
|
|
|
// check if it's a valid touchscreen
|
|
if (device.type == HID && device.hidInfo->touch.valid) {
|
|
|
|
// lock n' load
|
|
device.mutex->lock();
|
|
update_timeouts(&device);
|
|
device.mutex->unlock();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool is_enabled(RawInputManager *manager) {
|
|
|
|
// check if disabled or manager is null
|
|
if (DISABLED || manager == nullptr)
|
|
return false;
|
|
|
|
// check if at least one device is marked as valid touchscreen
|
|
for (auto &device : manager->devices_get()) {
|
|
if (device.type == HID && device.hidInfo->touch.valid) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// no valid touch screen found
|
|
return false;
|
|
}
|
|
|
|
void display_update() {
|
|
|
|
// check if disabled
|
|
if (DISABLED)
|
|
return;
|
|
|
|
// determine monitor size
|
|
static RECT display_rect;
|
|
GetWindowRect(GetDesktopWindow(), &display_rect);
|
|
DISPLAY_SIZE_X = display_rect.right - display_rect.left;
|
|
DISPLAY_SIZE_Y = display_rect.bottom - display_rect.top;
|
|
log_info("rawinput", "display size: {}x{}", (int) DISPLAY_SIZE_X, (int) DISPLAY_SIZE_Y);
|
|
|
|
// determine monitor orientation
|
|
DEVMODE display_mode{};
|
|
display_mode.dmSize = sizeof(DEVMODE);
|
|
if (!EnumDisplaySettingsEx(nullptr, ENUM_CURRENT_SETTINGS, &display_mode, EDS_RAWMODE)) {
|
|
log_info("rawinput", "failed to determine monitor mode");
|
|
} else if (display_mode.dmFields & DM_DISPLAYORIENTATION) {
|
|
DISPLAY_ORIENTATION = display_mode.dmDisplayOrientation;
|
|
switch (DISPLAY_ORIENTATION) {
|
|
case DMDO_DEFAULT:
|
|
log_info("rawinput", "display rotation: 0");
|
|
break;
|
|
case DMDO_90:
|
|
log_info("rawinput", "display rotation: 90");
|
|
break;
|
|
case DMDO_180:
|
|
log_info("rawinput", "display rotation: 180");
|
|
break;
|
|
case DMDO_270:
|
|
log_info("rawinput", "display rotation: 270");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// another XP fix
|
|
if (!IsWindowsVistaOrGreater()) {
|
|
switch (DISPLAY_ORIENTATION) {
|
|
case DMDO_90:
|
|
DISPLAY_ORIENTATION = DMDO_180;
|
|
log_info("rawinput", "flipping to 180");
|
|
break;
|
|
case DMDO_270:
|
|
DISPLAY_ORIENTATION = DMDO_90;
|
|
log_info("rawinput", "flipping to 90");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
log_info("rawinput", "failed to determine monitor orientation");
|
|
}
|
|
|
|
// mark as initialized
|
|
DISPLAY_INITIALIZED = true;
|
|
}
|
|
}
|