| /* |
| Simple DirectMedia Layer |
| Copyright (C) 1997-2024 Sam Lantinga <slouken@libsdl.org> |
| |
| This software is provided 'as-is', without any express or implied |
| warranty. In no event will the authors be held liable for any damages |
| arising from the use of this software. |
| |
| Permission is granted to anyone to use this software for any purpose, |
| including commercial applications, and to alter it and redistribute it |
| freely, subject to the following restrictions: |
| |
| 1. The origin of this software must not be misrepresented; you must not |
| claim that you wrote the original software. If you use this software |
| in a product, an acknowledgment in the product documentation would be |
| appreciated but is not required. |
| 2. Altered source versions must be plainly marked as such, and must not be |
| misrepresented as being the original software. |
| 3. This notice may not be removed or altered from any source distribution. |
| */ |
| #include "../../SDL_internal.h" |
| |
| #ifdef SDL_VIDEO_DRIVER_X11_XINPUT2 |
| |
| #include "../../events/SDL_pen_c.h" |
| #include "../SDL_sysvideo.h" |
| #include "SDL_x11pen.h" |
| #include "SDL_x11video.h" |
| #include "SDL_x11xinput2.h" |
| |
| #define PEN_ERASER_ID_MAXLEN 256 /* Max # characters of device name to scan */ |
| #define PEN_ERASER_NAME_TAG "eraser" /* String constant to identify erasers */ |
| |
| #define DEBUG_PEN (SDL_PEN_DEBUG_NOID | SDL_PEN_DEBUG_NONWACOM | SDL_PEN_DEBUG_UNKNOWN_WACOM | SDL_PEN_DEBUG_NOSERIAL_WACOM) |
| |
| #define SDL_PEN_AXIS_VALUATOR_MISSING -1 |
| |
| /* X11-specific information attached to each pen */ |
| typedef struct xinput2_pen |
| { |
| float axis_min[SDL_PEN_NUM_AXES]; |
| float axis_max[SDL_PEN_NUM_AXES]; |
| float slider_bias; /* shift value to add to PEN_AXIS_SLIDER (before normalisation) */ |
| float rotation_bias; /* rotation to add to PEN_AXIS_ROTATION (after normalisation) */ |
| Sint8 valuator_for_axis[SDL_PEN_NUM_AXES]; /* SDL_PEN_AXIS_VALUATOR_MISSING if not supported */ |
| } xinput2_pen; |
| |
| /* X11 atoms */ |
| static struct |
| { |
| int initialized; /* initialised to 0 */ |
| Atom device_product_id; |
| Atom abs_pressure; |
| Atom abs_tilt_x; |
| Atom abs_tilt_y; |
| Atom wacom_serial_ids; |
| Atom wacom_tool_type; |
| } pen_atoms; |
| |
| /* |
| * Mapping from X11 device IDs to pen IDs |
| * |
| * In X11, the same device ID may represent any number of pens. We |
| * thus cannot directly use device IDs as pen IDs. |
| */ |
| static struct |
| { |
| int num_pens_known; /* Number of currently known pens (based on their GUID); used to give pen ID to new pens */ |
| int num_entries; /* Number of X11 device IDs that correspond to pens */ |
| |
| struct pen_device_id_mapping |
| { |
| Uint32 deviceid; |
| Uint32 pen_id; |
| } * entries; /* Current pen to device ID mappings */ |
| } pen_map; |
| |
| typedef enum |
| { |
| SDL_PEN_VENDOR_UNKNOWN = 0, |
| SDL_PEN_VENDOR_WACOM |
| } sdl_pen_vendor; |
| |
| /* Information to identify pens during discovery */ |
| typedef struct |
| { |
| sdl_pen_vendor vendor; |
| SDL_GUID guid; |
| SDL_PenSubtype heuristic_type; /* Distinguish pen+eraser devices with shared bus ID */ |
| Uint32 devicetype_id, serial; /* used by PEN_VENDOR_WACOM */ |
| Uint32 deviceid; |
| } pen_identity; |
| |
| int X11_PenIDFromDeviceID(int deviceid) |
| { |
| int i; |
| for (i = 0; i < pen_map.num_entries; ++i) { |
| if (pen_map.entries[i].deviceid == deviceid) { |
| return pen_map.entries[i].pen_id; |
| } |
| } |
| return SDL_PEN_INVALID; |
| } |
| |
| static void pen_atoms_ensure_initialized(SDL_VideoDevice *_this) |
| { |
| SDL_VideoData *data = (SDL_VideoData *)_this->driverdata; |
| |
| if (pen_atoms.initialized) { |
| return; |
| } |
| /* Create atoms if they don't exist yet to pre-empt hotplugging updates */ |
| pen_atoms.device_product_id = X11_XInternAtom(data->display, "Device Product ID", False); |
| pen_atoms.wacom_serial_ids = X11_XInternAtom(data->display, "Wacom Serial IDs", False); |
| pen_atoms.wacom_tool_type = X11_XInternAtom(data->display, "Wacom Tool Type", False); |
| pen_atoms.abs_pressure = X11_XInternAtom(data->display, "Abs Pressure", False); |
| pen_atoms.abs_tilt_x = X11_XInternAtom(data->display, "Abs Tilt X", False); |
| pen_atoms.abs_tilt_y = X11_XInternAtom(data->display, "Abs Tilt Y", False); |
| |
| pen_atoms.initialized = 1; |
| } |
| |
| /* Read out an integer property and store into a preallocated Sint32 array, extending 8 and 16 bit values suitably. |
| Returns number of Sint32s written (<= max_words), or 0 on error. */ |
| static size_t xinput2_pen_get_int_property(SDL_VideoDevice *_this, int deviceid, Atom property, Sint32 *dest, size_t max_words) |
| { |
| const SDL_VideoData *data = (SDL_VideoData *)_this->driverdata; |
| Atom type_return; |
| int format_return; |
| unsigned long num_items_return; |
| unsigned long bytes_after_return; |
| unsigned char *output; |
| |
| if (property == None) { |
| return 0; |
| } |
| |
| if (Success != X11_XIGetProperty(data->display, deviceid, |
| property, |
| 0, max_words, False, |
| XA_INTEGER, &type_return, &format_return, |
| &num_items_return, &bytes_after_return, |
| &output) || |
| num_items_return == 0 || output == NULL) { |
| return 0; |
| } |
| |
| if (type_return == XA_INTEGER) { |
| int k; |
| const int to_copy = SDL_min(max_words, num_items_return); |
| |
| if (format_return == 8) { |
| Sint8 *numdata = (Sint8 *)output; |
| for (k = 0; k < to_copy; ++k) { |
| dest[k] = numdata[k]; |
| } |
| } else if (format_return == 16) { |
| Sint16 *numdata = (Sint16 *)output; |
| for (k = 0; k < to_copy; ++k) { |
| dest[k] = numdata[k]; |
| } |
| } else { |
| SDL_memcpy(dest, output, sizeof(Sint32) * to_copy); |
| } |
| X11_XFree(output); |
| return to_copy; |
| } |
| return 0; /* type mismatch */ |
| } |
| |
| /* 32 bit vendor + device ID from evdev */ |
| static Uint32 xinput2_pen_evdevid(SDL_VideoDevice *_this, int deviceid) |
| { |
| #if !(SDL_PEN_DEBUG_NOID) |
| Sint32 ids[2]; |
| |
| pen_atoms_ensure_initialized(_this); |
| |
| if (2 != xinput2_pen_get_int_property(_this, deviceid, pen_atoms.device_product_id, ids, 2)) { |
| return 0; |
| } |
| return ((ids[0] << 16) | (ids[1] & 0xffff)); |
| #else /* Testing: pretend that we have no ID (not sure if this can happen IRL) */ |
| return 0; |
| #endif |
| } |
| |
| /* Gets reasonably-unique GUID for the device */ |
| static void xinput2_pen_update_generic_guid(SDL_VideoDevice *_this, pen_identity *pident, int deviceid) |
| { |
| Uint32 evdevid = xinput2_pen_evdevid(_this, deviceid); /* also initialises pen_atoms */ |
| |
| if (!evdevid) { |
| /* Fallback: if no evdevid is available; try to at least distinguish devices within the |
| current session. This is a poor GUID and our last resort. */ |
| evdevid = deviceid; |
| } |
| SDL_PenUpdateGUIDForGeneric(&pident->guid, 0, evdevid); |
| } |
| |
| /* Identify Wacom devices (if SDL_TRUE is returned) and extract their device type and serial IDs */ |
| static SDL_bool xinput2_wacom_deviceid(SDL_VideoDevice *_this, int deviceid, Uint32 *wacom_devicetype_id, Uint32 *wacom_serial) |
| { |
| #if !(SDL_PEN_DEBUG_NONWACOM) /* Can be disabled for testing */ |
| Sint32 serial_id_buf[3]; |
| int result; |
| |
| pen_atoms_ensure_initialized(_this); |
| |
| if ((result = xinput2_pen_get_int_property(_this, deviceid, pen_atoms.wacom_serial_ids, serial_id_buf, 3)) == 3) { |
| *wacom_devicetype_id = serial_id_buf[2]; |
| *wacom_serial = serial_id_buf[1]; |
| #if SDL_PEN_DEBUG_NOSERIAL_WACOM /* Disabled for testing? */ |
| *wacom_serial = 0; |
| #endif |
| return SDL_TRUE; |
| } |
| #endif |
| return SDL_FALSE; |
| } |
| |
| /* Heuristically determines if device is an eraser */ |
| static SDL_bool xinput2_pen_is_eraser(SDL_VideoDevice *_this, int deviceid, char *devicename) |
| { |
| SDL_VideoData *data = (SDL_VideoData *)_this->driverdata; |
| char dev_name[PEN_ERASER_ID_MAXLEN]; |
| int k; |
| |
| pen_atoms_ensure_initialized(_this); |
| |
| if (pen_atoms.wacom_tool_type != None) { |
| Atom type_return; |
| int format_return; |
| unsigned long num_items_return; |
| unsigned long bytes_after_return; |
| unsigned char *tooltype_name_info = NULL; |
| |
| /* Try Wacom-specific method */ |
| if (Success == X11_XIGetProperty(data->display, deviceid, |
| pen_atoms.wacom_tool_type, |
| 0, 32, False, |
| AnyPropertyType, &type_return, &format_return, |
| &num_items_return, &bytes_after_return, |
| &tooltype_name_info) && |
| tooltype_name_info != NULL && num_items_return > 0) { |
| |
| SDL_bool result = SDL_FALSE; |
| char *tooltype_name = NULL; |
| |
| if (type_return == XA_ATOM) { |
| /* Atom instead of string? Un-intern */ |
| Atom atom = *((Atom *)tooltype_name_info); |
| if (atom != None) { |
| tooltype_name = X11_XGetAtomName(data->display, atom); |
| } |
| } else if (type_return == XA_STRING && format_return == 8) { |
| tooltype_name = (char *)tooltype_name_info; |
| } |
| |
| if (tooltype_name) { |
| if (0 == SDL_strcasecmp(tooltype_name, PEN_ERASER_NAME_TAG)) { |
| result = SDL_TRUE; |
| } |
| X11_XFree(tooltype_name_info); |
| |
| return result; |
| } |
| } |
| } |
| /* Non-Wacom device? */ |
| |
| /* We assume that a device is an eraser if its name contains the string "eraser". |
| * Unfortunately there doesn't seem to be a clean way to distinguish these cases (as of 2022-03). */ |
| |
| SDL_strlcpy(dev_name, devicename, PEN_ERASER_ID_MAXLEN); |
| /* lowercase device name string so we can use strstr() */ |
| for (k = 0; dev_name[k]; ++k) { |
| dev_name[k] = SDL_tolower(dev_name[k]); |
| } |
| |
| return (SDL_strstr(dev_name, PEN_ERASER_NAME_TAG)) ? SDL_TRUE : SDL_FALSE; |
| } |
| |
| /* Gets GUID and other identifying information for the device using the best known method */ |
| static pen_identity xinput2_identify_pen(SDL_VideoDevice *_this, int deviceid, char *name) |
| { |
| pen_identity pident; |
| |
| pident.devicetype_id = 0ul; |
| pident.serial = 0ul; |
| pident.deviceid = deviceid; |
| pident.heuristic_type = SDL_PEN_TYPE_PEN; |
| SDL_memset(pident.guid.data, 0, sizeof(pident.guid.data)); |
| |
| if (xinput2_pen_is_eraser(_this, deviceid, name)) { |
| pident.heuristic_type = SDL_PEN_TYPE_ERASER; |
| } |
| |
| if (xinput2_wacom_deviceid(_this, deviceid, &pident.devicetype_id, &pident.serial)) { |
| pident.vendor = SDL_PEN_VENDOR_WACOM; |
| SDL_PenUpdateGUIDForWacom(&pident.guid, pident.devicetype_id, pident.serial); |
| |
| #if DEBUG_PEN |
| printf("[pen] Pen %d reports Wacom device_id %x\n", |
| deviceid, pident.devicetype_id); |
| #endif |
| |
| } else { |
| pident.vendor = SDL_PEN_VENDOR_UNKNOWN; |
| } |
| if (!pident.serial) { |
| /* If the pen has a serial number, we can move it across tablets and retain its identity. |
| Otherwise, we use the evdev ID as part of its GUID, which may mean that we identify it with the tablet. */ |
| xinput2_pen_update_generic_guid(_this, &pident, deviceid); |
| } |
| SDL_PenUpdateGUIDForType(&pident.guid, pident.heuristic_type); |
| return pident; |
| } |
| |
| static void xinput2_pen_free_deviceinfo(Uint32 deviceid, void *x11_peninfo, void *context) |
| { |
| SDL_free(x11_peninfo); |
| } |
| |
| static void xinput2_merge_deviceinfo(xinput2_pen *dest, xinput2_pen *src) |
| { |
| *dest = *src; |
| } |
| |
| /** |
| * Fill in vendor-specific device information, if available |
| * |
| * For Wacom pens: identify number of buttons and extra axis (if present) |
| * |
| * \param _this global state |
| * \param dev The device to analyse |
| * \param pen The pen to initialise |
| * \param pident Pen identity information |
| * \param[out] valuator_5 Meaning of the valuator with offset 5, if any |
| * (written only if known and if the device has a 6th axis, |
| * e.g., for the Wacom Art Pen and Wacom Airbrush Pen) |
| * \param[out] axes Bitmask of all possibly supported axes |
| * |
| * This function identifies Wacom device types through a Wacom-specific device ID. |
| * It then fills in pen details from an internal database. |
| * If the device seems to be a Wacom pen/eraser but can't be identified, the function |
| * leaves "axes" untouched and sets the other outputs to common defaults. |
| * |
| * There is no explicit support for other vendors, though vendors that |
| * emulate the Wacom API might be supported. |
| * |
| * Unsupported devices will keep the default settings. |
| */ |
| static void xinput2_vendor_peninfo(SDL_VideoDevice *_this, const XIDeviceInfo *dev, SDL_Pen *pen, pen_identity pident, int *valuator_5, Uint32 *axes) |
| { |
| switch (pident.vendor) { |
| case SDL_PEN_VENDOR_WACOM: |
| { |
| if (SDL_PenModifyForWacomID(pen, pident.devicetype_id, axes)) { |
| if (*axes & SDL_PEN_AXIS_SLIDER_MASK) { |
| /* Air Brush Pen or eraser */ |
| *valuator_5 = SDL_PEN_AXIS_SLIDER; |
| } else if (*axes & SDL_PEN_AXIS_ROTATION_MASK) { |
| /* Art Pen or eraser, or 6D Art Pen */ |
| *valuator_5 = SDL_PEN_AXIS_ROTATION; |
| } |
| return; |
| } else { |
| #if DEBUG_PEN |
| printf("[pen] Could not identify wacom pen %d with device id %x, using default settings\n", |
| pident.deviceid, pident.devicetype_id); |
| #endif |
| break; |
| } |
| } |
| |
| default: |
| #if DEBUG_PEN |
| printf("[pen] Pen %d is not from a known vendor\n", pident.deviceid); |
| #endif |
| break; |
| } |
| |
| /* Fall back to default heuristics for identifying device type */ |
| |
| SDL_strlcpy(pen->name, dev->name, SDL_PEN_MAX_NAME); |
| |
| pen->type = pident.heuristic_type; |
| } |
| |
| /* Does this device have a valuator for pressure sensitivity? */ |
| static SDL_bool xinput2_device_is_pen(SDL_VideoDevice *_this, const XIDeviceInfo *dev) |
| { |
| int classct; |
| |
| pen_atoms_ensure_initialized(_this); |
| |
| for (classct = 0; classct < dev->num_classes; ++classct) { |
| const XIAnyClassInfo *classinfo = dev->classes[classct]; |
| |
| switch (classinfo->type) { |
| case XIValuatorClass: |
| { |
| XIValuatorClassInfo *val_classinfo = (XIValuatorClassInfo *)classinfo; |
| Atom vname = val_classinfo->label; |
| |
| if (vname == pen_atoms.abs_pressure) { |
| return SDL_TRUE; |
| } |
| } |
| } |
| } |
| return SDL_FALSE; |
| } |
| |
| void X11_InitPen(SDL_VideoDevice *_this) |
| { |
| SDL_VideoData *data = (SDL_VideoData *)_this->driverdata; |
| int i; |
| XIDeviceInfo *device_info; |
| int num_device_info; |
| |
| device_info = X11_XIQueryDevice(data->display, XIAllDevices, &num_device_info); |
| if (!device_info) { |
| return; |
| } |
| |
| /* Reset the device id -> pen map */ |
| if (pen_map.entries) { |
| SDL_free(pen_map.entries); |
| pen_map.entries = NULL; |
| pen_map.num_entries = 0; |
| } |
| |
| SDL_PenGCMark(); |
| |
| for (i = 0; i < num_device_info; ++i) { |
| const XIDeviceInfo *dev = &device_info[i]; |
| int classct; |
| xinput2_pen pen_device; |
| Uint32 capabilities = 0; |
| Uint32 axis_mask = ~0; /* Permitted axes (default: all) */ |
| int valuator_5_axis = -1; /* For Wacom devices, the 6th valuator (offset 5) has a model-specific meaning */ |
| pen_identity pident; |
| SDL_PenID pen_id; |
| SDL_Pen *pen; |
| int old_num_pens_known = pen_map.num_pens_known; |
| int k; |
| |
| /* Only track physical devices that are enabled and look like pens */ |
| if (dev->use != XISlavePointer || dev->enabled == 0 || !xinput2_device_is_pen(_this, dev)) { |
| continue; |
| } |
| |
| pen_device.slider_bias = 0.0f; |
| pen_device.rotation_bias = 0.0f; |
| for (k = 0; k < SDL_PEN_NUM_AXES; ++k) { |
| pen_device.valuator_for_axis[k] = SDL_PEN_AXIS_VALUATOR_MISSING; |
| } |
| |
| pident = xinput2_identify_pen(_this, dev->deviceid, dev->name); |
| |
| pen_id = SDL_GetPenFromGUID(pident.guid); |
| if (pen_id == SDL_PEN_INVALID) { |
| /* We have never met this pen */ |
| pen_id = ++pen_map.num_pens_known; /* start at 1 */ |
| } |
| pen = SDL_PenModifyBegin(pen_id); |
| |
| /* Complement XF86 driver information with vendor-specific details */ |
| xinput2_vendor_peninfo(_this, dev, pen, pident, &valuator_5_axis, &axis_mask); |
| |
| for (classct = 0; classct < dev->num_classes; ++classct) { |
| const XIAnyClassInfo *classinfo = dev->classes[classct]; |
| |
| switch (classinfo->type) { |
| case XIValuatorClass: |
| { |
| XIValuatorClassInfo *val_classinfo = (XIValuatorClassInfo *)classinfo; |
| Sint8 valuator_nr = val_classinfo->number; |
| Atom vname = val_classinfo->label; |
| int axis = -1; |
| |
| float min = (float)val_classinfo->min; |
| float max = (float)val_classinfo->max; |
| |
| if (vname == pen_atoms.abs_pressure) { |
| axis = SDL_PEN_AXIS_PRESSURE; |
| } else if (vname == pen_atoms.abs_tilt_x) { |
| axis = SDL_PEN_AXIS_XTILT; |
| } else if (vname == pen_atoms.abs_tilt_y) { |
| axis = SDL_PEN_AXIS_YTILT; |
| } |
| |
| if (axis == -1 && valuator_nr == 5) { |
| /* Wacom model-specific axis support */ |
| /* The meaning of the various axes is highly underspecitied in Xinput2. |
| * As of 2023-08-26, Wacom seems to be the only vendor to support these axes, so the code below |
| * captures the de-facto standard. */ |
| axis = valuator_5_axis; |
| |
| switch (axis) { |
| case SDL_PEN_AXIS_SLIDER: |
| /* cf. xinput2_wacom_peninfo for how this axis is used. |
| In all current cases, our API wants this value in 0..1, but the xf86 driver |
| starts at a negative offset, so we normalise here. */ |
| pen_device.slider_bias = -min; |
| max -= min; |
| min = 0.0f; |
| break; |
| |
| case SDL_PEN_AXIS_ROTATION: |
| /* The "0" value points to the left, rather than up, so we must |
| rotate 90 degrees counter-clockwise to have 0 point to the top. */ |
| |
| pen_device.rotation_bias = -90.0f; |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| if (axis >= 0) { |
| capabilities |= SDL_PEN_AXIS_CAPABILITY(axis); |
| |
| pen_device.valuator_for_axis[axis] = valuator_nr; |
| pen_device.axis_min[axis] = min; |
| pen_device.axis_max[axis] = max; |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| |
| /* We have a pen if and only if the device measures pressure */ |
| if (capabilities & SDL_PEN_AXIS_PRESSURE_MASK) { |
| xinput2_pen *xinput2_deviceinfo; |
| Uint64 guid_a, guid_b; |
| |
| /* Done collecting data, write to pen */ |
| SDL_PenModifyAddCapabilities(pen, capabilities); |
| pen->guid = pident.guid; |
| |
| if (pen->deviceinfo) { |
| /* Updating a known pen */ |
| xinput2_deviceinfo = (xinput2_pen *)pen->deviceinfo; |
| xinput2_merge_deviceinfo(xinput2_deviceinfo, &pen_device); |
| } else { |
| /* Registering a new pen */ |
| xinput2_deviceinfo = SDL_malloc(sizeof(xinput2_pen)); |
| SDL_memcpy(xinput2_deviceinfo, &pen_device, sizeof(xinput2_pen)); |
| } |
| pen->deviceinfo = xinput2_deviceinfo; |
| |
| #if DEBUG_PEN |
| printf("[pen] pen %d [%04x] valuators pressure=%d, xtilt=%d, ytilt=%d [%s]\n", |
| pen->header.id, pen->header.flags, |
| pen_device.valuator_for_axis[SDL_PEN_AXIS_PRESSURE], |
| pen_device.valuator_for_axis[SDL_PEN_AXIS_XTILT], |
| pen_device.valuator_for_axis[SDL_PEN_AXIS_YTILT], |
| pen->name); |
| #endif |
| SDL_memcpy(&guid_a, &pen->guid.data[0], 8); |
| SDL_memcpy(&guid_b, &pen->guid.data[8], 8); |
| if (!(guid_a | guid_b)) { |
| #if DEBUG_PEN |
| printf("[pen] (pen eliminated due to zero GUID)\n"); |
| #endif |
| pen->type = SDL_PEN_TYPE_NONE; |
| } |
| |
| } else { |
| /* Not a pen, mark for deletion */ |
| pen->type = SDL_PEN_TYPE_NONE; |
| } |
| SDL_PenModifyEnd(pen, SDL_TRUE); |
| |
| if (pen->type != SDL_PEN_TYPE_NONE) { |
| const int map_pos = pen_map.num_entries; |
| |
| /* We found a pen: add mapping */ |
| if (pen_map.entries == NULL) { |
| pen_map.entries = SDL_calloc(sizeof(struct pen_device_id_mapping), 1); |
| pen_map.num_entries = 1; |
| } else { |
| pen_map.num_entries += 1; |
| pen_map.entries = SDL_realloc(pen_map.entries, |
| pen_map.num_entries * (sizeof(struct pen_device_id_mapping))); |
| } |
| pen_map.entries[map_pos].deviceid = dev->deviceid; |
| pen_map.entries[map_pos].pen_id = pen_id; |
| } else { |
| /* Revert pen number allocation */ |
| pen_map.num_pens_known = old_num_pens_known; |
| } |
| } |
| X11_XIFreeDeviceInfo(device_info); |
| |
| SDL_PenGCSweep(NULL, xinput2_pen_free_deviceinfo); |
| } |
| |
| static void xinput2_normalize_pen_axes(const SDL_Pen *peninfo, |
| const xinput2_pen *xpen, |
| /* inout-mode paramters: */ |
| float *coords) |
| { |
| int axis; |
| |
| /* Normalise axes */ |
| for (axis = 0; axis < SDL_PEN_NUM_AXES; ++axis) { |
| int valuator = xpen->valuator_for_axis[axis]; |
| if (valuator != SDL_PEN_AXIS_VALUATOR_MISSING) { |
| float value = coords[axis]; |
| float min = xpen->axis_min[axis]; |
| float max = xpen->axis_max[axis]; |
| |
| if (axis == SDL_PEN_AXIS_SLIDER) { |
| value += xpen->slider_bias; |
| } |
| |
| /* min ... 0 ... max */ |
| if (min < 0.0) { |
| /* Normalise so that 0 remains 0.0 */ |
| if (value < 0) { |
| value = value / (-min); |
| } else { |
| if (max == 0.0) { |
| value = 0.0f; |
| } else { |
| value = value / max; |
| } |
| } |
| } else { |
| /* 0 ... min ... max */ |
| /* including 0.0 = min */ |
| if (max == 0.0) { |
| value = 0.0f; |
| } else { |
| value = (value - min) / max; |
| } |
| } |
| |
| switch (axis) { |
| case SDL_PEN_AXIS_XTILT: |
| case SDL_PEN_AXIS_YTILT: |
| if (peninfo->info.max_tilt > 0.0f) { |
| value *= peninfo->info.max_tilt; /* normalise to physical max */ |
| } |
| break; |
| |
| case SDL_PEN_AXIS_ROTATION: |
| /* normalised to -1..1, so let's convert to degrees */ |
| value *= 180.0f; |
| value += xpen->rotation_bias; |
| |
| /* handle simple over/underflow */ |
| if (value >= 180.0f) { |
| value -= 360.0f; |
| } else if (value < -180.0f) { |
| value += 360.0f; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| coords[axis] = value; |
| } |
| } |
| } |
| |
| void X11_PenAxesFromValuators(const SDL_Pen *peninfo, |
| const double *input_values, const unsigned char *mask, const int mask_len, |
| /* out-mode parameters: */ |
| float axis_values[SDL_PEN_NUM_AXES]) |
| { |
| const xinput2_pen *pen = (xinput2_pen *)peninfo->deviceinfo; |
| int i; |
| |
| for (i = 0; i < SDL_PEN_NUM_AXES; ++i) { |
| const int valuator = pen->valuator_for_axis[i]; |
| if (valuator == SDL_PEN_AXIS_VALUATOR_MISSING || valuator >= mask_len * 8 || !(XIMaskIsSet(mask, valuator))) { |
| axis_values[i] = 0.0f; |
| } else { |
| axis_values[i] = (float)input_values[valuator]; |
| } |
| } |
| xinput2_normalize_pen_axes(peninfo, pen, axis_values); |
| } |
| |
| #endif /* SDL_VIDEO_DRIVER_X11_XINPUT2 */ |
| |
| /* vi: set ts=4 sw=4 expandtab: */ |
