From 5a079a2d114f96d4847d1ee305d5b7c16eeec50e Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 27 Dec 2025 12:03:39 -0800 Subject: Initial commit --- .../SDL-3.2.8/src/video/windows/SDL_windowsmouse.c | 745 +++++++++++++++++++++ 1 file changed, 745 insertions(+) create mode 100644 contrib/SDL-3.2.8/src/video/windows/SDL_windowsmouse.c (limited to 'contrib/SDL-3.2.8/src/video/windows/SDL_windowsmouse.c') diff --git a/contrib/SDL-3.2.8/src/video/windows/SDL_windowsmouse.c b/contrib/SDL-3.2.8/src/video/windows/SDL_windowsmouse.c new file mode 100644 index 0000000..3d6bcc4 --- /dev/null +++ b/contrib/SDL-3.2.8/src/video/windows/SDL_windowsmouse.c @@ -0,0 +1,745 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + 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" + +#if defined(SDL_VIDEO_DRIVER_WINDOWS) && !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES) + +#include "SDL_windowsvideo.h" +#include "SDL_windowsevents.h" +#include "SDL_windowsrawinput.h" + +#include "../SDL_video_c.h" +#include "../../events/SDL_mouse_c.h" +#include "../../joystick/usb_ids.h" +#include "../../core/windows/SDL_windows.h" // for checking windows version + + +typedef struct CachedCursor +{ + float scale; + HCURSOR cursor; + struct CachedCursor *next; +} CachedCursor; + +struct SDL_CursorData +{ + SDL_Surface *surface; + int hot_x; + int hot_y; + CachedCursor *cache; + HCURSOR cursor; +}; + +typedef struct +{ + Uint64 xs[5]; + Uint64 ys[5]; + Sint64 residual[2]; + Uint32 dpiscale; + Uint32 dpidenom; + int last_node; + bool enhanced; + bool dpiaware; +} WIN_MouseData; + +DWORD SDL_last_warp_time = 0; +HCURSOR SDL_cursor = NULL; +static SDL_Cursor *SDL_blank_cursor = NULL; +static WIN_MouseData WIN_system_scale_data; + +static SDL_Cursor *WIN_CreateCursorAndData(HCURSOR hcursor) +{ + if (!hcursor) { + return NULL; + } + + SDL_Cursor *cursor = (SDL_Cursor *)SDL_calloc(1, sizeof(*cursor)); + if (!cursor) { + return NULL; + } + + SDL_CursorData *data = (SDL_CursorData *)SDL_calloc(1, sizeof(*data)); + if (!data) { + SDL_free(cursor); + return NULL; + } + + data->cursor = hcursor; + cursor->internal = data; + return cursor; +} + + +static bool IsMonochromeSurface(SDL_Surface *surface) +{ + int x, y; + Uint8 r, g, b, a; + + SDL_assert(surface->format == SDL_PIXELFORMAT_ARGB8888); + + for (y = 0; y < surface->h; y++) { + for (x = 0; x < surface->w; x++) { + SDL_ReadSurfacePixel(surface, x, y, &r, &g, &b, &a); + + // Black or white pixel. + if (!((r == 0x00 && g == 0x00 && b == 0x00) || (r == 0xff && g == 0xff && b == 0xff))) { + return false; + } + + // Transparent or opaque pixel. + if (!(a == 0x00 || a == 0xff)) { + return false; + } + } + } + + return true; +} + +static HBITMAP CreateColorBitmap(SDL_Surface *surface) +{ + HBITMAP bitmap; + BITMAPINFO bi; + void *pixels; + + SDL_assert(surface->format == SDL_PIXELFORMAT_ARGB8888); + + SDL_zero(bi); + bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + bi.bmiHeader.biWidth = surface->w; + bi.bmiHeader.biHeight = -surface->h; // Invert height to make the top-down DIB. + bi.bmiHeader.biPlanes = 1; + bi.bmiHeader.biBitCount = 32; + bi.bmiHeader.biCompression = BI_RGB; + + bitmap = CreateDIBSection(NULL, &bi, DIB_RGB_COLORS, &pixels, NULL, 0); + if (!bitmap || !pixels) { + WIN_SetError("CreateDIBSection()"); + if (bitmap) { + DeleteObject(bitmap); + } + return NULL; + } + + SDL_memcpy(pixels, surface->pixels, surface->pitch * surface->h); + + return bitmap; +} + +/* Generate bitmap with a mask and optional monochrome image data. + * + * For info on the expected mask format see: + * https://devblogs.microsoft.com/oldnewthing/20101018-00/?p=12513 + */ +static HBITMAP CreateMaskBitmap(SDL_Surface *surface, bool is_monochrome) +{ + HBITMAP bitmap; + bool isstack; + void *pixels; + int x, y; + Uint8 r, g, b, a; + Uint8 *dst; + const int pitch = ((surface->w + 15) & ~15) / 8; + const int size = pitch * surface->h; + static const unsigned char masks[] = { 0x80, 0x40, 0x20, 0x10, 0x8, 0x4, 0x2, 0x1 }; + + SDL_assert(surface->format == SDL_PIXELFORMAT_ARGB8888); + + pixels = SDL_small_alloc(Uint8, size * (is_monochrome ? 2 : 1), &isstack); + if (!pixels) { + SDL_OutOfMemory(); + return NULL; + } + + dst = (Uint8 *)pixels; + + // Make the mask completely transparent. + SDL_memset(dst, 0xff, size); + if (is_monochrome) { + SDL_memset(dst + size, 0x00, size); + } + + for (y = 0; y < surface->h; y++, dst += pitch) { + for (x = 0; x < surface->w; x++) { + SDL_ReadSurfacePixel(surface, x, y, &r, &g, &b, &a); + + if (a != 0) { + // Reset bit of an opaque pixel. + dst[x >> 3] &= ~masks[x & 7]; + } + + if (is_monochrome && !(r == 0x00 && g == 0x00 && b == 0x00)) { + // Set bit of white or inverted pixel. + dst[size + (x >> 3)] |= masks[x & 7]; + } + } + } + + bitmap = CreateBitmap(surface->w, surface->h * (is_monochrome ? 2 : 1), 1, 1, pixels); + SDL_small_free(pixels, isstack); + if (!bitmap) { + WIN_SetError("CreateBitmap()"); + return NULL; + } + + return bitmap; +} + +static HCURSOR WIN_CreateHCursor(SDL_Surface *surface, int hot_x, int hot_y) +{ + HCURSOR hcursor; + ICONINFO ii; + bool is_monochrome = IsMonochromeSurface(surface); + + SDL_zero(ii); + ii.fIcon = FALSE; + ii.xHotspot = (DWORD)hot_x; + ii.yHotspot = (DWORD)hot_y; + ii.hbmMask = CreateMaskBitmap(surface, is_monochrome); + ii.hbmColor = is_monochrome ? NULL : CreateColorBitmap(surface); + + if (!ii.hbmMask || (!is_monochrome && !ii.hbmColor)) { + SDL_SetError("Couldn't create cursor bitmaps"); + if (ii.hbmMask) { + DeleteObject(ii.hbmMask); + } + if (ii.hbmColor) { + DeleteObject(ii.hbmColor); + } + return NULL; + } + + hcursor = CreateIconIndirect(&ii); + if (!hcursor) { + WIN_SetError("CreateIconIndirect()"); + DeleteObject(ii.hbmMask); + if (ii.hbmColor) { + DeleteObject(ii.hbmColor); + } + return NULL; + } + + DeleteObject(ii.hbmMask); + if (ii.hbmColor) { + DeleteObject(ii.hbmColor); + } + + return hcursor; +} + +static SDL_Cursor *WIN_CreateCursor(SDL_Surface *surface, int hot_x, int hot_y) +{ + if (!SDL_SurfaceHasAlternateImages(surface)) { + HCURSOR hcursor = WIN_CreateHCursor(surface, hot_x, hot_y); + if (!hcursor) { + return NULL; + } + return WIN_CreateCursorAndData(hcursor); + } + + // Dynamically generate cursors at the appropriate DPI + SDL_Cursor *cursor = (SDL_Cursor *)SDL_calloc(1, sizeof(*cursor)); + if (cursor) { + SDL_CursorData *data = (SDL_CursorData *)SDL_calloc(1, sizeof(*data)); + if (!data) { + SDL_free(cursor); + return NULL; + } + data->hot_x = hot_x; + data->hot_y = hot_y; + data->surface = surface; + ++surface->refcount; + cursor->internal = data; + } + return cursor; +} + +static SDL_Cursor *WIN_CreateBlankCursor(void) +{ + SDL_Cursor *cursor = NULL; + SDL_Surface *surface = SDL_CreateSurface(32, 32, SDL_PIXELFORMAT_ARGB8888); + if (surface) { + cursor = WIN_CreateCursor(surface, 0, 0); + SDL_DestroySurface(surface); + } + return cursor; +} + +static SDL_Cursor *WIN_CreateSystemCursor(SDL_SystemCursor id) +{ + LPCTSTR name; + + switch (id) { + default: + SDL_assert(!"Unknown system cursor ID"); + return NULL; + case SDL_SYSTEM_CURSOR_DEFAULT: + name = IDC_ARROW; + break; + case SDL_SYSTEM_CURSOR_TEXT: + name = IDC_IBEAM; + break; + case SDL_SYSTEM_CURSOR_WAIT: + name = IDC_WAIT; + break; + case SDL_SYSTEM_CURSOR_CROSSHAIR: + name = IDC_CROSS; + break; + case SDL_SYSTEM_CURSOR_PROGRESS: + name = IDC_APPSTARTING; + break; + case SDL_SYSTEM_CURSOR_NWSE_RESIZE: + name = IDC_SIZENWSE; + break; + case SDL_SYSTEM_CURSOR_NESW_RESIZE: + name = IDC_SIZENESW; + break; + case SDL_SYSTEM_CURSOR_EW_RESIZE: + name = IDC_SIZEWE; + break; + case SDL_SYSTEM_CURSOR_NS_RESIZE: + name = IDC_SIZENS; + break; + case SDL_SYSTEM_CURSOR_MOVE: + name = IDC_SIZEALL; + break; + case SDL_SYSTEM_CURSOR_NOT_ALLOWED: + name = IDC_NO; + break; + case SDL_SYSTEM_CURSOR_POINTER: + name = IDC_HAND; + break; + case SDL_SYSTEM_CURSOR_NW_RESIZE: + name = IDC_SIZENWSE; + break; + case SDL_SYSTEM_CURSOR_N_RESIZE: + name = IDC_SIZENS; + break; + case SDL_SYSTEM_CURSOR_NE_RESIZE: + name = IDC_SIZENESW; + break; + case SDL_SYSTEM_CURSOR_E_RESIZE: + name = IDC_SIZEWE; + break; + case SDL_SYSTEM_CURSOR_SE_RESIZE: + name = IDC_SIZENWSE; + break; + case SDL_SYSTEM_CURSOR_S_RESIZE: + name = IDC_SIZENS; + break; + case SDL_SYSTEM_CURSOR_SW_RESIZE: + name = IDC_SIZENESW; + break; + case SDL_SYSTEM_CURSOR_W_RESIZE: + name = IDC_SIZEWE; + break; + } + return WIN_CreateCursorAndData(LoadCursor(NULL, name)); +} + +static SDL_Cursor *WIN_CreateDefaultCursor(void) +{ + SDL_SystemCursor id = SDL_GetDefaultSystemCursor(); + return WIN_CreateSystemCursor(id); +} + +static void WIN_FreeCursor(SDL_Cursor *cursor) +{ + SDL_CursorData *data = cursor->internal; + + if (data->surface) { + SDL_DestroySurface(data->surface); + } + while (data->cache) { + CachedCursor *entry = data->cache; + data->cache = entry->next; + if (entry->cursor) { + DestroyCursor(entry->cursor); + } + SDL_free(entry); + } + if (data->cursor) { + DestroyCursor(data->cursor); + } + SDL_free(data); + SDL_free(cursor); +} + +static HCURSOR GetCachedCursor(SDL_Cursor *cursor) +{ + SDL_CursorData *data = cursor->internal; + + SDL_Window *focus = SDL_GetMouseFocus(); + if (!focus) { + return NULL; + } + + float scale = SDL_GetDisplayContentScale(SDL_GetDisplayForWindow(focus)); + for (CachedCursor *entry = data->cache; entry; entry = entry->next) { + if (scale == entry->scale) { + return entry->cursor; + } + } + + // Need to create a cursor for this content scale + SDL_Surface *surface = NULL; + HCURSOR hcursor = NULL; + CachedCursor *entry = NULL; + + surface = SDL_GetSurfaceImage(data->surface, scale); + if (!surface) { + goto error; + } + + int hot_x = (int)SDL_round(data->hot_x * scale); + int hot_y = (int)SDL_round(data->hot_y * scale); + hcursor = WIN_CreateHCursor(surface, hot_x, hot_y); + if (!hcursor) { + goto error; + } + + entry = (CachedCursor *)SDL_malloc(sizeof(*entry)); + if (!entry) { + goto error; + } + entry->cursor = hcursor; + entry->scale = scale; + entry->next = data->cache; + data->cache = entry; + + SDL_DestroySurface(surface); + + return hcursor; + +error: + if (surface) { + SDL_DestroySurface(surface); + } + if (hcursor) { + DestroyCursor(hcursor); + } + SDL_free(entry); + return NULL; +} + +static bool WIN_ShowCursor(SDL_Cursor *cursor) +{ + if (!cursor) { + cursor = SDL_blank_cursor; + } + if (cursor) { + if (cursor->internal->surface) { + SDL_cursor = GetCachedCursor(cursor); + } else { + SDL_cursor = cursor->internal->cursor; + } + } else { + SDL_cursor = NULL; + } + if (SDL_GetMouseFocus() != NULL) { + SetCursor(SDL_cursor); + } + return true; +} + +void WIN_SetCursorPos(int x, int y) +{ + // We need to jitter the value because otherwise Windows will occasionally inexplicably ignore the SetCursorPos() or SendInput() + SetCursorPos(x, y); + SetCursorPos(x + 1, y); + SetCursorPos(x, y); + + // Flush any mouse motion prior to or associated with this warp +#ifdef _MSC_VER // We explicitly want to use GetTickCount(), not GetTickCount64() +#pragma warning(push) +#pragma warning(disable : 28159) +#endif + SDL_last_warp_time = GetTickCount(); + if (!SDL_last_warp_time) { + SDL_last_warp_time = 1; + } +#ifdef _MSC_VER +#pragma warning(pop) +#endif +} + +static bool WIN_WarpMouse(SDL_Window *window, float x, float y) +{ + SDL_WindowData *data = window->internal; + HWND hwnd = data->hwnd; + POINT pt; + + // Don't warp the mouse while we're doing a modal interaction + if (data->in_title_click || data->focus_click_pending) { + return true; + } + + pt.x = (int)SDL_roundf(x); + pt.y = (int)SDL_roundf(y); + ClientToScreen(hwnd, &pt); + WIN_SetCursorPos(pt.x, pt.y); + + // Send the exact mouse motion associated with this warp + SDL_SendMouseMotion(0, window, SDL_GLOBAL_MOUSE_ID, false, x, y); + return true; +} + +static bool WIN_WarpMouseGlobal(float x, float y) +{ + POINT pt; + + pt.x = (int)SDL_roundf(x); + pt.y = (int)SDL_roundf(y); + SetCursorPos(pt.x, pt.y); + return true; +} + +static bool WIN_SetRelativeMouseMode(bool enabled) +{ + return WIN_SetRawMouseEnabled(SDL_GetVideoDevice(), enabled); +} + +static bool WIN_CaptureMouse(SDL_Window *window) +{ + if (window) { + SDL_WindowData *data = window->internal; + SetCapture(data->hwnd); + } else { + SDL_Window *focus_window = SDL_GetMouseFocus(); + + if (focus_window) { + SDL_WindowData *data = focus_window->internal; + if (!data->mouse_tracked) { + SDL_SetMouseFocus(NULL); + } + } + ReleaseCapture(); + } + + return true; +} + +static SDL_MouseButtonFlags WIN_GetGlobalMouseState(float *x, float *y) +{ + SDL_MouseButtonFlags result = 0; + POINT pt = { 0, 0 }; + bool swapButtons = GetSystemMetrics(SM_SWAPBUTTON) != 0; + + GetCursorPos(&pt); + *x = (float)pt.x; + *y = (float)pt.y; + + result |= GetAsyncKeyState(!swapButtons ? VK_LBUTTON : VK_RBUTTON) & 0x8000 ? SDL_BUTTON_LMASK : 0; + result |= GetAsyncKeyState(!swapButtons ? VK_RBUTTON : VK_LBUTTON) & 0x8000 ? SDL_BUTTON_RMASK : 0; + result |= GetAsyncKeyState(VK_MBUTTON) & 0x8000 ? SDL_BUTTON_MMASK : 0; + result |= GetAsyncKeyState(VK_XBUTTON1) & 0x8000 ? SDL_BUTTON_X1MASK : 0; + result |= GetAsyncKeyState(VK_XBUTTON2) & 0x8000 ? SDL_BUTTON_X2MASK : 0; + + return result; +} + +static void WIN_ApplySystemScale(void *internal, Uint64 timestamp, SDL_Window *window, SDL_MouseID mouseID, float *x, float *y) +{ + if (!internal) { + return; + } + WIN_MouseData *data = (WIN_MouseData *)internal; + + SDL_VideoDisplay *display = window ? SDL_GetVideoDisplayForWindow(window) : SDL_GetVideoDisplay(SDL_GetPrimaryDisplay()); + + Sint64 ix = (Sint64)*x * 65536; + Sint64 iy = (Sint64)*y * 65536; + Uint32 dpi = display ? (Uint32)(display->content_scale * USER_DEFAULT_SCREEN_DPI) : USER_DEFAULT_SCREEN_DPI; + + if (!data->enhanced) { // early return if flat scale + dpi = data->dpiscale * (data->dpiaware ? dpi : USER_DEFAULT_SCREEN_DPI); + ix *= dpi; + iy *= dpi; + ix /= USER_DEFAULT_SCREEN_DPI; + iy /= USER_DEFAULT_SCREEN_DPI; + ix /= 32; + iy /= 32; + // data->residual[0] += ix; + // data->residual[1] += iy; + // ix = 65536 * (data->residual[0] / 65536); + // iy = 65536 * (data->residual[1] / 65536); + // data->residual[0] -= ix; + // data->residual[1] -= iy; + *x = (float)ix / 65536.0f; + *y = (float)iy / 65536.0f; + return; + } + + Uint64 *xs = data->xs; + Uint64 *ys = data->ys; + Uint64 absx = SDL_abs(ix); + Uint64 absy = SDL_abs(iy); + Uint64 speed = SDL_min(absx, absy) + (SDL_max(absx, absy) << 1); // super cursed approximation used by Windows + if (speed == 0) { + return; + } + + int i, j, k; + for (i = 1; i < 5; i++) { + j = i; + if (speed < xs[j]) { + break; + } + } + i -= 1; + j -= 1; + k = data->last_node; + data->last_node = j; + + Uint32 denom = data->dpidenom; + Sint64 scale = 0; + Sint64 xdiff = xs[j+1] - xs[j]; + Sint64 ydiff = ys[j+1] - ys[j]; + if (xdiff != 0) { + Sint64 slope = ydiff / xdiff; + Sint64 inter = slope * xs[i] - ys[i]; + scale += slope - inter / speed; + } + + if (j > k) { + denom <<= 1; + xdiff = xs[k+1] - xs[k]; + ydiff = ys[k+1] - ys[k]; + if (xdiff != 0) { + Sint64 slope = ydiff / xdiff; + Sint64 inter = slope * xs[k] - ys[k]; + scale += slope - inter / speed; + } + } + + scale *= dpi; + ix *= scale; + iy *= scale; + ix /= denom; + iy /= denom; + // data->residual[0] += ix; + // data->residual[1] += iy; + // ix = 65536 * (data->residual[0] / 65536); + // iy = 65536 * (data->residual[1] / 65536); + // data->residual[0] -= ix; + // data->residual[1] -= iy; + *x = (float)ix / 65536.0f; + *y = (float)iy / 65536.0f; +} + +void WIN_InitMouse(SDL_VideoDevice *_this) +{ + SDL_Mouse *mouse = SDL_GetMouse(); + + mouse->CreateCursor = WIN_CreateCursor; + mouse->CreateSystemCursor = WIN_CreateSystemCursor; + mouse->ShowCursor = WIN_ShowCursor; + mouse->FreeCursor = WIN_FreeCursor; + mouse->WarpMouse = WIN_WarpMouse; + mouse->WarpMouseGlobal = WIN_WarpMouseGlobal; + mouse->SetRelativeMouseMode = WIN_SetRelativeMouseMode; + mouse->CaptureMouse = WIN_CaptureMouse; + mouse->GetGlobalMouseState = WIN_GetGlobalMouseState; + mouse->ApplySystemScale = WIN_ApplySystemScale; + mouse->system_scale_data = &WIN_system_scale_data; + + SDL_SetDefaultCursor(WIN_CreateDefaultCursor()); + + SDL_blank_cursor = WIN_CreateBlankCursor(); + + WIN_UpdateMouseSystemScale(); +} + +void WIN_QuitMouse(SDL_VideoDevice *_this) +{ + if (SDL_blank_cursor) { + WIN_FreeCursor(SDL_blank_cursor); + SDL_blank_cursor = NULL; + } +} + +static void ReadMouseCurve(int v, Uint64 xs[5], Uint64 ys[5]) +{ + bool win8 = WIN_IsWindows8OrGreater(); + DWORD xbuff[10] = { + 0x00000000, 0, + 0x00006e15, 0, + 0x00014000, 0, + 0x0003dc29, 0, + 0x00280000, 0 + }; + DWORD ybuff[10] = { + 0x00000000, 0, + win8 ? 0x000111fd : 0x00015eb8, 0, + win8 ? 0x00042400 : 0x00054ccd, 0, + win8 ? 0x0012fc00 : 0x00184ccd, 0, + win8 ? 0x01bbc000 : 0x02380000, 0 + }; + DWORD xsize = sizeof(xbuff); + DWORD ysize = sizeof(ybuff); + HKEY open_handle; + if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Control Panel\\Mouse", 0, KEY_READ, &open_handle) == ERROR_SUCCESS) { + RegQueryValueExW(open_handle, L"SmoothMouseXCurve", NULL, NULL, (BYTE*)xbuff, &xsize); + RegQueryValueExW(open_handle, L"SmoothMouseYCurve", NULL, NULL, (BYTE*)ybuff, &ysize); + RegCloseKey(open_handle); + } + xs[0] = 0; // first node must always be origin + ys[0] = 0; // first node must always be origin + int i; + for (i = 1; i < 5; i++) { + xs[i] = (7 * (Uint64)xbuff[i*2]); + ys[i] = (v * (Uint64)ybuff[i*2]) << 17; + } +} + +void WIN_UpdateMouseSystemScale(void) +{ + SDL_Mouse *mouse = SDL_GetMouse(); + + if (mouse->ApplySystemScale == WIN_ApplySystemScale) { + mouse->system_scale_data = &WIN_system_scale_data; + } + + // always reinitialize to valid defaults, whether fetch was successful or not. + WIN_MouseData *data = &WIN_system_scale_data; + data->residual[0] = 0; + data->residual[1] = 0; + data->dpiscale = 32; + data->dpidenom = (10 * (WIN_IsWindows8OrGreater() ? 120 : 150)) << 16; + data->dpiaware = WIN_IsPerMonitorV2DPIAware(SDL_GetVideoDevice()); + data->enhanced = false; + + int v = 10; + if (SystemParametersInfo(SPI_GETMOUSESPEED, 0, &v, 0)) { + v = SDL_max(1, SDL_min(v, 20)); + data->dpiscale = SDL_max(SDL_max(v, (v - 2) * 4), (v - 6) * 8); + } + + int params[3]; + if (SystemParametersInfo(SPI_GETMOUSE, 0, ¶ms, 0)) { + data->enhanced = params[2] ? true : false; + if (params[2]) { + ReadMouseCurve(v, data->xs, data->ys); + } + } +} + +#endif // SDL_VIDEO_DRIVER_WINDOWS -- cgit v1.2.3