| /* GDK - The GIMP Drawing Kit |
| * Copyright (C) 2021 the GTK team |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library. If not, see <http://www.gnu.org/licenses/>. |
| */ |
| |
| #include "config.h" |
| |
| #include <gdk/gdk.h> |
| #include "gdkwin32.h" |
| #include "gdkprivate-win32.h" |
| #include "gdkdevicemanager-win32.h" |
| #include "gdkdevice-virtual.h" |
| #include "gdkdevice-winpointer.h" |
| #include "gdkdeviceprivate.h" |
| #include "gdkdevicetoolprivate.h" |
| #include "gdkdisplay-win32.h" |
| #include "gdkeventsprivate.h" |
| #include "gdkseatdefaultprivate.h" |
| |
| #include "gdkinput-winpointer.h" |
| |
| #include <windows.h> |
| |
| #include <tchar.h> |
| #include <tpcshrd.h> |
| #include <hidsdi.h> |
| |
| #define HID_STRING_BYTES_LIMIT 200 |
| #define VID_PID_CHARS 4 |
| |
| typedef BOOL |
| (WINAPI *registerPointerDeviceNotifications_t)(HWND window, BOOL notifyRange); |
| typedef BOOL |
| (WINAPI *getPointerDevices_t)(UINT32 *deviceCount, POINTER_DEVICE_INFO *pointerDevices); |
| typedef BOOL |
| (WINAPI *getPointerDeviceCursors_t)(HANDLE device, UINT32 *cursorCount, POINTER_DEVICE_CURSOR_INFO *deviceCursors); |
| typedef BOOL |
| (WINAPI *getPointerDeviceRects_t)(HANDLE device, RECT *pointerDeviceRect, RECT *displayRect); |
| typedef BOOL |
| (WINAPI *getPointerType_t)(UINT32 pointerId, POINTER_INPUT_TYPE *pointerType); |
| typedef BOOL |
| (WINAPI *getPointerCursorId_t)(UINT32 pointerId, UINT32 *cursorId); |
| typedef BOOL |
| (WINAPI *getPointerPenInfo_t)(UINT32 pointerId, POINTER_PEN_INFO *penInfo); |
| typedef BOOL |
| (WINAPI *getPointerTouchInfo_t)(UINT32 pointerId, POINTER_TOUCH_INFO *touchInfo); |
| typedef BOOL |
| (WINAPI *getPointerPenInfoHistory_t)(UINT32 pointerId, UINT32 *entriesCount, POINTER_PEN_INFO *penInfo); |
| typedef BOOL |
| (WINAPI *getPointerTouchInfoHistory_t)(UINT32 pointerId, UINT32 *entriesCount, POINTER_TOUCH_INFO *touchInfo); |
| typedef BOOL |
| (WINAPI *setGestureConfig_t)(HWND hwnd, DWORD dwReserved, UINT cIDs, PGESTURECONFIG pGestureConfig, UINT cbSize); |
| typedef BOOL |
| (WINAPI *setWindowFeedbackSetting_t)(HWND hwnd, FEEDBACK_TYPE feedback, DWORD dwFlags, UINT32 size, const VOID *configuration); |
| |
| struct _GdkDeviceManagerWin32WinpointerFuncs |
| { |
| registerPointerDeviceNotifications_t registerPointerDeviceNotifications; |
| getPointerDevices_t getPointerDevices; |
| getPointerDeviceCursors_t getPointerDeviceCursors; |
| getPointerDeviceRects_t getPointerDeviceRects; |
| getPointerType_t getPointerType; |
| getPointerCursorId_t getPointerCursorId; |
| getPointerPenInfo_t getPointerPenInfo; |
| getPointerTouchInfo_t getPointerTouchInfo; |
| getPointerPenInfoHistory_t getPointerPenInfoHistory; |
| getPointerTouchInfoHistory_t getPointerTouchInfoHistory; |
| setGestureConfig_t setGestureConfig; |
| setWindowFeedbackSetting_t setWindowFeedbackSetting; |
| }; |
| typedef struct _GdkDeviceManagerWin32WinpointerFuncs GdkDeviceManagerWin32WinpointerFuncs; |
| |
| #define WINPOINTER_API(dm,f) ((GdkDeviceManagerWin32WinpointerFuncs *)dm->winpointer_funcs)->f |
| |
| static inline void |
| winpointer_ignore_interaction (GdkDeviceManagerWin32 *device_manager, |
| UINT32 pointer_id) |
| { |
| g_ptr_array_add (device_manager->ignored_interactions, GUINT_TO_POINTER (pointer_id)); |
| } |
| |
| static inline void |
| winpointer_remove_ignored_interaction (GdkDeviceManagerWin32 *device_manager, |
| UINT32 pointer_id) |
| { |
| g_ptr_array_remove_fast (device_manager->ignored_interactions, GUINT_TO_POINTER (pointer_id)); |
| } |
| |
| static inline gboolean |
| winpointer_should_ignore_interaction (GdkDeviceManagerWin32 *device_manager, |
| UINT32 pointer_id) |
| { |
| return g_ptr_array_find (device_manager->ignored_interactions, GUINT_TO_POINTER (pointer_id), NULL); |
| } |
| |
| static inline guint32 |
| winpointer_get_time (MSG *msg, |
| POINTER_INFO *info) |
| { |
| return info->dwTime != 0 ? info->dwTime : msg->time; |
| } |
| |
| static inline gboolean |
| winpointer_is_eraser (POINTER_PEN_INFO *pen_info) |
| { |
| return (pen_info->penFlags & (PEN_FLAG_INVERTED | PEN_FLAG_ERASER)) != 0; |
| } |
| |
| static inline gboolean |
| winpointer_should_filter_message (MSG *msg, |
| POINTER_INPUT_TYPE type) |
| { |
| switch (type) |
| { |
| case PT_TOUCH: |
| return msg->message == WM_POINTERENTER || |
| msg->message == WM_POINTERLEAVE; |
| break; |
| } |
| |
| return FALSE; |
| } |
| |
| static inline double* |
| copy_axes (double *axes) |
| { |
| return g_memdup2 (axes, sizeof (double) * GDK_AXIS_LAST); |
| } |
| |
| static GdkDeviceWinpointer* |
| winpointer_find_device_with_source (GdkDeviceManagerWin32 *device_manager, |
| HANDLE device_handle, |
| UINT32 cursor_id, |
| GdkInputSource input_source) |
| { |
| for (GList *l = device_manager->winpointer_devices; l != NULL; l = l->next) |
| { |
| GdkDeviceWinpointer *device = (GdkDeviceWinpointer*) l->data; |
| |
| if (device->device_handle == device_handle && |
| device->start_cursor_id <= cursor_id && |
| device->end_cursor_id >= cursor_id && |
| gdk_device_get_source ((GdkDevice*) device) == input_source) |
| { |
| return device; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| static gboolean |
| winpointer_get_event_type (GdkDeviceManagerWin32 *device_manager, |
| MSG *msg, |
| POINTER_INFO *info, |
| GdkEventType *evt_type) |
| { |
| switch (info->pointerType) |
| { |
| case PT_PEN: |
| switch (msg->message) |
| { |
| case WM_POINTERENTER: |
| g_return_val_if_fail (IS_POINTER_NEW_WPARAM (msg->wParam), FALSE); |
| *evt_type = GDK_PROXIMITY_IN; |
| return TRUE; |
| case WM_POINTERLEAVE: |
| g_return_val_if_fail (!IS_POINTER_INRANGE_WPARAM (msg->wParam), FALSE); |
| *evt_type = GDK_PROXIMITY_OUT; |
| return TRUE; |
| case WM_POINTERDOWN: |
| *evt_type = GDK_BUTTON_PRESS; |
| return TRUE; |
| case WM_POINTERUP: |
| *evt_type = GDK_BUTTON_RELEASE; |
| return TRUE; |
| case WM_POINTERUPDATE: |
| *evt_type = GDK_MOTION_NOTIFY; |
| return TRUE; |
| } |
| break; |
| case PT_TOUCH: |
| if (IS_POINTER_CANCELED_WPARAM (msg->wParam) || |
| !HAS_POINTER_CONFIDENCE_WPARAM (msg->wParam)) |
| { |
| winpointer_ignore_interaction (device_manager, GET_POINTERID_WPARAM (msg->wParam)); |
| |
| if (((info->pointerFlags & POINTER_FLAG_INCONTACT) && |
| (info->pointerFlags & POINTER_FLAG_UPDATE)) || |
| (info->pointerFlags & POINTER_FLAG_UP)) |
| { |
| *evt_type = GDK_TOUCH_CANCEL; |
| return TRUE; |
| } |
| else |
| return FALSE; |
| } |
| |
| g_return_val_if_fail (msg->message != WM_POINTERENTER && |
| msg->message != WM_POINTERLEAVE, FALSE); |
| |
| switch (msg->message) |
| { |
| case WM_POINTERDOWN: |
| *evt_type = GDK_TOUCH_BEGIN; |
| return TRUE; |
| case WM_POINTERUP: |
| *evt_type = GDK_TOUCH_END; |
| return TRUE; |
| case WM_POINTERUPDATE: |
| if (!IS_POINTER_INCONTACT_WPARAM (msg->wParam)) |
| return FALSE; |
| *evt_type = GDK_TOUCH_UPDATE; |
| return TRUE; |
| } |
| break; |
| } |
| |
| g_warn_if_reached (); |
| |
| return FALSE; |
| } |
| |
| static void |
| winpointer_make_event (GdkDeviceWinpointer *device, |
| GdkDeviceTool *tool, |
| GdkSurface *surface, |
| MSG *msg, |
| POINTER_INFO *info) |
| { |
| guint32 time = 0; |
| double screen_x = 0.0; |
| double screen_y = 0.0; |
| double x = 0.0; |
| double y = 0.0; |
| unsigned int state = 0; |
| unsigned int button = 0; |
| double axes[GDK_AXIS_LAST]; |
| GdkEventSequence *sequence = NULL; |
| gboolean emulating_pointer = FALSE; |
| POINT client_area_coordinates; |
| GdkWin32Surface *impl = NULL; |
| GdkEventType evt_type; |
| GdkEvent *evt = NULL; |
| GdkDevice *core_device = NULL; |
| GdkDeviceManagerWin32 *device_manager = GDK_WIN32_DISPLAY (gdk_surface_get_display (surface))->device_manager; |
| |
| core_device = device_manager->core_pointer; |
| |
| if (!winpointer_get_event_type (device_manager, msg, info, &evt_type)) |
| return; |
| |
| time = winpointer_get_time (msg, info); |
| |
| screen_x = device->origin_x + info->ptHimetricLocation.x * device->scale_x; |
| screen_y = device->origin_y + info->ptHimetricLocation.y * device->scale_y; |
| |
| client_area_coordinates.x = 0; |
| client_area_coordinates.y = 0; |
| ClientToScreen (GDK_SURFACE_HWND (surface), &client_area_coordinates); |
| x = screen_x - client_area_coordinates.x; |
| y = screen_y - client_area_coordinates.y; |
| |
| impl = GDK_WIN32_SURFACE (surface); |
| x /= impl->surface_scale; |
| y /= impl->surface_scale; |
| |
| state = 0; |
| /* Note that info->dwKeyStates is not reliable, use GetKeyState() */ |
| if (GetKeyState (VK_CONTROL) < 0) |
| state |= GDK_CONTROL_MASK; |
| if (GetKeyState (VK_SHIFT) < 0) |
| state |= GDK_SHIFT_MASK; |
| if (GetKeyState (VK_MENU) < 0) |
| state |= GDK_ALT_MASK; |
| if (GetKeyState (VK_CAPITAL) & 0x1) |
| state |= GDK_LOCK_MASK; |
| |
| device->last_button_mask = 0; |
| if (((info->pointerFlags & POINTER_FLAG_FIRSTBUTTON) && |
| (info->ButtonChangeType != POINTER_CHANGE_FIRSTBUTTON_DOWN)) |
| || info->ButtonChangeType == POINTER_CHANGE_FIRSTBUTTON_UP) |
| device->last_button_mask |= GDK_BUTTON1_MASK; |
| if (((info->pointerFlags & POINTER_FLAG_SECONDBUTTON) && |
| (info->ButtonChangeType != POINTER_CHANGE_SECONDBUTTON_DOWN)) |
| || info->ButtonChangeType == POINTER_CHANGE_SECONDBUTTON_UP) |
| device->last_button_mask |= GDK_BUTTON3_MASK; |
| state |= device->last_button_mask; |
| |
| memset (axes, 0, sizeof (axes)); |
| switch (info->pointerType) |
| { |
| case PT_PEN: |
| { |
| POINTER_PEN_INFO *pen_info = (POINTER_PEN_INFO*) info; |
| |
| axes[GDK_AXIS_PRESSURE] = (pen_info->penMask & PEN_MASK_PRESSURE) ? |
| pen_info->pressure / 1024.0 : |
| (pen_info->pointerInfo.pointerFlags & POINTER_FLAG_INCONTACT) ? |
| 1.0 : 0.0; |
| axes[GDK_AXIS_XTILT] = (pen_info->penMask & PEN_MASK_TILT_X) ? |
| pen_info->tiltX / 90.0 : 0.0; |
| axes[GDK_AXIS_YTILT] = (pen_info->penMask & PEN_MASK_TILT_Y) ? |
| pen_info->tiltY / 90.0 : 0.0; |
| axes[GDK_AXIS_ROTATION] = (pen_info->penMask & PEN_MASK_ROTATION) ? |
| pen_info->rotation / 360.0 : 0.0; |
| } |
| break; |
| case PT_TOUCH: |
| { |
| POINTER_TOUCH_INFO *touch_info = (POINTER_TOUCH_INFO*) info; |
| |
| axes[GDK_AXIS_PRESSURE] = (touch_info->touchMask & TOUCH_MASK_PRESSURE) ? |
| touch_info->pressure / 1024.0 : |
| (touch_info->pointerInfo.pointerFlags & POINTER_FLAG_INCONTACT) ? |
| 1.0 : 0.0; |
| } |
| break; |
| } |
| |
| sequence = (GdkEventSequence*) GUINT_TO_POINTER (info->pointerId); |
| emulating_pointer = (info->pointerFlags & POINTER_FLAG_PRIMARY) != 0; |
| button = (info->pointerFlags & POINTER_FLAG_FIRSTBUTTON) || |
| (info->ButtonChangeType == POINTER_CHANGE_FIRSTBUTTON_UP) ? 1 : 3; |
| |
| switch (evt_type) |
| { |
| case GDK_PROXIMITY_IN: |
| case GDK_PROXIMITY_OUT: |
| evt = gdk_proximity_event_new (evt_type, |
| surface, |
| core_device, |
| tool, |
| time); |
| break; |
| case GDK_BUTTON_PRESS: |
| case GDK_BUTTON_RELEASE: |
| evt = gdk_button_event_new (evt_type, |
| surface, |
| core_device, |
| tool, |
| time, |
| state, |
| button, |
| x, |
| y, |
| copy_axes (axes)); |
| break; |
| case GDK_MOTION_NOTIFY: |
| evt = gdk_motion_event_new (surface, |
| core_device, |
| tool, |
| time, |
| state, |
| x, |
| y, |
| copy_axes (axes)); |
| break; |
| case GDK_TOUCH_BEGIN: |
| case GDK_TOUCH_UPDATE: |
| case GDK_TOUCH_CANCEL: |
| case GDK_TOUCH_END: |
| evt = gdk_touch_event_new (evt_type, |
| sequence, |
| surface, |
| core_device, |
| time, |
| state, |
| x, |
| y, |
| copy_axes (axes), |
| emulating_pointer); |
| break; |
| default: |
| g_warn_if_reached (); |
| break; |
| } |
| |
| if (evt_type == GDK_PROXIMITY_OUT) |
| gdk_device_update_tool ((GdkDevice*) device, NULL); |
| |
| if (G_LIKELY (evt)) |
| { |
| _gdk_device_virtual_set_active (core_device, (GdkDevice*) device); |
| _gdk_win32_append_event (evt); |
| } |
| } |
| |
| void |
| gdk_winpointer_input_events (GdkSurface *surface, |
| crossing_cb_t crossing_cb, |
| MSG *msg) |
| { |
| UINT32 pointer_id = GET_POINTERID_WPARAM (msg->wParam); |
| POINTER_INPUT_TYPE type = PT_POINTER; |
| UINT32 cursor_id = 0; |
| GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (gdk_surface_get_display (surface)); |
| GdkDeviceManagerWin32 *device_manager = display_win32->device_manager; |
| |
| if (!WINPOINTER_API (device_manager, getPointerType) (pointer_id, &type)) |
| { |
| WIN32_API_FAILED_LOG_ONCE ("GetPointerType"); |
| return; |
| } |
| |
| if (!WINPOINTER_API (device_manager, getPointerCursorId) (pointer_id, &cursor_id)) |
| { |
| WIN32_API_FAILED_LOG_ONCE ("GetPointerCursorId"); |
| return; |
| } |
| |
| if (winpointer_should_filter_message (msg, type)) |
| return; |
| |
| if (winpointer_should_ignore_interaction (device_manager, pointer_id)) |
| return; |
| |
| switch (type) |
| { |
| case PT_PEN: |
| { |
| POINTER_PEN_INFO *infos = NULL; |
| UINT32 history_count = 0; |
| GdkDeviceWinpointer *device = NULL; |
| GdkDeviceTool *tool = NULL; |
| UINT32 h = 0; |
| |
| do |
| { |
| infos = g_new0 (POINTER_PEN_INFO, history_count); |
| if (!WINPOINTER_API (device_manager, getPointerPenInfoHistory) (pointer_id, &history_count, infos)) |
| { |
| WIN32_API_FAILED_LOG_ONCE ("GetPointerPenInfoHistory"); |
| g_free (infos); |
| return; |
| } |
| } |
| while (!infos && history_count > 0); |
| |
| if (G_UNLIKELY (history_count == 0)) |
| return; |
| |
| device = winpointer_find_device_with_source (device_manager, infos->pointerInfo.sourceDevice, cursor_id, GDK_SOURCE_PEN); |
| if (G_UNLIKELY (!device)) |
| { |
| g_free (infos); |
| return; |
| } |
| |
| if (!winpointer_is_eraser (infos)) |
| tool = device->tool_pen; |
| else |
| tool = device->tool_eraser; |
| |
| gdk_device_update_tool ((GdkDevice*) device, tool); |
| |
| h = history_count - 1; |
| |
| if (crossing_cb) |
| { |
| POINT screen_pt = infos[h].pointerInfo.ptPixelLocation; |
| guint32 event_time = winpointer_get_time (msg, &infos[h].pointerInfo); |
| |
| crossing_cb(GDK_DEVICE (device), surface, &screen_pt, event_time); |
| } |
| |
| do |
| winpointer_make_event (device, tool, surface, msg, (POINTER_INFO*) &infos[h]); |
| while (h-- > 0); |
| |
| g_free (infos); |
| } |
| break; |
| case PT_TOUCH: |
| { |
| POINTER_TOUCH_INFO *infos = NULL; |
| UINT32 history_count = 0; |
| GdkDeviceWinpointer *device = NULL; |
| UINT32 h = 0; |
| |
| do |
| { |
| infos = g_new0 (POINTER_TOUCH_INFO, history_count); |
| if (!WINPOINTER_API (device_manager, getPointerTouchInfoHistory) (pointer_id, &history_count, infos)) |
| { |
| WIN32_API_FAILED_LOG_ONCE ("GetPointerTouchInfoHistory"); |
| g_free (infos); |
| return; |
| } |
| } |
| while (!infos && history_count > 0); |
| |
| if (G_UNLIKELY (history_count == 0)) |
| return; |
| |
| device = winpointer_find_device_with_source (device_manager, infos->pointerInfo.sourceDevice, cursor_id, GDK_SOURCE_TOUCHSCREEN); |
| if (G_UNLIKELY (!device)) |
| { |
| g_free (infos); |
| return; |
| } |
| |
| h = history_count - 1; |
| |
| if (crossing_cb) |
| { |
| POINT screen_pt = infos[h].pointerInfo.ptPixelLocation; |
| guint32 event_time = winpointer_get_time (msg, &infos[h].pointerInfo); |
| |
| crossing_cb(GDK_DEVICE (device), surface, &screen_pt, event_time); |
| } |
| |
| do |
| winpointer_make_event (device, NULL, surface, msg, (POINTER_INFO*) &infos[h]); |
| while (h-- > 0); |
| |
| g_free (infos); |
| } |
| break; |
| } |
| } |
| |
| gboolean |
| gdk_winpointer_get_message_info (MSG *msg, |
| GdkDevice **device, |
| GdkWin32Display *display_win32, |
| guint32 *time) |
| { |
| UINT32 pointer_id = GET_POINTERID_WPARAM (msg->wParam); |
| POINTER_INPUT_TYPE type = PT_POINTER; |
| UINT32 cursor_id = 0; |
| GdkDeviceManagerWin32 *device_manager = display_win32->device_manager; |
| |
| if (!WINPOINTER_API (device_manager, getPointerType) (pointer_id, &type)) |
| { |
| WIN32_API_FAILED_LOG_ONCE ("GetPointerType"); |
| return FALSE; |
| } |
| |
| if (!WINPOINTER_API (device_manager, getPointerCursorId) (pointer_id, &cursor_id)) |
| { |
| WIN32_API_FAILED_LOG_ONCE ("GetPointerCursorId"); |
| return FALSE; |
| } |
| |
| switch (type) |
| { |
| case PT_PEN: |
| { |
| POINTER_PEN_INFO pen_info; |
| |
| if (!WINPOINTER_API (device_manager, getPointerPenInfo) (pointer_id, &pen_info)) |
| { |
| WIN32_API_FAILED_LOG_ONCE ("GetPointerPenInfo"); |
| return FALSE; |
| } |
| |
| *device = (GdkDevice*) winpointer_find_device_with_source (device_manager, pen_info.pointerInfo.sourceDevice, cursor_id, GDK_SOURCE_PEN); |
| *time = winpointer_get_time (msg, &pen_info.pointerInfo); |
| } |
| break; |
| case PT_TOUCH: |
| { |
| POINTER_TOUCH_INFO touch_info; |
| |
| if (!WINPOINTER_API (device_manager, getPointerTouchInfo) (pointer_id, &touch_info)) |
| { |
| WIN32_API_FAILED_LOG_ONCE ("GetPointerTouchInfo"); |
| return FALSE; |
| } |
| |
| *device = GDK_DEVICE (winpointer_find_device_with_source (device_manager, |
| touch_info.pointerInfo.sourceDevice, |
| cursor_id, |
| GDK_SOURCE_TOUCHSCREEN)); |
| |
| *time = winpointer_get_time (msg, &touch_info.pointerInfo); |
| } |
| break; |
| default: |
| g_warn_if_reached (); |
| return FALSE; |
| break; |
| } |
| |
| return *device ? TRUE : FALSE; |
| } |
| |
| gboolean |
| gdk_winpointer_should_forward_message (GdkDeviceManagerWin32 *device_manager, |
| MSG *msg) |
| { |
| UINT32 pointer_id = GET_POINTERID_WPARAM (msg->wParam); |
| POINTER_INPUT_TYPE type = PT_POINTER; |
| |
| if (!WINPOINTER_API (device_manager, getPointerType) (pointer_id, &type)) |
| { |
| WIN32_API_FAILED_LOG_ONCE ("GetPointerType"); |
| return TRUE; |
| } |
| |
| return !(type == PT_PEN || type == PT_TOUCH); |
| } |
| |
| void |
| gdk_winpointer_interaction_ended (GdkDeviceManagerWin32 *device_manager, |
| MSG *msg) |
| { |
| winpointer_remove_ignored_interaction (device_manager, GET_POINTERID_WPARAM (msg->wParam)); |
| } |
| |
| static inline double |
| utils_rect_width (RECT *rect) |
| { |
| return rect->right - rect->left; |
| } |
| |
| static inline double |
| utils_rect_height (RECT *rect) |
| { |
| return rect->bottom - rect->top; |
| } |
| |
| static inline gboolean |
| utils_rect_is_degenerate (RECT *rect) |
| { |
| return utils_rect_width (rect) == 0 || utils_rect_height (rect) == 0; |
| } |
| |
| static gboolean |
| winpointer_device_update_scale_factors (GdkDeviceWinpointer *device, |
| GdkDeviceManagerWin32 *device_manager) |
| { |
| RECT device_rect; |
| RECT display_rect; |
| |
| if (!WINPOINTER_API (device_manager, getPointerDeviceRects) (device->device_handle, &device_rect, &display_rect)) |
| { |
| WIN32_API_FAILED ("GetPointerDeviceRects"); |
| return FALSE; |
| } |
| |
| if (utils_rect_is_degenerate (&device_rect)) |
| { |
| g_warning ("Invalid coordinates from GetPointerDeviceRects"); |
| return FALSE; |
| } |
| |
| device->origin_x = display_rect.left; |
| device->origin_y = display_rect.top; |
| device->scale_x = utils_rect_width (&display_rect) / utils_rect_width (&device_rect); |
| device->scale_y = utils_rect_height (&display_rect) / utils_rect_height (&device_rect); |
| |
| return TRUE; |
| } |
| |
| static void |
| winpointer_get_device_details (HANDLE device, |
| char *vid, |
| char *pid, |
| char **manufacturer, |
| char **product) |
| { |
| RID_DEVICE_INFO info; |
| UINT wchars_count = 0; |
| UINT size = 0; |
| |
| memset (&info, 0, sizeof (info)); |
| |
| info.cbSize = sizeof (info); |
| size = sizeof (info); |
| |
| if (GetRawInputDeviceInfoW (device, RIDI_DEVICEINFO, &info, &size) > 0 && |
| info.dwType == RIM_TYPEHID && |
| info.hid.dwVendorId > 0 && |
| info.hid.dwProductId > 0) |
| { |
| const char *format_string = "%0" G_STRINGIFY (VID_PID_CHARS) "x"; |
| |
| g_snprintf (vid, VID_PID_CHARS + 1, format_string, (unsigned) info.hid.dwVendorId); |
| g_snprintf (pid, VID_PID_CHARS + 1, format_string, (unsigned) info.hid.dwProductId); |
| } |
| |
| if (GetRawInputDeviceInfoW (device, RIDI_DEVICENAME, NULL, &wchars_count) == 0) |
| { |
| gunichar2 *device_path = g_new0 (gunichar2, wchars_count); |
| |
| if (GetRawInputDeviceInfoW (device, RIDI_DEVICENAME, device_path, &wchars_count) > 0) |
| { |
| HANDLE device_file = CreateFileW (device_path, |
| 0, |
| FILE_SHARE_READ | |
| FILE_SHARE_WRITE | |
| FILE_SHARE_DELETE, |
| NULL, |
| OPEN_EXISTING, |
| FILE_FLAG_SESSION_AWARE, |
| NULL); |
| |
| if (device_file != INVALID_HANDLE_VALUE) |
| { |
| gunichar2 *buffer = g_malloc0 (HID_STRING_BYTES_LIMIT); |
| |
| if (HidD_GetManufacturerString (device_file, buffer, HID_STRING_BYTES_LIMIT)) |
| if (buffer[0]) |
| *manufacturer = g_utf16_to_utf8 (buffer, -1, NULL, NULL, NULL); |
| |
| if (HidD_GetProductString (device_file, buffer, HID_STRING_BYTES_LIMIT)) |
| if (buffer[0]) |
| *product = g_utf16_to_utf8 (buffer, -1, NULL, NULL, NULL); |
| |
| g_free (buffer); |
| CloseHandle (device_file); |
| } |
| } |
| |
| g_free (device_path); |
| } |
| } |
| |
| static void |
| winpointer_create_device (GdkDeviceManagerWin32 *device_manager, |
| POINTER_DEVICE_INFO *info, |
| GdkInputSource source) |
| { |
| GdkDeviceWinpointer *device = NULL; |
| GdkSeat *seat = NULL; |
| unsigned num_touches = 0; |
| char vid[VID_PID_CHARS + 1]; |
| char pid[VID_PID_CHARS + 1]; |
| char *manufacturer = NULL; |
| char *product = NULL; |
| char *base_name = NULL; |
| char *name = NULL; |
| UINT32 num_cursors = 0; |
| GdkAxisFlags axes_flags = 0; |
| |
| seat = gdk_display_get_default_seat (device_manager->display); |
| |
| memset (pid, 0, VID_PID_CHARS + 1); |
| memset (vid, 0, VID_PID_CHARS + 1); |
| |
| if (!WINPOINTER_API (device_manager, getPointerDeviceCursors) (info->device, &num_cursors, NULL)) |
| { |
| WIN32_API_FAILED ("GetPointerDeviceCursors"); |
| return; |
| } |
| |
| if (num_cursors == 0) |
| return; |
| |
| winpointer_get_device_details (info->device, vid, pid, &manufacturer, &product); |
| |
| /* build up the name */ |
| if (!manufacturer && vid[0]) |
| manufacturer = g_strdup (vid); |
| |
| if (!product && pid[0]) |
| product = g_strdup (pid); |
| |
| if (manufacturer && product) |
| base_name = g_strconcat (manufacturer, " ", product, NULL); |
| |
| if (!base_name && info->productString[0]) |
| base_name = g_utf16_to_utf8 (info->productString, -1, NULL, NULL, NULL); |
| |
| if (!base_name) |
| base_name = g_strdup ("Unnamed"); |
| |
| switch (source) |
| { |
| case GDK_SOURCE_PEN: |
| name = g_strconcat (base_name, " Pen", NULL); |
| break; |
| |
| case GDK_SOURCE_TOUCHSCREEN: |
| num_touches = info->maxActiveContacts; |
| name = g_strconcat (base_name, " Finger touch", NULL); |
| break; |
| |
| default: |
| name = g_strdup (base_name); |
| break; |
| } |
| |
| device = g_object_new (GDK_TYPE_DEVICE_WINPOINTER, |
| "display", device_manager->display, |
| "seat", seat, |
| "has-cursor", TRUE, |
| "source", source, |
| "name", name, |
| "num-touches", num_touches, |
| "vendor-id", vid[0] ? vid : NULL, |
| "product-id", pid[0] ? pid : NULL, |
| NULL); |
| |
| switch (source) |
| { |
| case GDK_SOURCE_PEN: |
| _gdk_device_add_axis (GDK_DEVICE (device), GDK_AXIS_PRESSURE, 0.0, 1.0, 1.0 / 1024.0); |
| axes_flags |= GDK_AXIS_FLAG_PRESSURE; |
| |
| _gdk_device_add_axis (GDK_DEVICE (device), GDK_AXIS_XTILT, -1.0, 1.0, 1.0 / 90.0); |
| axes_flags |= GDK_AXIS_FLAG_XTILT; |
| |
| _gdk_device_add_axis (GDK_DEVICE (device), GDK_AXIS_YTILT, -1.0, 1.0, 1.0 / 90.0); |
| axes_flags |= GDK_AXIS_FLAG_YTILT; |
| |
| _gdk_device_add_axis (GDK_DEVICE (device), GDK_AXIS_ROTATION, 0.0, 1.0, 1.0 / 360.0); |
| axes_flags |= GDK_AXIS_FLAG_ROTATION; |
| break; |
| |
| case GDK_SOURCE_TOUCHSCREEN: |
| _gdk_device_add_axis (GDK_DEVICE (device), GDK_AXIS_PRESSURE, 0.0, 1.0, 1.0 / 1024.0); |
| axes_flags |= GDK_AXIS_FLAG_PRESSURE; |
| break; |
| |
| default: |
| g_warn_if_reached (); |
| break; |
| } |
| |
| device->device_handle = info->device; |
| device->start_cursor_id = info->startingCursorId; |
| device->end_cursor_id = info->startingCursorId + num_cursors - 1; |
| |
| if (!winpointer_device_update_scale_factors (device, device_manager)) |
| { |
| g_set_object (&device, NULL); |
| goto cleanup; |
| } |
| |
| switch (source) |
| { |
| case GDK_SOURCE_PEN: |
| { |
| device->tool_pen = gdk_device_tool_new (0, 0, GDK_DEVICE_TOOL_TYPE_PEN, axes_flags); |
| gdk_seat_default_add_tool (GDK_SEAT_DEFAULT (seat), device->tool_pen); |
| |
| device->tool_eraser = gdk_device_tool_new (0, 0, GDK_DEVICE_TOOL_TYPE_ERASER, axes_flags); |
| gdk_seat_default_add_tool (GDK_SEAT_DEFAULT (seat), device->tool_eraser); |
| } |
| break; |
| case GDK_SOURCE_TOUCHSCREEN: |
| break; |
| default: |
| g_warn_if_reached (); |
| break; |
| } |
| |
| device_manager->winpointer_devices = g_list_append (device_manager->winpointer_devices, device); |
| |
| _gdk_device_set_associated_device (GDK_DEVICE (device), device_manager->core_pointer); |
| _gdk_device_add_physical_device (device_manager->core_pointer, GDK_DEVICE (device)); |
| |
| gdk_seat_default_add_physical_device (GDK_SEAT_DEFAULT (seat), GDK_DEVICE (device)); |
| |
| cleanup: |
| g_free (name); |
| g_free (base_name); |
| g_free (product); |
| g_free (manufacturer); |
| } |
| |
| static void |
| winpointer_create_devices (GdkDeviceManagerWin32 *device_manager, |
| POINTER_DEVICE_INFO *info) |
| { |
| switch (info->pointerDeviceType) |
| { |
| case POINTER_DEVICE_TYPE_INTEGRATED_PEN: |
| case POINTER_DEVICE_TYPE_EXTERNAL_PEN: |
| winpointer_create_device (device_manager, info, GDK_SOURCE_PEN); |
| break; |
| case POINTER_DEVICE_TYPE_TOUCH: |
| winpointer_create_device (device_manager, info, GDK_SOURCE_TOUCHSCREEN); |
| break; |
| default: |
| g_warn_if_reached (); |
| break; |
| } |
| } |
| |
| static gboolean |
| winpointer_find_device_in_system_list (GdkDeviceWinpointer *device, |
| POINTER_DEVICE_INFO *infos, |
| UINT32 infos_count) |
| { |
| for (UINT32 i = 0; i < infos_count; i++) |
| { |
| if (device->device_handle == infos[i].device && |
| device->start_cursor_id == infos[i].startingCursorId) |
| { |
| return TRUE; |
| } |
| } |
| |
| return FALSE; |
| } |
| |
| static gboolean |
| winpointer_find_system_device_in_device_manager (GdkDeviceManagerWin32 *device_manager, |
| POINTER_DEVICE_INFO *info) |
| { |
| for (GList *l = device_manager->winpointer_devices; l != NULL; l = l->next) |
| { |
| GdkDeviceWinpointer *device = GDK_DEVICE_WINPOINTER (l->data); |
| |
| if (device->device_handle == info->device && |
| device->start_cursor_id == info->startingCursorId) |
| { |
| return TRUE; |
| } |
| } |
| |
| return FALSE; |
| } |
| |
| static void |
| winpointer_enumerate_devices (GdkDeviceManagerWin32 *device_manager) |
| { |
| POINTER_DEVICE_INFO *infos = NULL; |
| UINT32 infos_count = 0; |
| UINT32 i = 0; |
| GList *current = NULL; |
| |
| do |
| { |
| infos = g_new0 (POINTER_DEVICE_INFO, infos_count); |
| if (!WINPOINTER_API (device_manager, getPointerDevices) (&infos_count, infos)) |
| { |
| WIN32_API_FAILED ("GetPointerDevices"); |
| g_free (infos); |
| return; |
| } |
| } |
| while (infos_count > 0 && !infos); |
| |
| current = device_manager->winpointer_devices; |
| |
| while (current != NULL) |
| { |
| GdkDeviceWinpointer *device = GDK_DEVICE_WINPOINTER (current->data); |
| GList *next = current->next; |
| |
| if (!winpointer_find_device_in_system_list (device, infos, infos_count)) |
| { |
| GdkSeat *seat = gdk_device_get_seat (GDK_DEVICE (device)); |
| |
| device_manager->winpointer_devices = g_list_delete_link (device_manager->winpointer_devices, |
| current); |
| |
| gdk_device_update_tool (GDK_DEVICE (device), NULL); |
| |
| if (device->tool_pen) |
| gdk_seat_default_remove_tool (GDK_SEAT_DEFAULT (seat), device->tool_pen); |
| |
| if (device->tool_eraser) |
| gdk_seat_default_remove_tool (GDK_SEAT_DEFAULT (seat), device->tool_eraser); |
| |
| _gdk_device_set_associated_device (GDK_DEVICE (device), NULL); |
| _gdk_device_remove_physical_device (device_manager->core_pointer, GDK_DEVICE (device)); |
| |
| gdk_seat_default_remove_physical_device (GDK_SEAT_DEFAULT (seat), GDK_DEVICE (device)); |
| |
| g_object_unref (device); |
| } |
| else |
| { |
| winpointer_device_update_scale_factors (device, device_manager); |
| } |
| |
| current = next; |
| } |
| |
| /* create new gdk devices */ |
| for (i = 0; i < infos_count; i++) |
| { |
| if (!winpointer_find_system_device_in_device_manager (device_manager, &infos[i])) |
| { |
| winpointer_create_devices (device_manager, &infos[i]); |
| } |
| } |
| |
| g_free (infos); |
| } |
| |
| static LRESULT CALLBACK |
| winpointer_notifications_window_procedure (HWND hWnd, |
| UINT uMsg, |
| WPARAM wParam, |
| LPARAM lParam) |
| { |
| GdkDeviceManagerWin32 *device_manager; |
| CREATESTRUCT *cs = NULL; |
| |
| switch (uMsg) |
| { |
| case WM_NCCREATE: |
| cs = (CREATESTRUCT *)lParam; |
| device_manager = cs->lpCreateParams; |
| SetWindowLongPtr (hWnd, GWLP_USERDATA, (LONG_PTR)device_manager); |
| return TRUE; |
| case WM_POINTERDEVICECHANGE: |
| device_manager = (GdkDeviceManagerWin32 *) GetWindowLongPtr (hWnd, GWLP_USERDATA); |
| winpointer_enumerate_devices (device_manager); |
| return 0; |
| } |
| |
| return DefWindowProcW (hWnd, uMsg, wParam, lParam); |
| } |
| |
| static HWND |
| winpointer_notif_window_create (GdkDeviceManagerWin32 *device_manager) |
| { |
| WNDCLASSEXW wndclassex; |
| ATOM notifications_window_class; |
| HWND notification_window_hwnd = NULL; |
| |
| memset (&wndclassex, 0, sizeof (wndclassex)); |
| wndclassex.cbSize = sizeof (wndclassex); |
| wndclassex.lpszClassName = L"GdkWin32WinpointerNotificationsWindowClass"; |
| wndclassex.lpfnWndProc = winpointer_notifications_window_procedure; |
| wndclassex.hInstance = this_module (); |
| |
| notifications_window_class = RegisterClassExW (&wndclassex); |
| |
| if (notifications_window_class != 0) |
| { |
| notification_window_hwnd = CreateWindowExW (0, |
| (LPCWSTR)(guintptr)notifications_window_class, |
| L"GdkWin32 Winpointer Notifications", |
| 0, |
| 0, 0, 0, 0, |
| HWND_MESSAGE, |
| NULL, |
| this_module (), |
| device_manager); |
| |
| if (notification_window_hwnd == NULL) |
| WIN32_API_FAILED ("CreateWindowExW"); |
| } |
| else |
| WIN32_API_FAILED ("RegisterClassExW"); |
| |
| return notification_window_hwnd; |
| } |
| |
| static gboolean |
| winpointer_ensure_procedures (GdkDeviceManagerWin32 *device_manager) |
| { |
| GdkDeviceManagerWin32WinpointerFuncs *funcs = NULL; |
| static gsize user32_dll_checked = 0; |
| |
| if (g_once_init_enter (&user32_dll_checked)) |
| { |
| HMODULE user32_dll = NULL; |
| |
| user32_dll = LoadLibraryW (L"user32.dll"); |
| if (user32_dll) |
| { |
| funcs = g_new0 (GdkDeviceManagerWin32WinpointerFuncs, 1); |
| |
| funcs->registerPointerDeviceNotifications = (registerPointerDeviceNotifications_t) |
| GetProcAddress (user32_dll, "RegisterPointerDeviceNotifications"); |
| funcs->getPointerDevices = (getPointerDevices_t) |
| GetProcAddress (user32_dll, "GetPointerDevices"); |
| funcs->getPointerDeviceCursors = (getPointerDeviceCursors_t) |
| GetProcAddress (user32_dll, "GetPointerDeviceCursors"); |
| funcs->getPointerDeviceRects = (getPointerDeviceRects_t) |
| GetProcAddress (user32_dll, "GetPointerDeviceRects"); |
| funcs->getPointerType = (getPointerType_t) |
| GetProcAddress (user32_dll, "GetPointerType"); |
| funcs->getPointerCursorId = (getPointerCursorId_t) |
| GetProcAddress (user32_dll, "GetPointerCursorId"); |
| funcs->getPointerPenInfo = (getPointerPenInfo_t) |
| GetProcAddress (user32_dll, "GetPointerPenInfo"); |
| funcs->getPointerTouchInfo = (getPointerTouchInfo_t) |
| GetProcAddress (user32_dll, "GetPointerTouchInfo"); |
| funcs->getPointerPenInfoHistory = (getPointerPenInfoHistory_t) |
| GetProcAddress (user32_dll, "GetPointerPenInfoHistory"); |
| funcs->getPointerTouchInfoHistory = (getPointerTouchInfoHistory_t) |
| GetProcAddress (user32_dll, "GetPointerTouchInfoHistory"); |
| funcs->setGestureConfig = (setGestureConfig_t) |
| GetProcAddress (user32_dll, "SetGestureConfig"); |
| funcs->setWindowFeedbackSetting = (setWindowFeedbackSetting_t) |
| GetProcAddress (user32_dll, "SetWindowFeedbackSetting"); |
| |
| if (funcs->registerPointerDeviceNotifications && |
| funcs->getPointerDevices && |
| funcs->getPointerDeviceCursors && |
| funcs->getPointerDeviceRects && |
| funcs->getPointerType && |
| funcs->getPointerCursorId && |
| funcs->getPointerPenInfo && |
| funcs->getPointerTouchInfo && |
| funcs->getPointerPenInfoHistory && |
| funcs->getPointerTouchInfoHistory) |
| device_manager->winpointer_funcs = funcs; |
| } |
| else |
| WIN32_API_FAILED ("LoadLibraryW"); |
| |
| g_once_init_leave (&user32_dll_checked, 1); |
| } |
| |
| return (device_manager->winpointer_funcs != NULL); |
| } |
| |
| gboolean |
| gdk_winpointer_initialize (GdkDeviceManagerWin32 *device_manager) |
| { |
| HWND notification_hwnd = NULL; |
| if (!winpointer_ensure_procedures (device_manager)) |
| return FALSE; |
| |
| notification_hwnd = winpointer_notif_window_create (device_manager); |
| if (notification_hwnd == NULL) |
| return FALSE; |
| |
| if (!WINPOINTER_API (device_manager, registerPointerDeviceNotifications) (notification_hwnd, FALSE)) |
| { |
| WIN32_API_FAILED ("RegisterPointerDeviceNotifications"); |
| return FALSE; |
| } |
| |
| device_manager->winpointer_notification_hwnd = notification_hwnd; |
| device_manager->ignored_interactions = g_ptr_array_new (); |
| |
| winpointer_enumerate_devices (device_manager); |
| |
| return TRUE; |
| } |
| |
| #ifndef MICROSOFT_TABLETPENSERVICE_PROPERTY |
| #define MICROSOFT_TABLETPENSERVICE_PROPERTY \ |
| _T("MicrosoftTabletPenServiceProperty") |
| #endif |
| |
| void |
| gdk_winpointer_initialize_surface (GdkSurface *surface) |
| { |
| HWND hwnd = GDK_SURFACE_HWND (surface); |
| ATOM key = 0; |
| HANDLE val = (HANDLE)(TABLET_DISABLE_PRESSANDHOLD | |
| TABLET_DISABLE_PENTAPFEEDBACK | |
| TABLET_DISABLE_PENBARRELFEEDBACK | |
| TABLET_DISABLE_FLICKS | |
| TABLET_DISABLE_FLICKFALLBACKKEYS); |
| |
| GdkDeviceManagerWin32 *device_manager = GDK_WIN32_DISPLAY (gdk_surface_get_display (surface))->device_manager; |
| winpointer_ensure_procedures (device_manager); |
| |
| key = GlobalAddAtom (MICROSOFT_TABLETPENSERVICE_PROPERTY); |
| API_CALL (SetPropW, (hwnd, (LPCWSTR)(guintptr)key, val)); |
| GlobalDeleteAtom (key); |
| |
| if (WINPOINTER_API (device_manager, setGestureConfig) != NULL) |
| { |
| GESTURECONFIG gesture_config; |
| memset (&gesture_config, 0, sizeof (gesture_config)); |
| |
| gesture_config.dwID = 0; |
| gesture_config.dwWant = 0; |
| gesture_config.dwBlock = GC_ALLGESTURES; |
| |
| API_CALL (WINPOINTER_API (device_manager,setGestureConfig), (hwnd, 0, 1, &gesture_config, sizeof (gesture_config))); |
| } |
| |
| if (WINPOINTER_API (device_manager, setWindowFeedbackSetting) != NULL) |
| { |
| FEEDBACK_TYPE feedbacks[] = { |
| FEEDBACK_TOUCH_CONTACTVISUALIZATION, |
| FEEDBACK_PEN_BARRELVISUALIZATION, |
| FEEDBACK_PEN_TAP, |
| FEEDBACK_PEN_DOUBLETAP, |
| FEEDBACK_PEN_PRESSANDHOLD, |
| FEEDBACK_PEN_RIGHTTAP, |
| FEEDBACK_TOUCH_TAP, |
| FEEDBACK_TOUCH_DOUBLETAP, |
| FEEDBACK_TOUCH_PRESSANDHOLD, |
| FEEDBACK_TOUCH_RIGHTTAP, |
| FEEDBACK_GESTURE_PRESSANDTAP |
| }; |
| gsize i = 0; |
| |
| for (i = 0; i < G_N_ELEMENTS (feedbacks); i++) |
| { |
| BOOL setting = FALSE; |
| |
| API_CALL (WINPOINTER_API (device_manager, setWindowFeedbackSetting), (hwnd, feedbacks[i], 0, sizeof (BOOL), &setting)); |
| } |
| } |
| } |
| |
| void |
| gdk_winpointer_finalize_surface (GdkSurface *surface) |
| { |
| HWND hwnd = GDK_SURFACE_HWND (surface); |
| ATOM key = 0; |
| |
| key = GlobalAddAtom (MICROSOFT_TABLETPENSERVICE_PROPERTY); |
| RemovePropW (hwnd, (LPCWSTR)(guintptr)key); |
| GlobalDeleteAtom (key); |
| } |
