/* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2017 - Daniel De Matteis * * RetroArch is free software: you can redistribute it and/or modify it under the terms * of the GNU General Public License as published by the Free Software Found- * ation, either version 3 of the License, or (at your option) any later version. * * RetroArch 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 General Public License for more details. * * You should have received a copy of the GNU General Public License along with RetroArch. * If not, see . */ #include #include #include #include #include #include #ifdef HAVE_CONFIG_H #include "../../config.h" #endif #ifdef HAVE_XINERAMA #include #endif #include "x11_common.h" #include #include #include "dbus_common.h" #include "../../frontend/frontend_driver.h" #include "../../input/input_driver.h" #include "../../input/input_keymaps.h" #include "../../input/common/input_x11_common.h" #include "../../verbosity.h" #define _NET_WM_STATE_ADD 1 #define MOVERESIZE_GRAVITY_CENTER 5 #define MOVERESIZE_X_SHIFT 8 #define MOVERESIZE_Y_SHIFT 9 static XF86VidModeModeInfo desktop_mode; static bool xdg_screensaver_available = true; bool g_x11_entered = false; static bool g_x11_has_focus = false; static bool g_x11_true_full = false; Display *g_x11_dpy = NULL; unsigned g_x11_screen = 0; Colormap g_x11_cmap; Window g_x11_win; static Atom XA_NET_WM_STATE; static Atom XA_NET_WM_STATE_FULLSCREEN; static Atom XA_NET_MOVERESIZE_WINDOW; static Atom g_x11_quit_atom; static XIM g_x11_xim; static XIC g_x11_xic; static void x11_hide_mouse(Display *dpy, Window win) { static char bm_no_data[] = {0, 0, 0, 0, 0, 0, 0, 0}; Cursor no_ptr; Pixmap bm_no; XColor black, dummy; Colormap colormap = DefaultColormap(dpy, DefaultScreen(dpy)); if (!XAllocNamedColor(dpy, colormap, "black", &black, &dummy)) return; bm_no = XCreateBitmapFromData(dpy, win, bm_no_data, 8, 8); no_ptr = XCreatePixmapCursor(dpy, bm_no, bm_no, &black, &black, 0, 0); XDefineCursor(dpy, win, no_ptr); XFreeCursor(dpy, no_ptr); if (bm_no != None) XFreePixmap(dpy, bm_no); XFreeColors(dpy, colormap, &black.pixel, 1, 0); } void x11_show_mouse(Display *dpy, Window win, bool state) { if (state) XUndefineCursor(dpy, win); else x11_hide_mouse(dpy, win); } void x11_windowed_fullscreen(Display *dpy, Window win) { XEvent xev = {0}; XA_NET_WM_STATE = XInternAtom(dpy, "_NET_WM_STATE", False); XA_NET_WM_STATE_FULLSCREEN = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False); xev.xclient.type = ClientMessage; xev.xclient.send_event = True; xev.xclient.message_type = XA_NET_WM_STATE; xev.xclient.window = win; xev.xclient.format = 32; xev.xclient.data.l[0] = _NET_WM_STATE_ADD; xev.xclient.data.l[1] = XA_NET_WM_STATE_FULLSCREEN; XSendEvent(dpy, DefaultRootWindow(dpy), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev); } /* Try to be nice to tiling WMs if possible. */ void x11_move_window(Display *dpy, Window win, int x, int y, unsigned width, unsigned height) { XEvent xev = {0}; XA_NET_MOVERESIZE_WINDOW = XInternAtom(dpy, "_NET_MOVERESIZE_WINDOW", False); xev.xclient.type = ClientMessage; xev.xclient.send_event = True; xev.xclient.message_type = XA_NET_MOVERESIZE_WINDOW; xev.xclient.window = win; xev.xclient.format = 32; xev.xclient.data.l[0] = (1 << MOVERESIZE_X_SHIFT) | (1 << MOVERESIZE_Y_SHIFT); xev.xclient.data.l[1] = x; xev.xclient.data.l[2] = y; XSendEvent(dpy, DefaultRootWindow(dpy), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev); } static void x11_set_window_class(Display *dpy, Window win) { XClassHint hint; hint.res_name = (char*)"retroarch"; /* Broken header. */ hint.res_class = (char*)"retroarch"; XSetClassHint(dpy, win, &hint); } void x11_set_window_attr(Display *dpy, Window win) { x11_set_window_class(dpy, win); } static void xdg_screensaver_inhibit(Window wnd) { int ret; char cmd[64]; cmd[0] = '\0'; RARCH_LOG("[X11]: Suspending screensaver (X11, xdg-screensaver).\n"); snprintf(cmd, sizeof(cmd), "xdg-screensaver suspend 0x%x", (int)wnd); ret = system(cmd); if (ret == -1) { xdg_screensaver_available = false; RARCH_WARN("Failed to launch xdg-screensaver.\n"); } else if (WEXITSTATUS(ret)) { xdg_screensaver_available = false; RARCH_WARN("Could not suspend screen saver.\n"); } } void x11_suspend_screensaver_xdg_screensaver(Window wnd, bool enable) { /* Check if screensaver suspend is enabled in config */ if (!enable) return; if (xdg_screensaver_available) xdg_screensaver_inhibit(wnd); } void x11_suspend_screensaver(Window wnd, bool enable) { #ifdef HAVE_DBUS if (dbus_suspend_screensaver(enable)) return; #endif x11_suspend_screensaver_xdg_screensaver(wnd, enable); } static bool get_video_mode(video_frame_info_t *video_info, Display *dpy, unsigned width, unsigned height, XF86VidModeModeInfo *mode, XF86VidModeModeInfo *desktop_mode) { float refresh_mod; int i, num_modes = 0; bool ret = false; float minimum_fps_diff = 0.0f; XF86VidModeModeInfo **modes = NULL; XF86VidModeGetAllModeLines(dpy, DefaultScreen(dpy), &num_modes, &modes); if (!num_modes) { XFree(modes); return false; } *desktop_mode = *modes[0]; /* If we use black frame insertion, we fake a 60 Hz monitor * for 120 Hz one, etc, so try to match that. */ refresh_mod = video_info->black_frame_insertion ? 0.5f : 1.0f; for (i = 0; i < num_modes; i++) { float refresh, diff; const XF86VidModeModeInfo *m = modes[i]; if (!m) continue; if (m->hdisplay != width) continue; if (m->vdisplay != height) continue; refresh = refresh_mod * m->dotclock * 1000.0f / (m->htotal * m->vtotal); diff = fabsf(refresh - video_info->refresh_rate); if (!ret || diff < minimum_fps_diff) { *mode = *m; minimum_fps_diff = diff; } ret = true; } XFree(modes); return ret; } bool x11_enter_fullscreen(video_frame_info_t *video_info, Display *dpy, unsigned width, unsigned height) { XF86VidModeModeInfo mode; if (!get_video_mode(video_info, dpy, width, height, &mode, &desktop_mode)) return false; if (!XF86VidModeSwitchToMode(dpy, DefaultScreen(dpy), &mode)) return false; XF86VidModeSetViewPort(dpy, DefaultScreen(dpy), 0, 0); return true; } void x11_exit_fullscreen(Display *dpy) { XF86VidModeSwitchToMode(dpy, DefaultScreen(dpy), &desktop_mode); XF86VidModeSetViewPort(dpy, DefaultScreen(dpy), 0, 0); } bool x11_create_input_context(Display *dpy, Window win, XIM *xim, XIC *xic) { x11_destroy_input_context(xim, xic); g_x11_has_focus = true; *xim = XOpenIM(dpy, NULL, NULL, NULL); if (!*xim) { RARCH_ERR("[X11]: Failed to open input method.\n"); return false; } *xic = XCreateIC(*xim, XNInputStyle, XIMPreeditNothing | XIMStatusNothing, XNClientWindow, win, NULL); if (!*xic) { RARCH_ERR("[X11]: Failed to create input context.\n"); return false; } XSetICFocus(*xic); return true; } void x11_destroy_input_context(XIM *xim, XIC *xic) { if (*xic) { XDestroyIC(*xic); *xic = NULL; } if (*xim) { XCloseIM(*xim); *xim = NULL; } } bool x11_get_metrics(void *data, enum display_metric_types type, float *value) { unsigned screen_no = 0; Display *dpy = (Display*)XOpenDisplay(NULL); int pixels_x = DisplayWidth(dpy, screen_no); int pixels_y = DisplayHeight(dpy, screen_no); int physical_width = DisplayWidthMM(dpy, screen_no); int physical_height = DisplayHeightMM(dpy, screen_no); (void)pixels_y; XCloseDisplay(dpy); switch (type) { case DISPLAY_METRIC_MM_WIDTH: *value = (float)physical_width; break; case DISPLAY_METRIC_MM_HEIGHT: *value = (float)physical_height; break; case DISPLAY_METRIC_DPI: *value = ((((float)pixels_x) * 25.4) / ((float)physical_width)); break; case DISPLAY_METRIC_NONE: default: *value = 0; return false; } return true; } static void x11_handle_key_event(XEvent *event, XIC ic, bool filter) { int i; unsigned key; uint32_t chars[32]; uint16_t mod = 0; unsigned state = event->xkey.state; bool down = event->type == KeyPress; int num = 0; KeySym keysym = 0; chars[0] = '\0'; if (!filter) { if (down) { char keybuf[32]; keybuf[0] = '\0'; #ifdef X_HAVE_UTF8_STRING Status status = 0; /* XwcLookupString doesn't seem to work. */ num = Xutf8LookupString(ic, &event->xkey, keybuf, ARRAY_SIZE(keybuf), &keysym, &status); /* libc functions need UTF-8 locale to work properly, * which makes mbrtowc a bit impractical. * * Use custom UTF8 -> UTF-32 conversion. */ num = utf8_conv_utf32(chars, ARRAY_SIZE(chars), keybuf, num); #else (void)ic; num = XLookupString(&event->xkey, keybuf, sizeof(keybuf), &keysym, NULL); /* ASCII only. */ for (i = 0; i < num; i++) chars[i] = keybuf[i] & 0x7f; #endif } else keysym = XLookupKeysym(&event->xkey, (state & ShiftMask) || (state & LockMask)); } /* We can't feed uppercase letters to the keycode translator. Seems like a bad idea * to feed it keysyms anyway, so here is a little hack... */ if (keysym >= XK_A && keysym <= XK_Z) keysym += XK_z - XK_Z; key = input_keymaps_translate_keysym_to_rk(keysym); if (state & ShiftMask) mod |= RETROKMOD_SHIFT; if (state & LockMask) mod |= RETROKMOD_CAPSLOCK; if (state & ControlMask) mod |= RETROKMOD_CTRL; if (state & Mod1Mask) mod |= RETROKMOD_ALT; if (state & Mod4Mask) mod |= RETROKMOD_META; if (IsKeypadKey(keysym)) mod |= RETROKMOD_NUMLOCK; input_keyboard_event(down, key, chars[0], mod, RETRO_DEVICE_KEYBOARD); for (i = 1; i < num; i++) input_keyboard_event(down, RETROK_UNKNOWN, chars[i], mod, RETRO_DEVICE_KEYBOARD); } bool x11_alive(void *data) { while (XPending(g_x11_dpy)) { XEvent event; bool filter = false; /* Can get events from older windows. Check this. */ XNextEvent(g_x11_dpy, &event); filter = XFilterEvent(&event, g_x11_win); switch (event.type) { case ClientMessage: if (event.xclient.window == g_x11_win && (Atom)event.xclient.data.l[0] == g_x11_quit_atom) frontend_driver_set_signal_handler_state(1); break; case DestroyNotify: if (event.xdestroywindow.window == g_x11_win) frontend_driver_set_signal_handler_state(1); break; case MapNotify: if (event.xmap.window == g_x11_win) g_x11_has_focus = true; break; case UnmapNotify: if (event.xunmap.window == g_x11_win) g_x11_has_focus = false; break; case ButtonPress: switch (event.xbutton.button) { case 1: /* Left click */ #if 0 RARCH_LOG("Click occurred : [%d, %d]\n", event.xbutton.x_root, event.xbutton.y_root); #endif break; case 2: /* Grabbed */ /* Middle click */ break; case 3: /* Right click */ break; case 4: /* Grabbed */ /* Scroll up */ case 5: /* Scroll down */ x_input_poll_wheel(&event.xbutton, true); break; } break; case EnterNotify: g_x11_entered = true; break; case LeaveNotify: g_x11_entered = false; break; case ButtonRelease: break; case KeyPress: case KeyRelease: if (event.xkey.window == g_x11_win) x11_handle_key_event(&event, g_x11_xic, filter); break; } } return !((bool)frontend_driver_get_signal_handler_state()); } void x11_check_window(void *data, bool *quit, bool *resize, unsigned *width, unsigned *height, bool is_shutdown) { unsigned new_width = *width; unsigned new_height = *height; x11_get_video_size(data, &new_width, &new_height); if (new_width != *width || new_height != *height) { *resize = true; *width = new_width; *height = new_height; } x11_alive(data); *quit = (bool)frontend_driver_get_signal_handler_state(); } void x11_get_video_size(void *data, unsigned *width, unsigned *height) { if (!g_x11_dpy || g_x11_win == None) { Display *dpy = (Display*)XOpenDisplay(NULL); *width = 0; *height = 0; if (dpy) { int screen = DefaultScreen(dpy); *width = DisplayWidth(dpy, screen); *height = DisplayHeight(dpy, screen); XCloseDisplay(dpy); } } else { XWindowAttributes target; XGetWindowAttributes(g_x11_dpy, g_x11_win, &target); *width = target.width; *height = target.height; } } bool x11_has_focus_internal(void *data) { return g_x11_has_focus; } bool x11_has_focus(void *data) { Window win; int rev; XGetInputFocus(g_x11_dpy, &win, &rev); return (win == g_x11_win && g_x11_has_focus) || g_x11_true_full; } bool x11_connect(void) { frontend_driver_destroy_signal_handler_state(); /* Keep one g_x11_dpy alive the entire process lifetime. * This is necessary for nVidia's EGL implementation for now. */ if (!g_x11_dpy) { g_x11_dpy = XOpenDisplay(NULL); if (!g_x11_dpy) return false; } dbus_ensure_connection(); return true; } void x11_update_title(void *data, void *data2) { char title[128]; title[0] = '\0'; video_driver_get_window_title(title, sizeof(title)); if (title[0]) XStoreName(g_x11_dpy, g_x11_win, title); } bool x11_input_ctx_new(bool true_full) { if (!x11_create_input_context(g_x11_dpy, g_x11_win, &g_x11_xim, &g_x11_xic)) return false; video_driver_display_type_set(RARCH_DISPLAY_X11); video_driver_display_set((uintptr_t)g_x11_dpy); video_driver_window_set((uintptr_t)g_x11_win); g_x11_true_full = true_full; return true; } void x11_input_ctx_destroy(void) { x11_destroy_input_context(&g_x11_xim, &g_x11_xic); } void x11_window_destroy(bool fullscreen) { if (g_x11_win) XUnmapWindow(g_x11_dpy, g_x11_win); if (!fullscreen) XDestroyWindow(g_x11_dpy, g_x11_win); g_x11_win = None; #ifdef HAVE_DBUS dbus_screensaver_uninhibit(); dbus_close_connection(); #endif } void x11_colormap_destroy(void) { if (!g_x11_cmap) return; XFreeColormap(g_x11_dpy, g_x11_cmap); g_x11_cmap = None; } void x11_install_quit_atom(void) { g_x11_quit_atom = XInternAtom(g_x11_dpy, "WM_DELETE_WINDOW", False); if (g_x11_quit_atom) XSetWMProtocols(g_x11_dpy, g_x11_win, &g_x11_quit_atom, 1); } static Bool x11_wait_notify(Display *d, XEvent *e, char *arg) { return e->type == MapNotify && e->xmap.window == g_x11_win; } void x11_event_queue_check(XEvent *event) { XIfEvent(g_x11_dpy, event, x11_wait_notify, NULL); }