diff options
Diffstat (limited to 'source/3rd-party/SDL2/src/video/x11/SDL_x11mouse.c')
| -rw-r--r-- | source/3rd-party/SDL2/src/video/x11/SDL_x11mouse.c | 448 |
1 files changed, 448 insertions, 0 deletions
diff --git a/source/3rd-party/SDL2/src/video/x11/SDL_x11mouse.c b/source/3rd-party/SDL2/src/video/x11/SDL_x11mouse.c new file mode 100644 index 0000000..3b98726 --- /dev/null +++ b/source/3rd-party/SDL2/src/video/x11/SDL_x11mouse.c @@ -0,0 +1,448 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 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" + +#if SDL_VIDEO_DRIVER_X11 + +#include <X11/cursorfont.h> +#include "SDL_assert.h" +#include "SDL_x11video.h" +#include "SDL_x11mouse.h" +#include "SDL_x11xinput2.h" +#include "../../events/SDL_mouse_c.h" + + +/* FIXME: Find a better place to put this... */ +static Cursor x11_empty_cursor = None; + +static Display * +GetDisplay(void) +{ + return ((SDL_VideoData *)SDL_GetVideoDevice()->driverdata)->display; +} + +static Cursor +X11_CreateEmptyCursor() +{ + if (x11_empty_cursor == None) { + Display *display = GetDisplay(); + char data[1]; + XColor color; + Pixmap pixmap; + + SDL_zero(data); + color.red = color.green = color.blue = 0; + pixmap = X11_XCreateBitmapFromData(display, DefaultRootWindow(display), + data, 1, 1); + if (pixmap) { + x11_empty_cursor = X11_XCreatePixmapCursor(display, pixmap, pixmap, + &color, &color, 0, 0); + X11_XFreePixmap(display, pixmap); + } + } + return x11_empty_cursor; +} + +static void +X11_DestroyEmptyCursor(void) +{ + if (x11_empty_cursor != None) { + X11_XFreeCursor(GetDisplay(), x11_empty_cursor); + x11_empty_cursor = None; + } +} + +static SDL_Cursor * +X11_CreateDefaultCursor() +{ + SDL_Cursor *cursor; + + cursor = SDL_calloc(1, sizeof(*cursor)); + if (cursor) { + /* None is used to indicate the default cursor */ + cursor->driverdata = (void*)None; + } else { + SDL_OutOfMemory(); + } + + return cursor; +} + +#if SDL_VIDEO_DRIVER_X11_XCURSOR +static Cursor +X11_CreateXCursorCursor(SDL_Surface * surface, int hot_x, int hot_y) +{ + Display *display = GetDisplay(); + Cursor cursor = None; + XcursorImage *image; + + image = X11_XcursorImageCreate(surface->w, surface->h); + if (!image) { + SDL_OutOfMemory(); + return None; + } + image->xhot = hot_x; + image->yhot = hot_y; + image->delay = 0; + + SDL_assert(surface->format->format == SDL_PIXELFORMAT_ARGB8888); + SDL_assert(surface->pitch == surface->w * 4); + SDL_memcpy(image->pixels, surface->pixels, surface->h * surface->pitch); + + cursor = X11_XcursorImageLoadCursor(display, image); + + X11_XcursorImageDestroy(image); + + return cursor; +} +#endif /* SDL_VIDEO_DRIVER_X11_XCURSOR */ + +static Cursor +X11_CreatePixmapCursor(SDL_Surface * surface, int hot_x, int hot_y) +{ + Display *display = GetDisplay(); + XColor fg, bg; + Cursor cursor = None; + Uint32 *ptr; + Uint8 *data_bits, *mask_bits; + Pixmap data_pixmap, mask_pixmap; + int x, y; + unsigned int rfg, gfg, bfg, rbg, gbg, bbg, fgBits, bgBits; + unsigned int width_bytes = ((surface->w + 7) & ~7) / 8; + + data_bits = SDL_calloc(1, surface->h * width_bytes); + if (!data_bits) { + SDL_OutOfMemory(); + return None; + } + + mask_bits = SDL_calloc(1, surface->h * width_bytes); + if (!mask_bits) { + SDL_free(data_bits); + SDL_OutOfMemory(); + return None; + } + + /* Code below assumes ARGB pixel format */ + SDL_assert(surface->format->format == SDL_PIXELFORMAT_ARGB8888); + + rfg = gfg = bfg = rbg = gbg = bbg = fgBits = bgBits = 0; + for (y = 0; y < surface->h; ++y) { + ptr = (Uint32 *)((Uint8 *)surface->pixels + y * surface->pitch); + for (x = 0; x < surface->w; ++x) { + int alpha = (*ptr >> 24) & 0xff; + int red = (*ptr >> 16) & 0xff; + int green = (*ptr >> 8) & 0xff; + int blue = (*ptr >> 0) & 0xff; + if (alpha > 25) { + mask_bits[y * width_bytes + x / 8] |= (0x01 << (x % 8)); + + if ((red + green + blue) > 0x40) { + fgBits++; + rfg += red; + gfg += green; + bfg += blue; + data_bits[y * width_bytes + x / 8] |= (0x01 << (x % 8)); + } else { + bgBits++; + rbg += red; + gbg += green; + bbg += blue; + } + } + ++ptr; + } + } + + if (fgBits) { + fg.red = rfg * 257 / fgBits; + fg.green = gfg * 257 / fgBits; + fg.blue = bfg * 257 / fgBits; + } + else fg.red = fg.green = fg.blue = 0; + + if (bgBits) { + bg.red = rbg * 257 / bgBits; + bg.green = gbg * 257 / bgBits; + bg.blue = bbg * 257 / bgBits; + } + else bg.red = bg.green = bg.blue = 0; + + data_pixmap = X11_XCreateBitmapFromData(display, DefaultRootWindow(display), + (char*)data_bits, + surface->w, surface->h); + mask_pixmap = X11_XCreateBitmapFromData(display, DefaultRootWindow(display), + (char*)mask_bits, + surface->w, surface->h); + cursor = X11_XCreatePixmapCursor(display, data_pixmap, mask_pixmap, + &fg, &bg, hot_x, hot_y); + X11_XFreePixmap(display, data_pixmap); + X11_XFreePixmap(display, mask_pixmap); + + return cursor; +} + +static SDL_Cursor * +X11_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y) +{ + SDL_Cursor *cursor; + + cursor = SDL_calloc(1, sizeof(*cursor)); + if (cursor) { + Cursor x11_cursor = None; + +#if SDL_VIDEO_DRIVER_X11_XCURSOR + if (SDL_X11_HAVE_XCURSOR) { + x11_cursor = X11_CreateXCursorCursor(surface, hot_x, hot_y); + } +#endif + if (x11_cursor == None) { + x11_cursor = X11_CreatePixmapCursor(surface, hot_x, hot_y); + } + cursor->driverdata = (void*)x11_cursor; + } else { + SDL_OutOfMemory(); + } + + return cursor; +} + +static SDL_Cursor * +X11_CreateSystemCursor(SDL_SystemCursor id) +{ + SDL_Cursor *cursor; + unsigned int shape; + + switch(id) + { + default: + SDL_assert(0); + return NULL; + /* X Font Cursors reference: */ + /* http://tronche.com/gui/x/xlib/appendix/b/ */ + case SDL_SYSTEM_CURSOR_ARROW: shape = XC_left_ptr; break; + case SDL_SYSTEM_CURSOR_IBEAM: shape = XC_xterm; break; + case SDL_SYSTEM_CURSOR_WAIT: shape = XC_watch; break; + case SDL_SYSTEM_CURSOR_CROSSHAIR: shape = XC_tcross; break; + case SDL_SYSTEM_CURSOR_WAITARROW: shape = XC_watch; break; + case SDL_SYSTEM_CURSOR_SIZENWSE: shape = XC_fleur; break; + case SDL_SYSTEM_CURSOR_SIZENESW: shape = XC_fleur; break; + case SDL_SYSTEM_CURSOR_SIZEWE: shape = XC_sb_h_double_arrow; break; + case SDL_SYSTEM_CURSOR_SIZENS: shape = XC_sb_v_double_arrow; break; + case SDL_SYSTEM_CURSOR_SIZEALL: shape = XC_fleur; break; + case SDL_SYSTEM_CURSOR_NO: shape = XC_pirate; break; + case SDL_SYSTEM_CURSOR_HAND: shape = XC_hand2; break; + } + + cursor = SDL_calloc(1, sizeof(*cursor)); + if (cursor) { + Cursor x11_cursor; + + x11_cursor = X11_XCreateFontCursor(GetDisplay(), shape); + + cursor->driverdata = (void*)x11_cursor; + } else { + SDL_OutOfMemory(); + } + + return cursor; +} + +static void +X11_FreeCursor(SDL_Cursor * cursor) +{ + Cursor x11_cursor = (Cursor)cursor->driverdata; + + if (x11_cursor != None) { + X11_XFreeCursor(GetDisplay(), x11_cursor); + } + SDL_free(cursor); +} + +static int +X11_ShowCursor(SDL_Cursor * cursor) +{ + Cursor x11_cursor = 0; + + if (cursor) { + x11_cursor = (Cursor)cursor->driverdata; + } else { + x11_cursor = X11_CreateEmptyCursor(); + } + + /* FIXME: Is there a better way than this? */ + { + SDL_VideoDevice *video = SDL_GetVideoDevice(); + Display *display = GetDisplay(); + SDL_Window *window; + SDL_WindowData *data; + + for (window = video->windows; window; window = window->next) { + data = (SDL_WindowData *)window->driverdata; + if (x11_cursor != None) { + X11_XDefineCursor(display, data->xwindow, x11_cursor); + } else { + X11_XUndefineCursor(display, data->xwindow); + } + } + X11_XFlush(display); + } + return 0; +} + +static void +WarpMouseInternal(Window xwindow, const int x, const int y) +{ + SDL_VideoData *videodata = (SDL_VideoData *) SDL_GetVideoDevice()->driverdata; + Display *display = videodata->display; + X11_XWarpPointer(display, None, xwindow, 0, 0, 0, 0, x, y); + X11_XSync(display, False); + videodata->global_mouse_changed = SDL_TRUE; +} + +static void +X11_WarpMouse(SDL_Window * window, int x, int y) +{ + SDL_WindowData *data = (SDL_WindowData *) window->driverdata; + WarpMouseInternal(data->xwindow, x, y); +} + +static int +X11_WarpMouseGlobal(int x, int y) +{ + WarpMouseInternal(DefaultRootWindow(GetDisplay()), x, y); + return 0; +} + +static int +X11_SetRelativeMouseMode(SDL_bool enabled) +{ +#if SDL_VIDEO_DRIVER_X11_XINPUT2 + if(X11_Xinput2IsInitialized()) + return 0; +#else + SDL_Unsupported(); +#endif + return -1; +} + +static int +X11_CaptureMouse(SDL_Window *window) +{ + Display *display = GetDisplay(); + + if (window) { + SDL_WindowData *data = (SDL_WindowData *) window->driverdata; + const unsigned int mask = ButtonPressMask | ButtonReleaseMask | PointerMotionMask | FocusChangeMask; + const int rc = X11_XGrabPointer(display, data->xwindow, False, + mask, GrabModeAsync, GrabModeAsync, + None, None, CurrentTime); + if (rc != GrabSuccess) { + return SDL_SetError("X server refused mouse capture"); + } + } else { + X11_XUngrabPointer(display, CurrentTime); + } + + X11_XSync(display, False); + + return 0; +} + +static Uint32 +X11_GetGlobalMouseState(int *x, int *y) +{ + SDL_VideoData *videodata = (SDL_VideoData *) SDL_GetVideoDevice()->driverdata; + Display *display = GetDisplay(); + const int num_screens = SDL_GetNumVideoDisplays(); + int i; + + /* !!! FIXME: should we XSync() here first? */ + +#if !SDL_VIDEO_DRIVER_X11_XINPUT2 + videodata->global_mouse_changed = SDL_TRUE; +#endif + + /* check if we have this cached since XInput last saw the mouse move. */ + /* !!! FIXME: can we just calculate this from XInput's events? */ + if (videodata->global_mouse_changed) { + for (i = 0; i < num_screens; i++) { + SDL_DisplayData *data = (SDL_DisplayData *) SDL_GetDisplayDriverData(i); + if (data != NULL) { + Window root, child; + int rootx, rooty, winx, winy; + unsigned int mask; + if (X11_XQueryPointer(display, RootWindow(display, data->screen), &root, &child, &rootx, &rooty, &winx, &winy, &mask)) { + XWindowAttributes root_attrs; + Uint32 buttons = 0; + buttons |= (mask & Button1Mask) ? SDL_BUTTON_LMASK : 0; + buttons |= (mask & Button2Mask) ? SDL_BUTTON_MMASK : 0; + buttons |= (mask & Button3Mask) ? SDL_BUTTON_RMASK : 0; + /* SDL_DisplayData->x,y point to screen origin, and adding them to mouse coordinates relative to root window doesn't do the right thing + * (observed on dual monitor setup with primary display being the rightmost one - mouse was offset to the right). + * + * Adding root position to root-relative coordinates seems to be a better way to get absolute position. */ + X11_XGetWindowAttributes(display, root, &root_attrs); + videodata->global_mouse_position.x = root_attrs.x + rootx; + videodata->global_mouse_position.y = root_attrs.y + rooty; + videodata->global_mouse_buttons = buttons; + videodata->global_mouse_changed = SDL_FALSE; + break; + } + } + } + } + + SDL_assert(!videodata->global_mouse_changed); /* The pointer wasn't on any X11 screen?! */ + + *x = videodata->global_mouse_position.x; + *y = videodata->global_mouse_position.y; + return videodata->global_mouse_buttons; +} + + +void +X11_InitMouse(_THIS) +{ + SDL_Mouse *mouse = SDL_GetMouse(); + + mouse->CreateCursor = X11_CreateCursor; + mouse->CreateSystemCursor = X11_CreateSystemCursor; + mouse->ShowCursor = X11_ShowCursor; + mouse->FreeCursor = X11_FreeCursor; + mouse->WarpMouse = X11_WarpMouse; + mouse->WarpMouseGlobal = X11_WarpMouseGlobal; + mouse->SetRelativeMouseMode = X11_SetRelativeMouseMode; + mouse->CaptureMouse = X11_CaptureMouse; + mouse->GetGlobalMouseState = X11_GetGlobalMouseState; + + SDL_SetDefaultCursor(X11_CreateDefaultCursor()); +} + +void +X11_QuitMouse(_THIS) +{ + X11_DestroyEmptyCursor(); +} + +#endif /* SDL_VIDEO_DRIVER_X11 */ + +/* vi: set ts=4 sw=4 expandtab: */ |