|
|
@@ -0,0 +1,3216 @@
|
|
|
+/*************************************************************************/
|
|
|
+/* display_server_x11.cpp */
|
|
|
+/*************************************************************************/
|
|
|
+/* This file is part of: */
|
|
|
+/* GODOT ENGINE */
|
|
|
+/* https://godotengine.org */
|
|
|
+/*************************************************************************/
|
|
|
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
|
|
|
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
|
|
|
+/* */
|
|
|
+/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
|
+/* a copy of this software and associated documentation files (the */
|
|
|
+/* "Software"), to deal in the Software without restriction, including */
|
|
|
+/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
|
+/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
|
+/* permit persons to whom the Software is furnished to do so, subject to */
|
|
|
+/* the following conditions: */
|
|
|
+/* */
|
|
|
+/* The above copyright notice and this permission notice shall be */
|
|
|
+/* included in all copies or substantial portions of the Software. */
|
|
|
+/* */
|
|
|
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
|
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
|
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
|
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
|
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
|
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
|
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
|
+/*************************************************************************/
|
|
|
+
|
|
|
+#include "display_server_x11.h"
|
|
|
+
|
|
|
+#ifdef X11_ENABLED
|
|
|
+
|
|
|
+#include "detect_prime.h"
|
|
|
+
|
|
|
+#include "core/os/dir_access.h"
|
|
|
+#include "core/print_string.h"
|
|
|
+#include "errno.h"
|
|
|
+#include "key_mapping_x11.h"
|
|
|
+
|
|
|
+#if defined(OPENGL_ENABLED)
|
|
|
+#include "drivers/gles2/rasterizer_gles2.h"
|
|
|
+#endif
|
|
|
+
|
|
|
+#if defined(VULKAN_ENABLED)
|
|
|
+#include "servers/visual/rasterizer_rd/rasterizer_rd.h"
|
|
|
+#endif
|
|
|
+
|
|
|
+#include "servers/visual/visual_server_raster.h"
|
|
|
+#include "servers/visual/visual_server_wrap_mt.h"
|
|
|
+
|
|
|
+#ifdef HAVE_MNTENT
|
|
|
+#include <mntent.h>
|
|
|
+#endif
|
|
|
+
|
|
|
+#include <stdio.h>
|
|
|
+#include <stdlib.h>
|
|
|
+#include <string.h>
|
|
|
+
|
|
|
+#include "X11/Xutil.h"
|
|
|
+
|
|
|
+#include "X11/Xatom.h"
|
|
|
+#include "X11/extensions/Xinerama.h"
|
|
|
+// ICCCM
|
|
|
+#define WM_NormalState 1L // window normal state
|
|
|
+#define WM_IconicState 3L // window minimized
|
|
|
+// EWMH
|
|
|
+#define _NET_WM_STATE_REMOVE 0L // remove/unset property
|
|
|
+#define _NET_WM_STATE_ADD 1L // add/set property
|
|
|
+#define _NET_WM_STATE_TOGGLE 2L // toggle property
|
|
|
+
|
|
|
+#include "main/main.h"
|
|
|
+
|
|
|
+#include <dlfcn.h>
|
|
|
+#include <fcntl.h>
|
|
|
+#include <sys/stat.h>
|
|
|
+#include <sys/types.h>
|
|
|
+#include <unistd.h>
|
|
|
+
|
|
|
+//stupid linux.h
|
|
|
+#ifdef KEY_TAB
|
|
|
+#undef KEY_TAB
|
|
|
+#endif
|
|
|
+
|
|
|
+#include <X11/Xatom.h>
|
|
|
+
|
|
|
+#undef CursorShape
|
|
|
+
|
|
|
+#include <X11/XKBlib.h>
|
|
|
+
|
|
|
+// 2.2 is the first release with multitouch
|
|
|
+#define XINPUT_CLIENT_VERSION_MAJOR 2
|
|
|
+#define XINPUT_CLIENT_VERSION_MINOR 2
|
|
|
+
|
|
|
+#define VALUATOR_ABSX 0
|
|
|
+#define VALUATOR_ABSY 1
|
|
|
+#define VALUATOR_PRESSURE 2
|
|
|
+#define VALUATOR_TILTX 3
|
|
|
+#define VALUATOR_TILTY 4
|
|
|
+
|
|
|
+static const double abs_resolution_mult = 10000.0;
|
|
|
+static const double abs_resolution_range_mult = 10.0;
|
|
|
+
|
|
|
+bool DisplayServerX11::has_feature(Feature p_feature) const {
|
|
|
+ switch (p_feature) {
|
|
|
+ case FEATURE_SUBWINDOWS:
|
|
|
+#ifdef TOUCH_ENABLED
|
|
|
+ case FEATURE_TOUCHSCREEN:
|
|
|
+#endif
|
|
|
+ case FEATURE_MOUSE:
|
|
|
+ case FEATURE_MOUSE_WARP:
|
|
|
+ case FEATURE_CLIPBOARD:
|
|
|
+ case FEATURE_CURSOR_SHAPE:
|
|
|
+ case FEATURE_CUSTOM_CURSOR_SHAPE:
|
|
|
+ case FEATURE_IME:
|
|
|
+ case FEATURE_WINDOW_TRANSPARENCY:
|
|
|
+ //case FEATURE_HIDPI:
|
|
|
+ case FEATURE_ICON:
|
|
|
+ case FEATURE_NATIVE_ICON:
|
|
|
+ case FEATURE_SWAP_BUFFERS:
|
|
|
+ return true;
|
|
|
+ default: {
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+}
|
|
|
+String DisplayServerX11::get_name() const {
|
|
|
+ return "X11";
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::alert(const String &p_alert, const String &p_title) {
|
|
|
+ const char *message_programs[] = { "zenity", "kdialog", "Xdialog", "xmessage" };
|
|
|
+
|
|
|
+ String path = OS::get_singleton()->get_environment("PATH");
|
|
|
+ Vector<String> path_elems = path.split(":", false);
|
|
|
+ String program;
|
|
|
+
|
|
|
+ for (int i = 0; i < path_elems.size(); i++) {
|
|
|
+ for (uint64_t k = 0; k < sizeof(message_programs) / sizeof(char *); k++) {
|
|
|
+ String tested_path = path_elems[i].plus_file(message_programs[k]);
|
|
|
+
|
|
|
+ if (FileAccess::exists(tested_path)) {
|
|
|
+ program = tested_path;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (program.length())
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ List<String> args;
|
|
|
+
|
|
|
+ if (program.ends_with("zenity")) {
|
|
|
+ args.push_back("--error");
|
|
|
+ args.push_back("--width");
|
|
|
+ args.push_back("500");
|
|
|
+ args.push_back("--title");
|
|
|
+ args.push_back(p_title);
|
|
|
+ args.push_back("--text");
|
|
|
+ args.push_back(p_alert);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (program.ends_with("kdialog")) {
|
|
|
+ args.push_back("--error");
|
|
|
+ args.push_back(p_alert);
|
|
|
+ args.push_back("--title");
|
|
|
+ args.push_back(p_title);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (program.ends_with("Xdialog")) {
|
|
|
+ args.push_back("--title");
|
|
|
+ args.push_back(p_title);
|
|
|
+ args.push_back("--msgbox");
|
|
|
+ args.push_back(p_alert);
|
|
|
+ args.push_back("0");
|
|
|
+ args.push_back("0");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (program.ends_with("xmessage")) {
|
|
|
+ args.push_back("-center");
|
|
|
+ args.push_back("-title");
|
|
|
+ args.push_back(p_title);
|
|
|
+ args.push_back(p_alert);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (program.length()) {
|
|
|
+ OS::get_singleton()->execute(program, args, true);
|
|
|
+ } else {
|
|
|
+ print_line(p_alert);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::_update_real_mouse_position(const WindowData &wd) {
|
|
|
+ Window root_return, child_return;
|
|
|
+ int root_x, root_y, win_x, win_y;
|
|
|
+ unsigned int mask_return;
|
|
|
+
|
|
|
+ Bool xquerypointer_result = XQueryPointer(x11_display, wd.x11_window, &root_return, &child_return, &root_x, &root_y,
|
|
|
+ &win_x, &win_y, &mask_return);
|
|
|
+
|
|
|
+ if (xquerypointer_result) {
|
|
|
+ if (win_x > 0 && win_y > 0 && win_x <= wd.size.width && win_y <= wd.size.height) {
|
|
|
+
|
|
|
+ last_mouse_pos.x = win_x;
|
|
|
+ last_mouse_pos.y = win_y;
|
|
|
+ last_mouse_pos_valid = true;
|
|
|
+ Input::get_singleton()->set_mouse_position(last_mouse_pos);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+bool DisplayServerX11::_refresh_device_info() {
|
|
|
+ int event_base, error_base;
|
|
|
+
|
|
|
+ print_verbose("XInput: Refreshing devices.");
|
|
|
+
|
|
|
+ if (!XQueryExtension(x11_display, "XInputExtension", &xi.opcode, &event_base, &error_base)) {
|
|
|
+ print_verbose("XInput extension not available. Please upgrade your distribution.");
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ int xi_major_query = XINPUT_CLIENT_VERSION_MAJOR;
|
|
|
+ int xi_minor_query = XINPUT_CLIENT_VERSION_MINOR;
|
|
|
+
|
|
|
+ if (XIQueryVersion(x11_display, &xi_major_query, &xi_minor_query) != Success) {
|
|
|
+ print_verbose(vformat("XInput 2 not available (server supports %d.%d).", xi_major_query, xi_minor_query));
|
|
|
+ xi.opcode = 0;
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (xi_major_query < XINPUT_CLIENT_VERSION_MAJOR || (xi_major_query == XINPUT_CLIENT_VERSION_MAJOR && xi_minor_query < XINPUT_CLIENT_VERSION_MINOR)) {
|
|
|
+ print_verbose(vformat("XInput %d.%d not available (server supports %d.%d). Touch input unavailable.",
|
|
|
+ XINPUT_CLIENT_VERSION_MAJOR, XINPUT_CLIENT_VERSION_MINOR, xi_major_query, xi_minor_query));
|
|
|
+ }
|
|
|
+
|
|
|
+ xi.absolute_devices.clear();
|
|
|
+ xi.touch_devices.clear();
|
|
|
+
|
|
|
+ int dev_count;
|
|
|
+ XIDeviceInfo *info = XIQueryDevice(x11_display, XIAllDevices, &dev_count);
|
|
|
+
|
|
|
+ for (int i = 0; i < dev_count; i++) {
|
|
|
+ XIDeviceInfo *dev = &info[i];
|
|
|
+ if (!dev->enabled)
|
|
|
+ continue;
|
|
|
+ if (!(dev->use == XIMasterPointer || dev->use == XIFloatingSlave))
|
|
|
+ continue;
|
|
|
+
|
|
|
+ bool direct_touch = false;
|
|
|
+ bool absolute_mode = false;
|
|
|
+ int resolution_x = 0;
|
|
|
+ int resolution_y = 0;
|
|
|
+ int range_min_x = 0;
|
|
|
+ int range_min_y = 0;
|
|
|
+ int range_max_x = 0;
|
|
|
+ int range_max_y = 0;
|
|
|
+ int pressure_resolution = 0;
|
|
|
+ int tilt_resolution_x = 0;
|
|
|
+ int tilt_resolution_y = 0;
|
|
|
+ for (int j = 0; j < dev->num_classes; j++) {
|
|
|
+#ifdef TOUCH_ENABLED
|
|
|
+ if (dev->classes[j]->type == XITouchClass && ((XITouchClassInfo *)dev->classes[j])->mode == XIDirectTouch) {
|
|
|
+ direct_touch = true;
|
|
|
+ }
|
|
|
+#endif
|
|
|
+ if (dev->classes[j]->type == XIValuatorClass) {
|
|
|
+ XIValuatorClassInfo *class_info = (XIValuatorClassInfo *)dev->classes[j];
|
|
|
+
|
|
|
+ if (class_info->number == VALUATOR_ABSX && class_info->mode == XIModeAbsolute) {
|
|
|
+ resolution_x = class_info->resolution;
|
|
|
+ range_min_x = class_info->min;
|
|
|
+ range_max_x = class_info->max;
|
|
|
+ absolute_mode = true;
|
|
|
+ } else if (class_info->number == VALUATOR_ABSY && class_info->mode == XIModeAbsolute) {
|
|
|
+ resolution_y = class_info->resolution;
|
|
|
+ range_min_y = class_info->min;
|
|
|
+ range_max_y = class_info->max;
|
|
|
+ absolute_mode = true;
|
|
|
+ } else if (class_info->number == VALUATOR_PRESSURE && class_info->mode == XIModeAbsolute) {
|
|
|
+ pressure_resolution = (class_info->max - class_info->min);
|
|
|
+ if (pressure_resolution == 0) pressure_resolution = 1;
|
|
|
+ } else if (class_info->number == VALUATOR_TILTX && class_info->mode == XIModeAbsolute) {
|
|
|
+ tilt_resolution_x = (class_info->max - class_info->min);
|
|
|
+ if (tilt_resolution_x == 0) tilt_resolution_x = 1;
|
|
|
+ } else if (class_info->number == VALUATOR_TILTY && class_info->mode == XIModeAbsolute) {
|
|
|
+ tilt_resolution_y = (class_info->max - class_info->min);
|
|
|
+ if (tilt_resolution_y == 0) tilt_resolution_y = 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (direct_touch) {
|
|
|
+ xi.touch_devices.push_back(dev->deviceid);
|
|
|
+ print_verbose("XInput: Using touch device: " + String(dev->name));
|
|
|
+ }
|
|
|
+ if (absolute_mode) {
|
|
|
+ // If no resolution was reported, use the min/max ranges.
|
|
|
+ if (resolution_x <= 0) {
|
|
|
+ resolution_x = (range_max_x - range_min_x) * abs_resolution_range_mult;
|
|
|
+ }
|
|
|
+ if (resolution_y <= 0) {
|
|
|
+ resolution_y = (range_max_y - range_min_y) * abs_resolution_range_mult;
|
|
|
+ }
|
|
|
+
|
|
|
+ xi.absolute_devices[dev->deviceid] = Vector2(abs_resolution_mult / resolution_x, abs_resolution_mult / resolution_y);
|
|
|
+ print_verbose("XInput: Absolute pointing device: " + String(dev->name));
|
|
|
+ }
|
|
|
+
|
|
|
+ xi.pressure = 0;
|
|
|
+ xi.pen_devices[dev->deviceid] = Vector3(pressure_resolution, tilt_resolution_x, tilt_resolution_y);
|
|
|
+ }
|
|
|
+
|
|
|
+ XIFreeDeviceInfo(info);
|
|
|
+#ifdef TOUCH_ENABLED
|
|
|
+ if (!xi.touch_devices.size()) {
|
|
|
+ print_verbose("XInput: No touch devices found.");
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::_flush_mouse_motion() {
|
|
|
+ while (true) {
|
|
|
+ if (XPending(x11_display) > 0) {
|
|
|
+ XEvent event;
|
|
|
+ XPeekEvent(x11_display, &event);
|
|
|
+
|
|
|
+ if (XGetEventData(x11_display, &event.xcookie) && event.xcookie.type == GenericEvent && event.xcookie.extension == xi.opcode) {
|
|
|
+ XIDeviceEvent *event_data = (XIDeviceEvent *)event.xcookie.data;
|
|
|
+
|
|
|
+ if (event_data->evtype == XI_RawMotion) {
|
|
|
+ XNextEvent(x11_display, &event);
|
|
|
+ } else {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ xi.relative_motion.x = 0;
|
|
|
+ xi.relative_motion.y = 0;
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::mouse_set_mode(MouseMode p_mode) {
|
|
|
+ if (p_mode == mouse_mode)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (mouse_mode == MOUSE_MODE_CAPTURED || mouse_mode == MOUSE_MODE_CONFINED)
|
|
|
+ XUngrabPointer(x11_display, CurrentTime);
|
|
|
+
|
|
|
+ // The only modes that show a cursor are VISIBLE and CONFINED
|
|
|
+ bool showCursor = (p_mode == MOUSE_MODE_VISIBLE || p_mode == MOUSE_MODE_CONFINED);
|
|
|
+
|
|
|
+ for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
|
|
|
+
|
|
|
+ if (showCursor) {
|
|
|
+ XDefineCursor(x11_display, E->get().x11_window, cursors[current_cursor]); // show cursor
|
|
|
+ } else {
|
|
|
+ XDefineCursor(x11_display, E->get().x11_window, null_cursor); // hide cursor
|
|
|
+ }
|
|
|
+ }
|
|
|
+ mouse_mode = p_mode;
|
|
|
+
|
|
|
+ if (mouse_mode == MOUSE_MODE_CAPTURED || mouse_mode == MOUSE_MODE_CONFINED) {
|
|
|
+
|
|
|
+ //flush pending motion events
|
|
|
+ _flush_mouse_motion();
|
|
|
+ WindowData &main_window = windows[MAIN_WINDOW_ID];
|
|
|
+
|
|
|
+ if (XGrabPointer(
|
|
|
+ x11_display, main_window.x11_window, True,
|
|
|
+ ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
|
|
|
+ GrabModeAsync, GrabModeAsync, windows[MAIN_WINDOW_ID].x11_window, None, CurrentTime) != GrabSuccess) {
|
|
|
+ ERR_PRINT("NO GRAB");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (mouse_mode == MOUSE_MODE_CAPTURED) {
|
|
|
+ center.x = main_window.size.width / 2;
|
|
|
+ center.y = main_window.size.height / 2;
|
|
|
+
|
|
|
+ XWarpPointer(x11_display, None, main_window.x11_window,
|
|
|
+ 0, 0, 0, 0, (int)center.x, (int)center.y);
|
|
|
+
|
|
|
+ Input::get_singleton()->set_mouse_position(center);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ do_mouse_warp = false;
|
|
|
+ }
|
|
|
+
|
|
|
+ XFlush(x11_display);
|
|
|
+}
|
|
|
+DisplayServerX11::MouseMode DisplayServerX11::mouse_get_mode() const {
|
|
|
+ return mouse_mode;
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::mouse_warp_to_position(const Point2i &p_to) {
|
|
|
+ if (mouse_mode == MOUSE_MODE_CAPTURED) {
|
|
|
+
|
|
|
+ last_mouse_pos = p_to;
|
|
|
+ } else {
|
|
|
+
|
|
|
+ /*XWindowAttributes xwa;
|
|
|
+ XGetWindowAttributes(x11_display, x11_window, &xwa);
|
|
|
+ printf("%d %d\n", xwa.x, xwa.y); needed? */
|
|
|
+
|
|
|
+ XWarpPointer(x11_display, None, windows[MAIN_WINDOW_ID].x11_window,
|
|
|
+ 0, 0, 0, 0, (int)p_to.x, (int)p_to.y);
|
|
|
+ }
|
|
|
+}
|
|
|
+Point2i DisplayServerX11::mouse_get_position() const {
|
|
|
+ return last_mouse_pos;
|
|
|
+}
|
|
|
+int DisplayServerX11::mouse_get_button_state() const {
|
|
|
+ return last_button_state;
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::clipboard_set(const String &p_text) {
|
|
|
+
|
|
|
+ internal_clipboard = p_text;
|
|
|
+ XSetSelectionOwner(x11_display, XA_PRIMARY, windows[MAIN_WINDOW_ID].x11_window, CurrentTime);
|
|
|
+ XSetSelectionOwner(x11_display, XInternAtom(x11_display, "CLIPBOARD", 0), windows[MAIN_WINDOW_ID].x11_window, CurrentTime);
|
|
|
+}
|
|
|
+
|
|
|
+static String _clipboard_get_impl(Atom p_source, Window x11_window, ::Display *x11_display, String p_internal_clipboard, Atom target) {
|
|
|
+
|
|
|
+ String ret;
|
|
|
+
|
|
|
+ Atom type;
|
|
|
+ Atom selection = XA_PRIMARY;
|
|
|
+ int format, result;
|
|
|
+ unsigned long len, bytes_left, dummy;
|
|
|
+ unsigned char *data;
|
|
|
+ Window Sown = XGetSelectionOwner(x11_display, p_source);
|
|
|
+
|
|
|
+ if (Sown == x11_window) {
|
|
|
+
|
|
|
+ return p_internal_clipboard;
|
|
|
+ };
|
|
|
+
|
|
|
+ if (Sown != None) {
|
|
|
+ XConvertSelection(x11_display, p_source, target, selection,
|
|
|
+ x11_window, CurrentTime);
|
|
|
+ XFlush(x11_display);
|
|
|
+ while (true) {
|
|
|
+ XEvent event;
|
|
|
+ XNextEvent(x11_display, &event);
|
|
|
+ if (event.type == SelectionNotify && event.xselection.requestor == x11_window) {
|
|
|
+ break;
|
|
|
+ };
|
|
|
+ };
|
|
|
+
|
|
|
+ //
|
|
|
+ // Do not get any data, see how much data is there
|
|
|
+ //
|
|
|
+ XGetWindowProperty(x11_display, x11_window,
|
|
|
+ selection, // Tricky..
|
|
|
+ 0, 0, // offset - len
|
|
|
+ 0, // Delete 0==FALSE
|
|
|
+ AnyPropertyType, //flag
|
|
|
+ &type, // return type
|
|
|
+ &format, // return format
|
|
|
+ &len, &bytes_left, //that
|
|
|
+ &data);
|
|
|
+ // DATA is There
|
|
|
+ if (bytes_left > 0) {
|
|
|
+ result = XGetWindowProperty(x11_display, x11_window,
|
|
|
+ selection, 0, bytes_left, 0,
|
|
|
+ AnyPropertyType, &type, &format,
|
|
|
+ &len, &dummy, &data);
|
|
|
+ if (result == Success) {
|
|
|
+ ret.parse_utf8((const char *)data);
|
|
|
+ } else
|
|
|
+ printf("FAIL\n");
|
|
|
+ XFree(data);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+static String _clipboard_get(Atom p_source, Window x11_window, ::Display *x11_display, String p_internal_clipboard) {
|
|
|
+ String ret;
|
|
|
+ Atom utf8_atom = XInternAtom(x11_display, "UTF8_STRING", True);
|
|
|
+ if (utf8_atom != None) {
|
|
|
+ ret = _clipboard_get_impl(p_source, x11_window, x11_display, p_internal_clipboard, utf8_atom);
|
|
|
+ }
|
|
|
+ if (ret == "") {
|
|
|
+ ret = _clipboard_get_impl(p_source, x11_window, x11_display, p_internal_clipboard, XA_STRING);
|
|
|
+ }
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+String DisplayServerX11::clipboard_get() const {
|
|
|
+
|
|
|
+ String ret;
|
|
|
+ ret = _clipboard_get(XInternAtom(x11_display, "CLIPBOARD", 0), windows[MAIN_WINDOW_ID].x11_window, x11_display, internal_clipboard);
|
|
|
+
|
|
|
+ if (ret == "") {
|
|
|
+ ret = _clipboard_get(XA_PRIMARY, windows[MAIN_WINDOW_ID].x11_window, x11_display, internal_clipboard);
|
|
|
+ };
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+int DisplayServerX11::get_screen_count() const {
|
|
|
+ // Using Xinerama Extension
|
|
|
+ int event_base, error_base;
|
|
|
+ const Bool ext_okay = XineramaQueryExtension(x11_display, &event_base, &error_base);
|
|
|
+ if (!ext_okay) return 0;
|
|
|
+
|
|
|
+ int count;
|
|
|
+ XineramaScreenInfo *xsi = XineramaQueryScreens(x11_display, &count);
|
|
|
+ XFree(xsi);
|
|
|
+ return count;
|
|
|
+}
|
|
|
+Point2i DisplayServerX11::screen_get_position(int p_screen) const {
|
|
|
+ if (p_screen == SCREEN_OF_MAIN_WINDOW) {
|
|
|
+ p_screen = window_get_current_screen();
|
|
|
+ }
|
|
|
+
|
|
|
+ // Using Xinerama Extension
|
|
|
+ int event_base, error_base;
|
|
|
+ const Bool ext_okay = XineramaQueryExtension(x11_display, &event_base, &error_base);
|
|
|
+ if (!ext_okay) {
|
|
|
+ return Point2i(0, 0);
|
|
|
+ }
|
|
|
+
|
|
|
+ int count;
|
|
|
+ XineramaScreenInfo *xsi = XineramaQueryScreens(x11_display, &count);
|
|
|
+ if (p_screen >= count) {
|
|
|
+ return Point2i(0, 0);
|
|
|
+ }
|
|
|
+
|
|
|
+ Point2i position = Point2i(xsi[p_screen].x_org, xsi[p_screen].y_org);
|
|
|
+
|
|
|
+ XFree(xsi);
|
|
|
+
|
|
|
+ return position;
|
|
|
+}
|
|
|
+Size2i DisplayServerX11::screen_get_size(int p_screen) const {
|
|
|
+
|
|
|
+ if (p_screen == SCREEN_OF_MAIN_WINDOW) {
|
|
|
+ p_screen = window_get_current_screen();
|
|
|
+ }
|
|
|
+
|
|
|
+ // Using Xinerama Extension
|
|
|
+ int event_base, error_base;
|
|
|
+ const Bool ext_okay = XineramaQueryExtension(x11_display, &event_base, &error_base);
|
|
|
+ if (!ext_okay) return Size2i(0, 0);
|
|
|
+
|
|
|
+ int count;
|
|
|
+ XineramaScreenInfo *xsi = XineramaQueryScreens(x11_display, &count);
|
|
|
+ if (p_screen >= count) return Size2i(0, 0);
|
|
|
+
|
|
|
+ Size2i size = Point2i(xsi[p_screen].width, xsi[p_screen].height);
|
|
|
+ XFree(xsi);
|
|
|
+ return size;
|
|
|
+}
|
|
|
+int DisplayServerX11::screen_get_dpi(int p_screen) const {
|
|
|
+ if (p_screen == SCREEN_OF_MAIN_WINDOW) {
|
|
|
+ p_screen = window_get_current_screen();
|
|
|
+ }
|
|
|
+
|
|
|
+ //invalid screen?
|
|
|
+ ERR_FAIL_INDEX_V(p_screen, get_screen_count(), 0);
|
|
|
+
|
|
|
+ //Get physical monitor Dimensions through XRandR and calculate dpi
|
|
|
+ Size2i sc = screen_get_size(p_screen);
|
|
|
+ if (xrandr_ext_ok) {
|
|
|
+ int count = 0;
|
|
|
+ if (xrr_get_monitors) {
|
|
|
+ xrr_monitor_info *monitors = xrr_get_monitors(x11_display, windows[MAIN_WINDOW_ID].x11_window, true, &count);
|
|
|
+ if (p_screen < count) {
|
|
|
+ double xdpi = sc.width / (double)monitors[p_screen].mwidth * 25.4;
|
|
|
+ double ydpi = sc.height / (double)monitors[p_screen].mheight * 25.4;
|
|
|
+ xrr_free_monitors(monitors);
|
|
|
+ return (xdpi + ydpi) / 2;
|
|
|
+ }
|
|
|
+ xrr_free_monitors(monitors);
|
|
|
+ } else if (p_screen == 0) {
|
|
|
+ XRRScreenSize *sizes = XRRSizes(x11_display, 0, &count);
|
|
|
+ if (sizes) {
|
|
|
+ double xdpi = sc.width / (double)sizes[0].mwidth * 25.4;
|
|
|
+ double ydpi = sc.height / (double)sizes[0].mheight * 25.4;
|
|
|
+ return (xdpi + ydpi) / 2;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ int width_mm = DisplayWidthMM(x11_display, p_screen);
|
|
|
+ int height_mm = DisplayHeightMM(x11_display, p_screen);
|
|
|
+ double xdpi = (width_mm ? sc.width / (double)width_mm * 25.4 : 0);
|
|
|
+ double ydpi = (height_mm ? sc.height / (double)height_mm * 25.4 : 0);
|
|
|
+ if (xdpi || ydpi)
|
|
|
+ return (xdpi + ydpi) / (xdpi && ydpi ? 2 : 1);
|
|
|
+
|
|
|
+ //could not get dpi
|
|
|
+ return 96;
|
|
|
+}
|
|
|
+bool DisplayServerX11::screen_is_touchscreen(int p_screen) const {
|
|
|
+#ifndef _MSC_VER
|
|
|
+#warning Need to get from proper window
|
|
|
+#endif
|
|
|
+ return false; //?
|
|
|
+}
|
|
|
+
|
|
|
+Vector<DisplayServer::WindowID> DisplayServerX11::get_window_list() const {
|
|
|
+ Vector<int> ret;
|
|
|
+ for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
|
|
|
+ ret.push_back(E->key());
|
|
|
+ }
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+DisplayServer::WindowID DisplayServerX11::create_sub_window(WindowMode p_mode, uint32_t p_flags, const Rect2i &p_rect) {
|
|
|
+
|
|
|
+ WindowID id = _create_window(p_mode, p_rect.size);
|
|
|
+ window_set_position(p_rect.position, id);
|
|
|
+ for (int i = 0; i < WINDOW_FLAG_MAX; i++) {
|
|
|
+ if (p_flags & (1 << i)) {
|
|
|
+ window_set_flag(WindowFlags(i), true, id);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return id;
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::delete_sub_window(WindowID p_id) {
|
|
|
+ ERR_FAIL_COND(windows.has(p_id));
|
|
|
+ ERR_FAIL_COND_MSG(p_id == MAIN_WINDOW_ID, "Main window can't be deleted"); //ma
|
|
|
+
|
|
|
+ WindowData &wd = windows[p_id];
|
|
|
+
|
|
|
+ XUnmapWindow(x11_display, wd.x11_window);
|
|
|
+ XDestroyWindow(x11_display, wd.x11_window);
|
|
|
+ if (wd.xic) {
|
|
|
+ XDestroyIC(wd.xic);
|
|
|
+ }
|
|
|
+
|
|
|
+ windows.erase(p_id);
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::window_set_title(const String &p_title, WindowID p_window) {
|
|
|
+
|
|
|
+ ERR_FAIL_COND(windows.has(p_window));
|
|
|
+ WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ XStoreName(x11_display, wd.x11_window, p_title.utf8().get_data());
|
|
|
+
|
|
|
+ Atom _net_wm_name = XInternAtom(x11_display, "_NET_WM_NAME", false);
|
|
|
+ Atom utf8_string = XInternAtom(x11_display, "UTF8_STRING", false);
|
|
|
+ XChangeProperty(x11_display, wd.x11_window, _net_wm_name, utf8_string, 8, PropModeReplace, (unsigned char *)p_title.utf8().get_data(), p_title.utf8().length());
|
|
|
+}
|
|
|
+
|
|
|
+int DisplayServerX11::window_get_current_screen(WindowID p_window) const {
|
|
|
+ ERR_FAIL_COND_V(windows.has(p_window), -1);
|
|
|
+ const WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ int x, y;
|
|
|
+ Window child;
|
|
|
+ XTranslateCoordinates(x11_display, wd.x11_window, DefaultRootWindow(x11_display), 0, 0, &x, &y, &child);
|
|
|
+
|
|
|
+ int count = get_screen_count();
|
|
|
+ for (int i = 0; i < count; i++) {
|
|
|
+ Point2i pos = screen_get_position(i);
|
|
|
+ Size2i size = screen_get_size(i);
|
|
|
+ if ((x >= pos.x && x < pos.x + size.width) && (y >= pos.y && y < pos.y + size.height))
|
|
|
+ return i;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+void DisplayServerX11::window_set_current_screen(int p_screen, WindowID p_window) {
|
|
|
+ ERR_FAIL_COND(windows.has(p_window));
|
|
|
+ WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ int count = get_screen_count();
|
|
|
+ if (p_screen >= count) return;
|
|
|
+
|
|
|
+ if (window_get_mode(p_window) == WINDOW_MODE_FULLSCREEN) {
|
|
|
+ Point2i position = screen_get_position(p_screen);
|
|
|
+ Size2i size = screen_get_size(p_screen);
|
|
|
+
|
|
|
+ XMoveResizeWindow(x11_display, wd.x11_window, position.x, position.y, size.x, size.y);
|
|
|
+ } else {
|
|
|
+ if (p_screen != window_get_current_screen(p_window)) {
|
|
|
+ Point2i position = screen_get_position(p_screen);
|
|
|
+ XMoveWindow(x11_display, wd.x11_window, position.x, position.y);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+Point2i DisplayServerX11::window_get_position(WindowID p_window) const {
|
|
|
+ ERR_FAIL_COND_V(windows.has(p_window), Point2i());
|
|
|
+ const WindowData &wd = windows[p_window];
|
|
|
+ int x, y;
|
|
|
+ Window child;
|
|
|
+ XTranslateCoordinates(x11_display, wd.x11_window, DefaultRootWindow(x11_display), 0, 0, &x, &y, &child);
|
|
|
+ return Point2i(x, y);
|
|
|
+}
|
|
|
+void DisplayServerX11::window_set_position(const Point2i &p_position, WindowID p_window) {
|
|
|
+ ERR_FAIL_COND(windows.has(p_window));
|
|
|
+ WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ int x = 0;
|
|
|
+ int y = 0;
|
|
|
+ if (!window_get_flag(WINDOW_FLAG_BORDERLESS, p_window)) {
|
|
|
+ //exclude window decorations
|
|
|
+ XSync(x11_display, False);
|
|
|
+ Atom prop = XInternAtom(x11_display, "_NET_FRAME_EXTENTS", True);
|
|
|
+ if (prop != None) {
|
|
|
+ Atom type;
|
|
|
+ int format;
|
|
|
+ unsigned long len;
|
|
|
+ unsigned long remaining;
|
|
|
+ unsigned char *data = NULL;
|
|
|
+ if (XGetWindowProperty(x11_display, wd.x11_window, prop, 0, 4, False, AnyPropertyType, &type, &format, &len, &remaining, &data) == Success) {
|
|
|
+ if (format == 32 && len == 4) {
|
|
|
+ long *extents = (long *)data;
|
|
|
+ x = extents[0];
|
|
|
+ y = extents[2];
|
|
|
+ }
|
|
|
+ XFree(data);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ XMoveWindow(x11_display, wd.x11_window, p_position.x - x, p_position.y - y);
|
|
|
+ _update_real_mouse_position(wd);
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::window_set_max_size(const Size2i p_size, WindowID p_window) {
|
|
|
+ ERR_FAIL_COND(windows.has(p_window));
|
|
|
+ WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ if ((p_size != Size2i()) && ((p_size.x < wd.min_size.x) || (p_size.y < wd.min_size.y))) {
|
|
|
+ ERR_PRINT("Maximum window size can't be smaller than minimum window size!");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ wd.max_size = p_size;
|
|
|
+
|
|
|
+ if (!window_get_flag(WINDOW_FLAG_RESIZE_DISABLED, p_window)) {
|
|
|
+ XSizeHints *xsh;
|
|
|
+ xsh = XAllocSizeHints();
|
|
|
+ xsh->flags = 0L;
|
|
|
+ if (wd.min_size != Size2i()) {
|
|
|
+ xsh->flags |= PMinSize;
|
|
|
+ xsh->min_width = wd.min_size.x;
|
|
|
+ xsh->min_height = wd.min_size.y;
|
|
|
+ }
|
|
|
+ if (wd.max_size != Size2i()) {
|
|
|
+ xsh->flags |= PMaxSize;
|
|
|
+ xsh->max_width = wd.max_size.x;
|
|
|
+ xsh->max_height = wd.max_size.y;
|
|
|
+ }
|
|
|
+ XSetWMNormalHints(x11_display, wd.x11_window, xsh);
|
|
|
+ XFree(xsh);
|
|
|
+
|
|
|
+ XFlush(x11_display);
|
|
|
+ }
|
|
|
+}
|
|
|
+Size2i DisplayServerX11::window_get_max_size(WindowID p_window) const {
|
|
|
+ ERR_FAIL_COND_V(windows.has(p_window), Size2i());
|
|
|
+ const WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ return wd.max_size;
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::window_set_min_size(const Size2i p_size, WindowID p_window) {
|
|
|
+ ERR_FAIL_COND(windows.has(p_window));
|
|
|
+ WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ if ((p_size != Size2i()) && (wd.max_size != Size2i()) && ((p_size.x > wd.max_size.x) || (p_size.y > wd.max_size.y))) {
|
|
|
+ ERR_PRINT("Minimum window size can't be larger than maximum window size!");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ wd.min_size = p_size;
|
|
|
+
|
|
|
+ if (!window_get_flag(WINDOW_FLAG_RESIZE_DISABLED, p_window)) {
|
|
|
+ XSizeHints *xsh;
|
|
|
+ xsh = XAllocSizeHints();
|
|
|
+ xsh->flags = 0L;
|
|
|
+ if (wd.min_size != Size2i()) {
|
|
|
+ xsh->flags |= PMinSize;
|
|
|
+ xsh->min_width = wd.min_size.x;
|
|
|
+ xsh->min_height = wd.min_size.y;
|
|
|
+ }
|
|
|
+ if (wd.max_size != Size2i()) {
|
|
|
+ xsh->flags |= PMaxSize;
|
|
|
+ xsh->max_width = wd.max_size.x;
|
|
|
+ xsh->max_height = wd.max_size.y;
|
|
|
+ }
|
|
|
+ XSetWMNormalHints(x11_display, wd.x11_window, xsh);
|
|
|
+ XFree(xsh);
|
|
|
+
|
|
|
+ XFlush(x11_display);
|
|
|
+ }
|
|
|
+}
|
|
|
+Size2i DisplayServerX11::window_get_min_size(WindowID p_window) const {
|
|
|
+ ERR_FAIL_COND_V(windows.has(p_window), Size2i());
|
|
|
+ const WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ return wd.min_size;
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::window_set_size(const Size2i p_size, WindowID p_window) {
|
|
|
+ ERR_FAIL_COND(windows.has(p_window));
|
|
|
+ WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ if (wd.size.width == p_size.width && wd.size.height == p_size.height)
|
|
|
+ return;
|
|
|
+
|
|
|
+ XWindowAttributes xwa;
|
|
|
+ XSync(x11_display, False);
|
|
|
+ XGetWindowAttributes(x11_display, wd.x11_window, &xwa);
|
|
|
+ int old_w = xwa.width;
|
|
|
+ int old_h = xwa.height;
|
|
|
+
|
|
|
+ // If window resizable is disabled we need to update the attributes first
|
|
|
+ XSizeHints *xsh;
|
|
|
+ xsh = XAllocSizeHints();
|
|
|
+ if (!window_get_flag(WINDOW_FLAG_RESIZE_DISABLED, p_window)) {
|
|
|
+ xsh->flags = PMinSize | PMaxSize;
|
|
|
+ xsh->min_width = p_size.x;
|
|
|
+ xsh->max_width = p_size.x;
|
|
|
+ xsh->min_height = p_size.y;
|
|
|
+ xsh->max_height = p_size.y;
|
|
|
+ } else {
|
|
|
+ xsh->flags = 0L;
|
|
|
+ if (wd.min_size != Size2i()) {
|
|
|
+ xsh->flags |= PMinSize;
|
|
|
+ xsh->min_width = wd.min_size.x;
|
|
|
+ xsh->min_height = wd.min_size.y;
|
|
|
+ }
|
|
|
+ if (wd.max_size != Size2i()) {
|
|
|
+ xsh->flags |= PMaxSize;
|
|
|
+ xsh->max_width = wd.max_size.x;
|
|
|
+ xsh->max_height = wd.max_size.y;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ XSetWMNormalHints(x11_display, wd.x11_window, xsh);
|
|
|
+ XFree(xsh);
|
|
|
+
|
|
|
+ // Resize the window
|
|
|
+ XResizeWindow(x11_display, wd.x11_window, p_size.x, p_size.y);
|
|
|
+
|
|
|
+ // Update our videomode width and height
|
|
|
+ wd.size = p_size;
|
|
|
+
|
|
|
+ for (int timeout = 0; timeout < 50; ++timeout) {
|
|
|
+ XSync(x11_display, False);
|
|
|
+ XGetWindowAttributes(x11_display, wd.x11_window, &xwa);
|
|
|
+
|
|
|
+ if (old_w != xwa.width || old_h != xwa.height)
|
|
|
+ break;
|
|
|
+
|
|
|
+ usleep(10000);
|
|
|
+ }
|
|
|
+}
|
|
|
+Size2i DisplayServerX11::window_get_size(WindowID p_window) const {
|
|
|
+ ERR_FAIL_COND_V(windows.has(p_window), Size2i());
|
|
|
+ const WindowData &wd = windows[p_window];
|
|
|
+ return wd.size;
|
|
|
+}
|
|
|
+Size2i DisplayServerX11::window_get_real_size(WindowID p_window) const {
|
|
|
+ ERR_FAIL_COND_V(windows.has(p_window), Size2i());
|
|
|
+ const WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ XWindowAttributes xwa;
|
|
|
+ XSync(x11_display, False);
|
|
|
+ XGetWindowAttributes(x11_display, wd.x11_window, &xwa);
|
|
|
+ int w = xwa.width;
|
|
|
+ int h = xwa.height;
|
|
|
+ Atom prop = XInternAtom(x11_display, "_NET_FRAME_EXTENTS", True);
|
|
|
+ if (prop != None) {
|
|
|
+ Atom type;
|
|
|
+ int format;
|
|
|
+ unsigned long len;
|
|
|
+ unsigned long remaining;
|
|
|
+ unsigned char *data = NULL;
|
|
|
+ if (XGetWindowProperty(x11_display, wd.x11_window, prop, 0, 4, False, AnyPropertyType, &type, &format, &len, &remaining, &data) == Success) {
|
|
|
+ if (format == 32 && len == 4) {
|
|
|
+ long *extents = (long *)data;
|
|
|
+ w += extents[0] + extents[1]; // left, right
|
|
|
+ h += extents[2] + extents[3]; // top, bottom
|
|
|
+ }
|
|
|
+ XFree(data);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return Size2(w, h);
|
|
|
+}
|
|
|
+
|
|
|
+bool DisplayServerX11::window_is_maximize_allowed(WindowID p_window) const {
|
|
|
+
|
|
|
+ ERR_FAIL_COND_V(windows.has(p_window), false);
|
|
|
+ const WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ Atom property = XInternAtom(x11_display, "_NET_WM_ALLOWED_ACTIONS", False);
|
|
|
+ Atom type;
|
|
|
+ int format;
|
|
|
+ unsigned long len;
|
|
|
+ unsigned long remaining;
|
|
|
+ unsigned char *data = NULL;
|
|
|
+
|
|
|
+ int result = XGetWindowProperty(
|
|
|
+ x11_display,
|
|
|
+ wd.x11_window,
|
|
|
+ property,
|
|
|
+ 0,
|
|
|
+ 1024,
|
|
|
+ False,
|
|
|
+ XA_ATOM,
|
|
|
+ &type,
|
|
|
+ &format,
|
|
|
+ &len,
|
|
|
+ &remaining,
|
|
|
+ &data);
|
|
|
+
|
|
|
+ if (result == Success) {
|
|
|
+ Atom *atoms = (Atom *)data;
|
|
|
+ Atom wm_act_max_horz = XInternAtom(x11_display, "_NET_WM_ACTION_MAXIMIZE_HORZ", False);
|
|
|
+ Atom wm_act_max_vert = XInternAtom(x11_display, "_NET_WM_ACTION_MAXIMIZE_VERT", False);
|
|
|
+ bool found_wm_act_max_horz = false;
|
|
|
+ bool found_wm_act_max_vert = false;
|
|
|
+
|
|
|
+ for (uint64_t i = 0; i < len; i++) {
|
|
|
+ if (atoms[i] == wm_act_max_horz)
|
|
|
+ found_wm_act_max_horz = true;
|
|
|
+ if (atoms[i] == wm_act_max_vert)
|
|
|
+ found_wm_act_max_vert = true;
|
|
|
+
|
|
|
+ if (found_wm_act_max_horz || found_wm_act_max_vert)
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ XFree(atoms);
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::_set_wm_maximized(WindowID p_window, bool p_enabled) {
|
|
|
+ ERR_FAIL_COND(windows.has(p_window));
|
|
|
+ WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ // Using EWMH -- Extended Window Manager Hints
|
|
|
+ XEvent xev;
|
|
|
+ Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
|
|
|
+ Atom wm_max_horz = XInternAtom(x11_display, "_NET_WM_STATE_MAXIMIZED_HORZ", False);
|
|
|
+ Atom wm_max_vert = XInternAtom(x11_display, "_NET_WM_STATE_MAXIMIZED_VERT", False);
|
|
|
+
|
|
|
+ memset(&xev, 0, sizeof(xev));
|
|
|
+ xev.type = ClientMessage;
|
|
|
+ xev.xclient.window = wd.x11_window;
|
|
|
+ xev.xclient.message_type = wm_state;
|
|
|
+ xev.xclient.format = 32;
|
|
|
+ xev.xclient.data.l[0] = p_enabled ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
|
|
|
+ xev.xclient.data.l[1] = wm_max_horz;
|
|
|
+ xev.xclient.data.l[2] = wm_max_vert;
|
|
|
+
|
|
|
+ XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
|
|
|
+
|
|
|
+ if (p_enabled && window_is_maximize_allowed(p_window)) {
|
|
|
+ // Wait for effective resizing (so the GLX context is too).
|
|
|
+ // Give up after 0.5s, it's not going to happen on this WM.
|
|
|
+ // https://github.com/godotengine/godot/issues/19978
|
|
|
+ for (int attempt = 0; window_get_mode(p_window) != WINDOW_MODE_MAXIMIZED && attempt < 50; attempt++) {
|
|
|
+ usleep(10000);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::_set_wm_fullscreen(WindowID p_window, bool p_enabled) {
|
|
|
+
|
|
|
+ ERR_FAIL_COND(windows.has(p_window));
|
|
|
+ WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ if (p_enabled && !window_get_flag(WINDOW_FLAG_BORDERLESS, p_window)) {
|
|
|
+ // remove decorations if the window is not already borderless
|
|
|
+ Hints hints;
|
|
|
+ Atom property;
|
|
|
+ hints.flags = 2;
|
|
|
+ hints.decorations = 0;
|
|
|
+ property = XInternAtom(x11_display, "_MOTIF_WM_HINTS", True);
|
|
|
+ XChangeProperty(x11_display, wd.x11_window, property, property, 32, PropModeReplace, (unsigned char *)&hints, 5);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (p_enabled && window_get_flag(WINDOW_FLAG_RESIZE_DISABLED, p_window)) {
|
|
|
+ // Set the window as resizable to prevent window managers to ignore the fullscreen state flag.
|
|
|
+ XSizeHints *xsh;
|
|
|
+
|
|
|
+ xsh = XAllocSizeHints();
|
|
|
+ xsh->flags = 0L;
|
|
|
+ XSetWMNormalHints(x11_display, wd.x11_window, xsh);
|
|
|
+ XFree(xsh);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Using EWMH -- Extended Window Manager Hints
|
|
|
+ XEvent xev;
|
|
|
+ Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
|
|
|
+ Atom wm_fullscreen = XInternAtom(x11_display, "_NET_WM_STATE_FULLSCREEN", False);
|
|
|
+
|
|
|
+ memset(&xev, 0, sizeof(xev));
|
|
|
+ xev.type = ClientMessage;
|
|
|
+ xev.xclient.window = wd.x11_window;
|
|
|
+ xev.xclient.message_type = wm_state;
|
|
|
+ xev.xclient.format = 32;
|
|
|
+ xev.xclient.data.l[0] = p_enabled ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
|
|
|
+ xev.xclient.data.l[1] = wm_fullscreen;
|
|
|
+ xev.xclient.data.l[2] = 0;
|
|
|
+
|
|
|
+ XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
|
|
|
+
|
|
|
+ // set bypass compositor hint
|
|
|
+ Atom bypass_compositor = XInternAtom(x11_display, "_NET_WM_BYPASS_COMPOSITOR", False);
|
|
|
+ unsigned long compositing_disable_on = p_enabled ? 1 : 0;
|
|
|
+ XChangeProperty(x11_display, wd.x11_window, bypass_compositor, XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&compositing_disable_on, 1);
|
|
|
+
|
|
|
+ XFlush(x11_display);
|
|
|
+
|
|
|
+ if (!p_enabled) {
|
|
|
+ // Reset the non-resizable flags if we un-set these before.
|
|
|
+ Size2 size = window_get_size(p_window);
|
|
|
+ XSizeHints *xsh;
|
|
|
+ xsh = XAllocSizeHints();
|
|
|
+ if (window_get_flag(WINDOW_FLAG_RESIZE_DISABLED, p_window)) {
|
|
|
+ xsh->flags = PMinSize | PMaxSize;
|
|
|
+ xsh->min_width = size.x;
|
|
|
+ xsh->max_width = size.x;
|
|
|
+ xsh->min_height = size.y;
|
|
|
+ xsh->max_height = size.y;
|
|
|
+ } else {
|
|
|
+ xsh->flags = 0L;
|
|
|
+ if (wd.min_size != Size2()) {
|
|
|
+ xsh->flags |= PMinSize;
|
|
|
+ xsh->min_width = wd.min_size.x;
|
|
|
+ xsh->min_height = wd.min_size.y;
|
|
|
+ }
|
|
|
+ if (wd.max_size != Size2()) {
|
|
|
+ xsh->flags |= PMaxSize;
|
|
|
+ xsh->max_width = wd.max_size.x;
|
|
|
+ xsh->max_height = wd.max_size.y;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ XSetWMNormalHints(x11_display, wd.x11_window, xsh);
|
|
|
+ XFree(xsh);
|
|
|
+
|
|
|
+ // put back or remove decorations according to the last set borderless state
|
|
|
+ Hints hints;
|
|
|
+ Atom property;
|
|
|
+ hints.flags = 2;
|
|
|
+ hints.decorations = window_get_flag(WINDOW_FLAG_BORDERLESS, p_window) ? 0 : 1;
|
|
|
+ property = XInternAtom(x11_display, "_MOTIF_WM_HINTS", True);
|
|
|
+ XChangeProperty(x11_display, wd.x11_window, property, property, 32, PropModeReplace, (unsigned char *)&hints, 5);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::window_set_mode(WindowMode p_mode, WindowID p_window) {
|
|
|
+ ERR_FAIL_COND(windows.has(p_window));
|
|
|
+ WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ WindowMode old_mode = window_get_mode(p_window);
|
|
|
+ if (old_mode == p_mode) {
|
|
|
+ return; // do nothing
|
|
|
+ }
|
|
|
+ //remove all "extra" modes
|
|
|
+
|
|
|
+ switch (old_mode) {
|
|
|
+ case WINDOW_MODE_WINDOWED: {
|
|
|
+ //do nothing
|
|
|
+ } break;
|
|
|
+ case WINDOW_MODE_MINIMIZED: {
|
|
|
+ //Un-Minimize
|
|
|
+ // Using ICCCM -- Inter-Client Communication Conventions Manual
|
|
|
+ XEvent xev;
|
|
|
+ Atom wm_change = XInternAtom(x11_display, "WM_CHANGE_STATE", False);
|
|
|
+
|
|
|
+ memset(&xev, 0, sizeof(xev));
|
|
|
+ xev.type = ClientMessage;
|
|
|
+ xev.xclient.window = wd.x11_window;
|
|
|
+ xev.xclient.message_type = wm_change;
|
|
|
+ xev.xclient.format = 32;
|
|
|
+ xev.xclient.data.l[0] = WM_NormalState;
|
|
|
+
|
|
|
+ XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
|
|
|
+
|
|
|
+ Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
|
|
|
+ Atom wm_hidden = XInternAtom(x11_display, "_NET_WM_STATE_HIDDEN", False);
|
|
|
+
|
|
|
+ memset(&xev, 0, sizeof(xev));
|
|
|
+ xev.type = ClientMessage;
|
|
|
+ xev.xclient.window = wd.x11_window;
|
|
|
+ xev.xclient.message_type = wm_state;
|
|
|
+ xev.xclient.format = 32;
|
|
|
+ xev.xclient.data.l[0] = _NET_WM_STATE_ADD;
|
|
|
+ xev.xclient.data.l[1] = wm_hidden;
|
|
|
+
|
|
|
+ XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
|
|
|
+ } break;
|
|
|
+ case WINDOW_MODE_FULLSCREEN: {
|
|
|
+ //Remove full-screen
|
|
|
+ _set_wm_fullscreen(p_window, false);
|
|
|
+
|
|
|
+ //un-maximize required for always on top
|
|
|
+ bool on_top = window_get_flag(WINDOW_FLAG_ALWAYS_ON_TOP, p_window);
|
|
|
+
|
|
|
+ wd.fullscreen = false;
|
|
|
+
|
|
|
+ window_set_position(wd.last_position_before_fs, p_window);
|
|
|
+
|
|
|
+ if (on_top) {
|
|
|
+ _set_wm_maximized(p_window, false);
|
|
|
+ }
|
|
|
+
|
|
|
+ } break;
|
|
|
+ case WINDOW_MODE_MAXIMIZED: {
|
|
|
+
|
|
|
+ _set_wm_maximized(p_window, false);
|
|
|
+ } break;
|
|
|
+ }
|
|
|
+
|
|
|
+ switch (p_mode) {
|
|
|
+ case WINDOW_MODE_WINDOWED: {
|
|
|
+ //do nothing
|
|
|
+ } break;
|
|
|
+ case WINDOW_MODE_MINIMIZED: {
|
|
|
+ // Using ICCCM -- Inter-Client Communication Conventions Manual
|
|
|
+ XEvent xev;
|
|
|
+ Atom wm_change = XInternAtom(x11_display, "WM_CHANGE_STATE", False);
|
|
|
+
|
|
|
+ memset(&xev, 0, sizeof(xev));
|
|
|
+ xev.type = ClientMessage;
|
|
|
+ xev.xclient.window = wd.x11_window;
|
|
|
+ xev.xclient.message_type = wm_change;
|
|
|
+ xev.xclient.format = 32;
|
|
|
+ xev.xclient.data.l[0] = WM_IconicState;
|
|
|
+
|
|
|
+ XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
|
|
|
+
|
|
|
+ Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
|
|
|
+ Atom wm_hidden = XInternAtom(x11_display, "_NET_WM_STATE_HIDDEN", False);
|
|
|
+
|
|
|
+ memset(&xev, 0, sizeof(xev));
|
|
|
+ xev.type = ClientMessage;
|
|
|
+ xev.xclient.window = wd.x11_window;
|
|
|
+ xev.xclient.message_type = wm_state;
|
|
|
+ xev.xclient.format = 32;
|
|
|
+ xev.xclient.data.l[0] = _NET_WM_STATE_ADD;
|
|
|
+ xev.xclient.data.l[1] = wm_hidden;
|
|
|
+
|
|
|
+ XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
|
|
|
+ } break;
|
|
|
+ case WINDOW_MODE_FULLSCREEN: {
|
|
|
+ wd.last_position_before_fs = window_get_position(p_window);
|
|
|
+ if (window_get_flag(WINDOW_FLAG_ALWAYS_ON_TOP, p_window)) {
|
|
|
+ _set_wm_maximized(p_window, true);
|
|
|
+ }
|
|
|
+ _set_wm_fullscreen(p_window, true);
|
|
|
+ wd.fullscreen = true;
|
|
|
+ } break;
|
|
|
+ case WINDOW_MODE_MAXIMIZED: {
|
|
|
+
|
|
|
+ _set_wm_maximized(p_window, true);
|
|
|
+
|
|
|
+ } break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+DisplayServer::WindowMode DisplayServerX11::window_get_mode(WindowID p_window) const {
|
|
|
+ ERR_FAIL_COND_V(windows.has(p_window), WINDOW_MODE_WINDOWED);
|
|
|
+ const WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ if (wd.fullscreen) { //if fullscreen, it's not in another mode
|
|
|
+ return WINDOW_MODE_FULLSCREEN;
|
|
|
+ }
|
|
|
+ { //test maximized
|
|
|
+ // Using EWMH -- Extended Window Manager Hints
|
|
|
+ Atom property = XInternAtom(x11_display, "_NET_WM_STATE", False);
|
|
|
+ Atom type;
|
|
|
+ int format;
|
|
|
+ unsigned long len;
|
|
|
+ unsigned long remaining;
|
|
|
+ unsigned char *data = NULL;
|
|
|
+ bool retval = false;
|
|
|
+
|
|
|
+ int result = XGetWindowProperty(
|
|
|
+ x11_display,
|
|
|
+ wd.x11_window,
|
|
|
+ property,
|
|
|
+ 0,
|
|
|
+ 1024,
|
|
|
+ False,
|
|
|
+ XA_ATOM,
|
|
|
+ &type,
|
|
|
+ &format,
|
|
|
+ &len,
|
|
|
+ &remaining,
|
|
|
+ &data);
|
|
|
+
|
|
|
+ if (result == Success) {
|
|
|
+ Atom *atoms = (Atom *)data;
|
|
|
+ Atom wm_max_horz = XInternAtom(x11_display, "_NET_WM_STATE_MAXIMIZED_HORZ", False);
|
|
|
+ Atom wm_max_vert = XInternAtom(x11_display, "_NET_WM_STATE_MAXIMIZED_VERT", False);
|
|
|
+ bool found_wm_max_horz = false;
|
|
|
+ bool found_wm_max_vert = false;
|
|
|
+
|
|
|
+ for (uint64_t i = 0; i < len; i++) {
|
|
|
+ if (atoms[i] == wm_max_horz)
|
|
|
+ found_wm_max_horz = true;
|
|
|
+ if (atoms[i] == wm_max_vert)
|
|
|
+ found_wm_max_vert = true;
|
|
|
+
|
|
|
+ if (found_wm_max_horz && found_wm_max_vert) {
|
|
|
+ retval = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ XFree(data);
|
|
|
+ if (retval) {
|
|
|
+ return WINDOW_MODE_MAXIMIZED;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ { // test minimzed
|
|
|
+ // Using ICCCM -- Inter-Client Communication Conventions Manual
|
|
|
+ Atom property = XInternAtom(x11_display, "WM_STATE", True);
|
|
|
+ Atom type;
|
|
|
+ int format;
|
|
|
+ unsigned long len;
|
|
|
+ unsigned long remaining;
|
|
|
+ unsigned char *data = NULL;
|
|
|
+
|
|
|
+ int result = XGetWindowProperty(
|
|
|
+ x11_display,
|
|
|
+ wd.x11_window,
|
|
|
+ property,
|
|
|
+ 0,
|
|
|
+ 32,
|
|
|
+ False,
|
|
|
+ AnyPropertyType,
|
|
|
+ &type,
|
|
|
+ &format,
|
|
|
+ &len,
|
|
|
+ &remaining,
|
|
|
+ &data);
|
|
|
+
|
|
|
+ if (result == Success) {
|
|
|
+ long *state = (long *)data;
|
|
|
+ if (state[0] == WM_IconicState)
|
|
|
+ return WINDOW_MODE_MINIMIZED;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // all other discarded, return windowed.
|
|
|
+
|
|
|
+ return WINDOW_MODE_WINDOWED;
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::window_set_flag(WindowFlags p_flag, bool p_enabled, WindowID p_window) {
|
|
|
+ ERR_FAIL_COND(windows.has(p_window));
|
|
|
+ WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ switch (p_flag) {
|
|
|
+ case WINDOW_FLAG_RESIZE_DISABLED: {
|
|
|
+ XSizeHints *xsh;
|
|
|
+ xsh = XAllocSizeHints();
|
|
|
+ if (p_enabled) {
|
|
|
+ Size2 size = window_get_size(p_window);
|
|
|
+
|
|
|
+ xsh->flags = PMinSize | PMaxSize;
|
|
|
+ xsh->min_width = size.x;
|
|
|
+ xsh->max_width = size.x;
|
|
|
+ xsh->min_height = size.y;
|
|
|
+ xsh->max_height = size.y;
|
|
|
+ } else {
|
|
|
+ xsh->flags = 0L;
|
|
|
+ if (wd.min_size != Size2()) {
|
|
|
+ xsh->flags |= PMinSize;
|
|
|
+ xsh->min_width = wd.min_size.x;
|
|
|
+ xsh->min_height = wd.min_size.y;
|
|
|
+ }
|
|
|
+ if (wd.max_size != Size2()) {
|
|
|
+ xsh->flags |= PMaxSize;
|
|
|
+ xsh->max_width = wd.max_size.x;
|
|
|
+ xsh->max_height = wd.max_size.y;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ XSetWMNormalHints(x11_display, wd.x11_window, xsh);
|
|
|
+ XFree(xsh);
|
|
|
+
|
|
|
+ wd.resize_disabled = p_enabled;
|
|
|
+
|
|
|
+ XFlush(x11_display);
|
|
|
+
|
|
|
+ } break;
|
|
|
+ case WINDOW_FLAG_BORDERLESS: {
|
|
|
+
|
|
|
+ Hints hints;
|
|
|
+ Atom property;
|
|
|
+ hints.flags = 2;
|
|
|
+ hints.decorations = p_enabled ? 0 : 1;
|
|
|
+ property = XInternAtom(x11_display, "_MOTIF_WM_HINTS", True);
|
|
|
+ XChangeProperty(x11_display, wd.x11_window, property, property, 32, PropModeReplace, (unsigned char *)&hints, 5);
|
|
|
+
|
|
|
+ // Preserve window size
|
|
|
+ window_set_size(window_get_size(p_window), p_window);
|
|
|
+
|
|
|
+ wd.borderless = p_enabled;
|
|
|
+ } break;
|
|
|
+ case WINDOW_FLAG_ALWAYS_ON_TOP: {
|
|
|
+
|
|
|
+ if (p_enabled && wd.fullscreen) {
|
|
|
+ _set_wm_maximized(p_window, true);
|
|
|
+ }
|
|
|
+
|
|
|
+ Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
|
|
|
+ Atom wm_above = XInternAtom(x11_display, "_NET_WM_STATE_ABOVE", False);
|
|
|
+
|
|
|
+ XClientMessageEvent xev;
|
|
|
+ memset(&xev, 0, sizeof(xev));
|
|
|
+ xev.type = ClientMessage;
|
|
|
+ xev.window = wd.x11_window;
|
|
|
+ xev.message_type = wm_state;
|
|
|
+ xev.format = 32;
|
|
|
+ xev.data.l[0] = p_enabled ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
|
|
|
+ xev.data.l[1] = wm_above;
|
|
|
+ xev.data.l[3] = 1;
|
|
|
+ XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, (XEvent *)&xev);
|
|
|
+
|
|
|
+ if (!p_enabled && !wd.fullscreen) {
|
|
|
+ _set_wm_maximized(p_window, false);
|
|
|
+ }
|
|
|
+ wd.on_top = p_enabled;
|
|
|
+
|
|
|
+ } break;
|
|
|
+ case WINDOW_FLAG_TRANSPARENT: {
|
|
|
+ //todo reimplement
|
|
|
+ } break;
|
|
|
+ default: {
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+bool DisplayServerX11::window_get_flag(WindowFlags p_flag, WindowID p_window) const {
|
|
|
+ ERR_FAIL_COND_V(windows.has(p_window), false);
|
|
|
+ const WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ switch (p_flag) {
|
|
|
+ case WINDOW_FLAG_RESIZE_DISABLED: {
|
|
|
+
|
|
|
+ return wd.resize_disabled;
|
|
|
+ } break;
|
|
|
+ case WINDOW_FLAG_BORDERLESS: {
|
|
|
+
|
|
|
+ bool borderless = wd.borderless;
|
|
|
+ Atom prop = XInternAtom(x11_display, "_MOTIF_WM_HINTS", True);
|
|
|
+ if (prop != None) {
|
|
|
+
|
|
|
+ Atom type;
|
|
|
+ int format;
|
|
|
+ unsigned long len;
|
|
|
+ unsigned long remaining;
|
|
|
+ unsigned char *data = NULL;
|
|
|
+ if (XGetWindowProperty(x11_display, wd.x11_window, prop, 0, sizeof(Hints), False, AnyPropertyType, &type, &format, &len, &remaining, &data) == Success) {
|
|
|
+ if (data && (format == 32) && (len >= 5)) {
|
|
|
+ borderless = !((Hints *)data)->decorations;
|
|
|
+ }
|
|
|
+ XFree(data);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return borderless;
|
|
|
+ } break;
|
|
|
+ case WINDOW_FLAG_ALWAYS_ON_TOP: {
|
|
|
+
|
|
|
+ return wd.on_top;
|
|
|
+ } break;
|
|
|
+ case WINDOW_FLAG_TRANSPARENT: {
|
|
|
+ //todo reimplement
|
|
|
+ } break;
|
|
|
+ default: {
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::window_request_attention(WindowID p_window) {
|
|
|
+ ERR_FAIL_COND(windows.has(p_window));
|
|
|
+ WindowData &wd = windows[p_window];
|
|
|
+ // Using EWMH -- Extended Window Manager Hints
|
|
|
+ //
|
|
|
+ // Sets the _NET_WM_STATE_DEMANDS_ATTENTION atom for WM_STATE
|
|
|
+ // Will be unset by the window manager after user react on the request for attention
|
|
|
+
|
|
|
+ XEvent xev;
|
|
|
+ Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
|
|
|
+ Atom wm_attention = XInternAtom(x11_display, "_NET_WM_STATE_DEMANDS_ATTENTION", False);
|
|
|
+
|
|
|
+ memset(&xev, 0, sizeof(xev));
|
|
|
+ xev.type = ClientMessage;
|
|
|
+ xev.xclient.window = wd.x11_window;
|
|
|
+ xev.xclient.message_type = wm_state;
|
|
|
+ xev.xclient.format = 32;
|
|
|
+ xev.xclient.data.l[0] = _NET_WM_STATE_ADD;
|
|
|
+ xev.xclient.data.l[1] = wm_attention;
|
|
|
+
|
|
|
+ XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
|
|
|
+ XFlush(x11_display);
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::window_move_to_foreground(WindowID p_window) {
|
|
|
+ ERR_FAIL_COND(windows.has(p_window));
|
|
|
+ WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ XEvent xev;
|
|
|
+ Atom net_active_window = XInternAtom(x11_display, "_NET_ACTIVE_WINDOW", False);
|
|
|
+
|
|
|
+ memset(&xev, 0, sizeof(xev));
|
|
|
+ xev.type = ClientMessage;
|
|
|
+ xev.xclient.window = wd.x11_window;
|
|
|
+ xev.xclient.message_type = net_active_window;
|
|
|
+ xev.xclient.format = 32;
|
|
|
+ xev.xclient.data.l[0] = 1;
|
|
|
+ xev.xclient.data.l[1] = CurrentTime;
|
|
|
+
|
|
|
+ XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
|
|
|
+ XFlush(x11_display);
|
|
|
+}
|
|
|
+
|
|
|
+bool DisplayServerX11::window_can_draw(WindowID p_window) const {
|
|
|
+ //this seems to be all that is provided by X11
|
|
|
+ return window_get_mode(p_window) != WINDOW_MODE_MINIMIZED;
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::window_set_ime_active(const bool p_active, WindowID p_window) {
|
|
|
+ ERR_FAIL_COND(windows.has(p_window));
|
|
|
+ WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ wd.im_active = p_active;
|
|
|
+
|
|
|
+ if (!wd.xic)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (p_active) {
|
|
|
+ XSetICFocus(wd.xic);
|
|
|
+ window_set_ime_position(wd.im_position, p_window);
|
|
|
+ } else {
|
|
|
+ XUnsetICFocus(wd.xic);
|
|
|
+ }
|
|
|
+}
|
|
|
+void DisplayServerX11::window_set_ime_position(const Point2i &p_pos, WindowID p_window) {
|
|
|
+ ERR_FAIL_COND(windows.has(p_window));
|
|
|
+ WindowData &wd = windows[p_window];
|
|
|
+
|
|
|
+ wd.im_position = p_pos;
|
|
|
+
|
|
|
+ if (!wd.xic)
|
|
|
+ return;
|
|
|
+
|
|
|
+ ::XPoint spot;
|
|
|
+ spot.x = short(p_pos.x);
|
|
|
+ spot.y = short(p_pos.y);
|
|
|
+ XVaNestedList preedit_attr = XVaCreateNestedList(0, XNSpotLocation, &spot, NULL);
|
|
|
+ XSetICValues(wd.xic, XNPreeditAttributes, preedit_attr, NULL);
|
|
|
+ XFree(preedit_attr);
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::cursor_set_shape(CursorShape p_shape) {
|
|
|
+ ERR_FAIL_INDEX(p_shape, CURSOR_MAX);
|
|
|
+
|
|
|
+ if (p_shape == current_cursor) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (mouse_mode == MOUSE_MODE_VISIBLE || mouse_mode == MOUSE_MODE_CONFINED) {
|
|
|
+ if (cursors[p_shape] != None) {
|
|
|
+ for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
|
|
|
+ XDefineCursor(x11_display, E->get().x11_window, cursors[p_shape]);
|
|
|
+ }
|
|
|
+ } else if (cursors[CURSOR_ARROW] != None) {
|
|
|
+ for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
|
|
|
+ XDefineCursor(x11_display, E->get().x11_window, cursors[CURSOR_ARROW]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ current_cursor = p_shape;
|
|
|
+}
|
|
|
+DisplayServerX11::CursorShape DisplayServerX11::cursor_get_shape() const {
|
|
|
+ return current_cursor;
|
|
|
+}
|
|
|
+void DisplayServerX11::cursor_set_custom_image(const RES &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
|
|
|
+
|
|
|
+ if (p_cursor.is_valid()) {
|
|
|
+
|
|
|
+ Map<CursorShape, Vector<Variant>>::Element *cursor_c = cursors_cache.find(p_shape);
|
|
|
+
|
|
|
+ if (cursor_c) {
|
|
|
+ if (cursor_c->get()[0] == p_cursor && cursor_c->get()[1] == p_hotspot) {
|
|
|
+ cursor_set_shape(p_shape);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ cursors_cache.erase(p_shape);
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<Texture2D> texture = p_cursor;
|
|
|
+ Ref<AtlasTexture> atlas_texture = p_cursor;
|
|
|
+ Ref<Image> image;
|
|
|
+ Size2 texture_size;
|
|
|
+ Rect2 atlas_rect;
|
|
|
+
|
|
|
+ if (texture.is_valid()) {
|
|
|
+ image = texture->get_data();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!image.is_valid() && atlas_texture.is_valid()) {
|
|
|
+ texture = atlas_texture->get_atlas();
|
|
|
+
|
|
|
+ atlas_rect.size.width = texture->get_width();
|
|
|
+ atlas_rect.size.height = texture->get_height();
|
|
|
+ atlas_rect.position.x = atlas_texture->get_region().position.x;
|
|
|
+ atlas_rect.position.y = atlas_texture->get_region().position.y;
|
|
|
+
|
|
|
+ texture_size.width = atlas_texture->get_region().size.x;
|
|
|
+ texture_size.height = atlas_texture->get_region().size.y;
|
|
|
+ } else if (image.is_valid()) {
|
|
|
+ texture_size.width = texture->get_width();
|
|
|
+ texture_size.height = texture->get_height();
|
|
|
+ }
|
|
|
+
|
|
|
+ ERR_FAIL_COND(!texture.is_valid());
|
|
|
+ ERR_FAIL_COND(p_hotspot.x < 0 || p_hotspot.y < 0);
|
|
|
+ ERR_FAIL_COND(texture_size.width > 256 || texture_size.height > 256);
|
|
|
+ ERR_FAIL_COND(p_hotspot.x > texture_size.width || p_hotspot.y > texture_size.height);
|
|
|
+
|
|
|
+ image = texture->get_data();
|
|
|
+
|
|
|
+ ERR_FAIL_COND(!image.is_valid());
|
|
|
+
|
|
|
+ // Create the cursor structure
|
|
|
+ XcursorImage *cursor_image = XcursorImageCreate(texture_size.width, texture_size.height);
|
|
|
+ XcursorUInt image_size = texture_size.width * texture_size.height;
|
|
|
+ XcursorDim size = sizeof(XcursorPixel) * image_size;
|
|
|
+
|
|
|
+ cursor_image->version = 1;
|
|
|
+ cursor_image->size = size;
|
|
|
+ cursor_image->xhot = p_hotspot.x;
|
|
|
+ cursor_image->yhot = p_hotspot.y;
|
|
|
+
|
|
|
+ // allocate memory to contain the whole file
|
|
|
+ cursor_image->pixels = (XcursorPixel *)memalloc(size);
|
|
|
+
|
|
|
+ for (XcursorPixel index = 0; index < image_size; index++) {
|
|
|
+ int row_index = floor(index / texture_size.width) + atlas_rect.position.y;
|
|
|
+ int column_index = (index % int(texture_size.width)) + atlas_rect.position.x;
|
|
|
+
|
|
|
+ if (atlas_texture.is_valid()) {
|
|
|
+ column_index = MIN(column_index, atlas_rect.size.width - 1);
|
|
|
+ row_index = MIN(row_index, atlas_rect.size.height - 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ *(cursor_image->pixels + index) = image->get_pixel(column_index, row_index).to_argb32();
|
|
|
+ }
|
|
|
+
|
|
|
+ ERR_FAIL_COND(cursor_image->pixels == NULL);
|
|
|
+
|
|
|
+ // Save it for a further usage
|
|
|
+ cursors[p_shape] = XcursorImageLoadCursor(x11_display, cursor_image);
|
|
|
+
|
|
|
+ Vector<Variant> params;
|
|
|
+ params.push_back(p_cursor);
|
|
|
+ params.push_back(p_hotspot);
|
|
|
+ cursors_cache.insert(p_shape, params);
|
|
|
+
|
|
|
+ if (p_shape == current_cursor) {
|
|
|
+ if (mouse_mode == MOUSE_MODE_VISIBLE || mouse_mode == MOUSE_MODE_CONFINED) {
|
|
|
+ for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
|
|
|
+ XDefineCursor(x11_display, E->get().x11_window, cursors[p_shape]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ memfree(cursor_image->pixels);
|
|
|
+ XcursorImageDestroy(cursor_image);
|
|
|
+ } else {
|
|
|
+ // Reset to default system cursor
|
|
|
+ if (img[p_shape]) {
|
|
|
+ cursors[p_shape] = XcursorImageLoadCursor(x11_display, img[p_shape]);
|
|
|
+ }
|
|
|
+
|
|
|
+ CursorShape c = current_cursor;
|
|
|
+ current_cursor = CURSOR_MAX;
|
|
|
+ cursor_set_shape(c);
|
|
|
+
|
|
|
+ cursors_cache.erase(p_shape);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+DisplayServerX11::LatinKeyboardVariant DisplayServerX11::get_latin_keyboard_variant() const {
|
|
|
+ XkbDescRec *xkbdesc = XkbAllocKeyboard();
|
|
|
+ ERR_FAIL_COND_V(!xkbdesc, LATIN_KEYBOARD_QWERTY);
|
|
|
+
|
|
|
+ XkbGetNames(x11_display, XkbSymbolsNameMask, xkbdesc);
|
|
|
+ ERR_FAIL_COND_V(!xkbdesc->names, LATIN_KEYBOARD_QWERTY);
|
|
|
+ ERR_FAIL_COND_V(!xkbdesc->names->symbols, LATIN_KEYBOARD_QWERTY);
|
|
|
+
|
|
|
+ char *layout = XGetAtomName(x11_display, xkbdesc->names->symbols);
|
|
|
+ ERR_FAIL_COND_V(!layout, LATIN_KEYBOARD_QWERTY);
|
|
|
+
|
|
|
+ Vector<String> info = String(layout).split("+");
|
|
|
+ ERR_FAIL_INDEX_V(1, info.size(), LATIN_KEYBOARD_QWERTY);
|
|
|
+
|
|
|
+ if (info[1].find("colemak") != -1) {
|
|
|
+ return LATIN_KEYBOARD_COLEMAK;
|
|
|
+ } else if (info[1].find("qwertz") != -1) {
|
|
|
+ return LATIN_KEYBOARD_QWERTZ;
|
|
|
+ } else if (info[1].find("azerty") != -1) {
|
|
|
+ return LATIN_KEYBOARD_AZERTY;
|
|
|
+ } else if (info[1].find("qzerty") != -1) {
|
|
|
+ return LATIN_KEYBOARD_QZERTY;
|
|
|
+ } else if (info[1].find("dvorak") != -1) {
|
|
|
+ return LATIN_KEYBOARD_DVORAK;
|
|
|
+ } else if (info[1].find("neo") != -1) {
|
|
|
+ return LATIN_KEYBOARD_NEO;
|
|
|
+ }
|
|
|
+
|
|
|
+ return LATIN_KEYBOARD_QWERTY;
|
|
|
+}
|
|
|
+
|
|
|
+DisplayServerX11::Property DisplayServerX11::_read_property(Display *p_display, Window p_window, Atom p_property) {
|
|
|
+
|
|
|
+ Atom actual_type;
|
|
|
+ int actual_format;
|
|
|
+ unsigned long nitems;
|
|
|
+ unsigned long bytes_after;
|
|
|
+ unsigned char *ret = 0;
|
|
|
+
|
|
|
+ int read_bytes = 1024;
|
|
|
+
|
|
|
+ //Keep trying to read the property until there are no
|
|
|
+ //bytes unread.
|
|
|
+ do {
|
|
|
+ if (ret != 0)
|
|
|
+ XFree(ret);
|
|
|
+
|
|
|
+ XGetWindowProperty(p_display, p_window, p_property, 0, read_bytes, False, AnyPropertyType,
|
|
|
+ &actual_type, &actual_format, &nitems, &bytes_after,
|
|
|
+ &ret);
|
|
|
+
|
|
|
+ read_bytes *= 2;
|
|
|
+
|
|
|
+ } while (bytes_after != 0);
|
|
|
+
|
|
|
+ Property p = { ret, actual_format, (int)nitems, actual_type };
|
|
|
+
|
|
|
+ return p;
|
|
|
+}
|
|
|
+
|
|
|
+static Atom pick_target_from_list(Display *p_display, Atom *p_list, int p_count) {
|
|
|
+
|
|
|
+ static const char *target_type = "text/uri-list";
|
|
|
+
|
|
|
+ for (int i = 0; i < p_count; i++) {
|
|
|
+
|
|
|
+ Atom atom = p_list[i];
|
|
|
+
|
|
|
+ if (atom != None && String(XGetAtomName(p_display, atom)) == target_type)
|
|
|
+ return atom;
|
|
|
+ }
|
|
|
+ return None;
|
|
|
+}
|
|
|
+
|
|
|
+static Atom pick_target_from_atoms(Display *p_disp, Atom p_t1, Atom p_t2, Atom p_t3) {
|
|
|
+
|
|
|
+ static const char *target_type = "text/uri-list";
|
|
|
+ if (p_t1 != None && String(XGetAtomName(p_disp, p_t1)) == target_type)
|
|
|
+ return p_t1;
|
|
|
+
|
|
|
+ if (p_t2 != None && String(XGetAtomName(p_disp, p_t2)) == target_type)
|
|
|
+ return p_t2;
|
|
|
+
|
|
|
+ if (p_t3 != None && String(XGetAtomName(p_disp, p_t3)) == target_type)
|
|
|
+ return p_t3;
|
|
|
+
|
|
|
+ return None;
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::_get_key_modifier_state(unsigned int p_x11_state, Ref<InputEventWithModifiers> state) {
|
|
|
+
|
|
|
+ state->set_shift((p_x11_state & ShiftMask));
|
|
|
+ state->set_control((p_x11_state & ControlMask));
|
|
|
+ state->set_alt((p_x11_state & Mod1Mask /*|| p_x11_state&Mod5Mask*/)); //altgr should not count as alt
|
|
|
+ state->set_metakey((p_x11_state & Mod4Mask));
|
|
|
+}
|
|
|
+
|
|
|
+unsigned int DisplayServerX11::_get_mouse_button_state(unsigned int p_x11_button, int p_x11_type) {
|
|
|
+
|
|
|
+ unsigned int mask = 1 << (p_x11_button - 1);
|
|
|
+
|
|
|
+ if (p_x11_type == ButtonPress) {
|
|
|
+ last_button_state |= mask;
|
|
|
+ } else {
|
|
|
+ last_button_state &= ~mask;
|
|
|
+ }
|
|
|
+
|
|
|
+ return last_button_state;
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::_handle_key_event(WindowID p_window, XKeyEvent *p_event, bool p_echo) {
|
|
|
+
|
|
|
+ WindowData wd = windows[p_window];
|
|
|
+ // X11 functions don't know what const is
|
|
|
+ XKeyEvent *xkeyevent = p_event;
|
|
|
+
|
|
|
+ // This code was pretty difficult to write.
|
|
|
+ // The docs stink and every toolkit seems to
|
|
|
+ // do it in a different way.
|
|
|
+
|
|
|
+ /* Phase 1, obtain a proper keysym */
|
|
|
+
|
|
|
+ // This was also very difficult to figure out.
|
|
|
+ // You'd expect you could just use Keysym provided by
|
|
|
+ // XKeycodeToKeysym to obtain internationalized
|
|
|
+ // input.. WRONG!!
|
|
|
+ // you must use XLookupString (???) which not only wastes
|
|
|
+ // cycles generating an unnecessary string, but also
|
|
|
+ // still works in half the cases. (won't handle deadkeys)
|
|
|
+ // For more complex input methods (deadkeys and more advanced)
|
|
|
+ // you have to use XmbLookupString (??).
|
|
|
+ // So.. then you have to chosse which of both results
|
|
|
+ // you want to keep.
|
|
|
+ // This is a real bizarreness and cpu waster.
|
|
|
+
|
|
|
+ KeySym keysym_keycode = 0; // keysym used to find a keycode
|
|
|
+ KeySym keysym_unicode = 0; // keysym used to find unicode
|
|
|
+
|
|
|
+ // XLookupString returns keysyms usable as nice keycodes.
|
|
|
+ char str[256 + 1];
|
|
|
+ XKeyEvent xkeyevent_no_mod = *xkeyevent;
|
|
|
+ xkeyevent_no_mod.state &= ~ShiftMask;
|
|
|
+ xkeyevent_no_mod.state &= ~ControlMask;
|
|
|
+ XLookupString(xkeyevent, str, 256, &keysym_unicode, NULL);
|
|
|
+ XLookupString(&xkeyevent_no_mod, NULL, 0, &keysym_keycode, NULL);
|
|
|
+
|
|
|
+ // Meanwhile, XLookupString returns keysyms useful for unicode.
|
|
|
+
|
|
|
+ if (!xmbstring) {
|
|
|
+ // keep a temporary buffer for the string
|
|
|
+ xmbstring = (char *)memalloc(sizeof(char) * 8);
|
|
|
+ xmblen = 8;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (xkeyevent->type == KeyPress && wd.xic) {
|
|
|
+
|
|
|
+ Status status;
|
|
|
+#ifdef X_HAVE_UTF8_STRING
|
|
|
+ int utf8len = 8;
|
|
|
+ char *utf8string = (char *)memalloc(sizeof(char) * utf8len);
|
|
|
+ int utf8bytes = Xutf8LookupString(wd.xic, xkeyevent, utf8string,
|
|
|
+ utf8len - 1, &keysym_unicode, &status);
|
|
|
+ if (status == XBufferOverflow) {
|
|
|
+ utf8len = utf8bytes + 1;
|
|
|
+ utf8string = (char *)memrealloc(utf8string, utf8len);
|
|
|
+ utf8bytes = Xutf8LookupString(wd.xic, xkeyevent, utf8string,
|
|
|
+ utf8len - 1, &keysym_unicode, &status);
|
|
|
+ }
|
|
|
+ utf8string[utf8bytes] = '\0';
|
|
|
+
|
|
|
+ if (status == XLookupChars) {
|
|
|
+ bool keypress = xkeyevent->type == KeyPress;
|
|
|
+ unsigned int keycode = KeyMappingX11::get_keycode(keysym_keycode);
|
|
|
+ unsigned int physical_keycode = KeyMappingX11::get_scancode(xkeyevent->keycode);
|
|
|
+
|
|
|
+ if (keycode >= 'a' && keycode <= 'z')
|
|
|
+ keycode -= 'a' - 'A';
|
|
|
+
|
|
|
+ String tmp;
|
|
|
+ tmp.parse_utf8(utf8string, utf8bytes);
|
|
|
+ for (int i = 0; i < tmp.length(); i++) {
|
|
|
+ Ref<InputEventKey> k;
|
|
|
+ k.instance();
|
|
|
+ if (physical_keycode == 0 && keycode == 0 && tmp[i] == 0) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (keycode == 0) {
|
|
|
+ keycode = physical_keycode;
|
|
|
+ }
|
|
|
+
|
|
|
+ _get_key_modifier_state(xkeyevent->state, k);
|
|
|
+
|
|
|
+ k->set_unicode(tmp[i]);
|
|
|
+
|
|
|
+ k->set_pressed(keypress);
|
|
|
+
|
|
|
+ k->set_keycode(keycode);
|
|
|
+
|
|
|
+ k->set_physical_keycode(physical_keycode);
|
|
|
+
|
|
|
+ k->set_echo(false);
|
|
|
+
|
|
|
+ if (k->get_keycode() == KEY_BACKTAB) {
|
|
|
+ //make it consistent across platforms.
|
|
|
+ k->set_keycode(KEY_TAB);
|
|
|
+ k->set_physical_keycode(KEY_TAB);
|
|
|
+ k->set_shift(true);
|
|
|
+ }
|
|
|
+
|
|
|
+ Input::get_singleton()->accumulate_input_event(k);
|
|
|
+ }
|
|
|
+ memfree(utf8string);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ memfree(utf8string);
|
|
|
+#else
|
|
|
+ do {
|
|
|
+
|
|
|
+ int mnbytes = XmbLookupString(xic, xkeyevent, xmbstring, xmblen - 1, &keysym_unicode, &status);
|
|
|
+ xmbstring[mnbytes] = '\0';
|
|
|
+
|
|
|
+ if (status == XBufferOverflow) {
|
|
|
+ xmblen = mnbytes + 1;
|
|
|
+ xmbstring = (char *)memrealloc(xmbstring, xmblen);
|
|
|
+ }
|
|
|
+ } while (status == XBufferOverflow);
|
|
|
+#endif
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Phase 2, obtain a Godot keycode from the keysym */
|
|
|
+
|
|
|
+ // KeyMappingX11 just translated the X11 keysym to a PIGUI
|
|
|
+ // keysym, so it works in all platforms the same.
|
|
|
+
|
|
|
+ unsigned int keycode = KeyMappingX11::get_keycode(keysym_keycode);
|
|
|
+ unsigned int physical_keycode = KeyMappingX11::get_scancode(xkeyevent->keycode);
|
|
|
+
|
|
|
+ /* Phase 3, obtain a unicode character from the keysym */
|
|
|
+
|
|
|
+ // KeyMappingX11 also translates keysym to unicode.
|
|
|
+ // It does a binary search on a table to translate
|
|
|
+ // most properly.
|
|
|
+ unsigned int unicode = keysym_unicode > 0 ? KeyMappingX11::get_unicode_from_keysym(keysym_unicode) : 0;
|
|
|
+
|
|
|
+ /* Phase 4, determine if event must be filtered */
|
|
|
+
|
|
|
+ // This seems to be a side-effect of using XIM.
|
|
|
+ // XEventFilter looks like a core X11 function,
|
|
|
+ // but it's actually just used to see if we must
|
|
|
+ // ignore a deadkey, or events XIM determines
|
|
|
+ // must not reach the actual gui.
|
|
|
+ // Guess it was a design problem of the extension
|
|
|
+
|
|
|
+ bool keypress = xkeyevent->type == KeyPress;
|
|
|
+
|
|
|
+ if (physical_keycode == 0 && keycode == 0 && unicode == 0) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (keycode == 0) {
|
|
|
+ keycode = physical_keycode;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Phase 5, determine modifier mask */
|
|
|
+
|
|
|
+ // No problems here, except I had no way to
|
|
|
+ // know Mod1 was ALT and Mod4 was META (applekey/winkey)
|
|
|
+ // just tried Mods until i found them.
|
|
|
+
|
|
|
+ //print_verbose("mod1: "+itos(xkeyevent->state&Mod1Mask)+" mod 5: "+itos(xkeyevent->state&Mod5Mask));
|
|
|
+
|
|
|
+ Ref<InputEventKey> k;
|
|
|
+ k.instance();
|
|
|
+
|
|
|
+ _get_key_modifier_state(xkeyevent->state, k);
|
|
|
+
|
|
|
+ /* Phase 6, determine echo character */
|
|
|
+
|
|
|
+ // Echo characters in X11 are a keyrelease and a keypress
|
|
|
+ // one after the other with the (almot) same timestamp.
|
|
|
+ // To detect them, i use XPeekEvent and check that their
|
|
|
+ // difference in time is below a threshold.
|
|
|
+
|
|
|
+ if (xkeyevent->type != KeyPress) {
|
|
|
+
|
|
|
+ p_echo = false;
|
|
|
+
|
|
|
+ // make sure there are events pending,
|
|
|
+ // so this call won't block.
|
|
|
+ if (XPending(x11_display) > 0) {
|
|
|
+ XEvent peek_event;
|
|
|
+ XPeekEvent(x11_display, &peek_event);
|
|
|
+
|
|
|
+ // I'm using a threshold of 5 msecs,
|
|
|
+ // since sometimes there seems to be a little
|
|
|
+ // jitter. I'm still not convinced that all this approach
|
|
|
+ // is correct, but the xorg developers are
|
|
|
+ // not very helpful today.
|
|
|
+
|
|
|
+#define ABSDIFF(x, y) (((x) < (y)) ? ((y) - (x)) : ((x) - (y)))
|
|
|
+ ::Time threshold = ABSDIFF(peek_event.xkey.time, xkeyevent->time);
|
|
|
+#undef ABSDIFF
|
|
|
+ if (peek_event.type == KeyPress && threshold < 5) {
|
|
|
+ KeySym rk;
|
|
|
+ XLookupString((XKeyEvent *)&peek_event, str, 256, &rk, NULL);
|
|
|
+ if (rk == keysym_keycode) {
|
|
|
+ XEvent event;
|
|
|
+ XNextEvent(x11_display, &event); //erase next event
|
|
|
+ _handle_key_event(p_window, (XKeyEvent *)&event, true);
|
|
|
+ return; //ignore current, echo next
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // use the time from peek_event so it always works
|
|
|
+ }
|
|
|
+
|
|
|
+ // save the time to check for echo when keypress happens
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Phase 7, send event to Window */
|
|
|
+
|
|
|
+ k->set_pressed(keypress);
|
|
|
+
|
|
|
+ if (keycode >= 'a' && keycode <= 'z')
|
|
|
+ keycode -= 'a' - 'A';
|
|
|
+
|
|
|
+ k->set_keycode(keycode);
|
|
|
+ k->set_physical_keycode(physical_keycode);
|
|
|
+ k->set_unicode(unicode);
|
|
|
+ k->set_echo(p_echo);
|
|
|
+
|
|
|
+ if (k->get_keycode() == KEY_BACKTAB) {
|
|
|
+ //make it consistent across platforms.
|
|
|
+ k->set_keycode(KEY_TAB);
|
|
|
+ k->set_physical_keycode(KEY_TAB);
|
|
|
+ k->set_shift(true);
|
|
|
+ }
|
|
|
+
|
|
|
+ //don't set mod state if modifier keys are released by themselves
|
|
|
+ //else event.is_action() will not work correctly here
|
|
|
+ if (!k->is_pressed()) {
|
|
|
+ if (k->get_keycode() == KEY_SHIFT)
|
|
|
+ k->set_shift(false);
|
|
|
+ else if (k->get_keycode() == KEY_CONTROL)
|
|
|
+ k->set_control(false);
|
|
|
+ else if (k->get_keycode() == KEY_ALT)
|
|
|
+ k->set_alt(false);
|
|
|
+ else if (k->get_keycode() == KEY_META)
|
|
|
+ k->set_metakey(false);
|
|
|
+ }
|
|
|
+
|
|
|
+ bool last_is_pressed = Input::get_singleton()->is_key_pressed(k->get_keycode());
|
|
|
+ if (k->is_pressed()) {
|
|
|
+ if (last_is_pressed) {
|
|
|
+ k->set_echo(true);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ Input::get_singleton()->accumulate_input_event(k);
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::_xim_destroy_callback(::XIM im, ::XPointer client_data,
|
|
|
+ ::XPointer call_data) {
|
|
|
+
|
|
|
+ WARN_PRINT("Input method stopped");
|
|
|
+ DisplayServerX11 *ds = reinterpret_cast<DisplayServerX11 *>(client_data);
|
|
|
+ ds->xim = NULL;
|
|
|
+
|
|
|
+ for (Map<WindowID, WindowData>::Element *E = ds->windows.front(); E; E = E->next()) {
|
|
|
+ E->get().xic = NULL;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::_window_changed(XEvent *event) {
|
|
|
+
|
|
|
+ WindowID window_id = MAIN_WINDOW_ID;
|
|
|
+
|
|
|
+ //assign the event to the relevant window
|
|
|
+ for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
|
|
|
+ if (event->xany.window == E->get().x11_window) {
|
|
|
+ window_id = E->key();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ WindowData &wd = windows[window_id];
|
|
|
+
|
|
|
+ if (wd.xic) {
|
|
|
+ // Not portable.
|
|
|
+ window_set_ime_position(Point2(0, 1));
|
|
|
+ }
|
|
|
+ if ((event->xconfigure.width == wd.size.width) &&
|
|
|
+ (event->xconfigure.height == wd.size.height))
|
|
|
+ return;
|
|
|
+
|
|
|
+ wd.size.width = event->xconfigure.width;
|
|
|
+ wd.size.height = event->xconfigure.height;
|
|
|
+
|
|
|
+#if defined(VULKAN_ENABLED)
|
|
|
+ if (video_driver == "vulkan") {
|
|
|
+ context_vulkan->window_resize(wd.vulkan_window, wd.size.width, wd.size.height);
|
|
|
+ }
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::process_events() {
|
|
|
+ do_mouse_warp = false;
|
|
|
+
|
|
|
+ // Is the current mouse mode one where it needs to be grabbed.
|
|
|
+ bool mouse_mode_grab = mouse_mode == MOUSE_MODE_CAPTURED || mouse_mode == MOUSE_MODE_CONFINED;
|
|
|
+
|
|
|
+ while (XPending(x11_display) > 0) {
|
|
|
+ XEvent event;
|
|
|
+ XNextEvent(x11_display, &event);
|
|
|
+
|
|
|
+ WindowID window_id = MAIN_WINDOW_ID;
|
|
|
+
|
|
|
+ //assign the event to the relevant window
|
|
|
+ for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
|
|
|
+ if (event.xany.window == E->get().x11_window) {
|
|
|
+ window_id = E->key();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (XFilterEvent(&event, None)) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (XGetEventData(x11_display, &event.xcookie)) {
|
|
|
+
|
|
|
+ if (event.xcookie.type == GenericEvent && event.xcookie.extension == xi.opcode) {
|
|
|
+
|
|
|
+ XIDeviceEvent *event_data = (XIDeviceEvent *)event.xcookie.data;
|
|
|
+ int index = event_data->detail;
|
|
|
+ Vector2 pos = Vector2(event_data->event_x, event_data->event_y);
|
|
|
+
|
|
|
+ switch (event_data->evtype) {
|
|
|
+ case XI_HierarchyChanged:
|
|
|
+ case XI_DeviceChanged: {
|
|
|
+ _refresh_device_info();
|
|
|
+ } break;
|
|
|
+ case XI_RawMotion: {
|
|
|
+ XIRawEvent *raw_event = (XIRawEvent *)event_data;
|
|
|
+ int device_id = raw_event->deviceid;
|
|
|
+
|
|
|
+ // Determine the axis used (called valuators in XInput for some forsaken reason)
|
|
|
+ // Mask is a bitmask indicating which axes are involved.
|
|
|
+ // We are interested in the values of axes 0 and 1.
|
|
|
+ if (raw_event->valuators.mask_len <= 0) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ const double *values = raw_event->raw_values;
|
|
|
+
|
|
|
+ double rel_x = 0.0;
|
|
|
+ double rel_y = 0.0;
|
|
|
+ double pressure = 0.0;
|
|
|
+ double tilt_x = 0.0;
|
|
|
+ double tilt_y = 0.0;
|
|
|
+
|
|
|
+ if (XIMaskIsSet(raw_event->valuators.mask, VALUATOR_ABSX)) {
|
|
|
+ rel_x = *values;
|
|
|
+ values++;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (XIMaskIsSet(raw_event->valuators.mask, VALUATOR_ABSY)) {
|
|
|
+ rel_y = *values;
|
|
|
+ values++;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (XIMaskIsSet(raw_event->valuators.mask, VALUATOR_PRESSURE)) {
|
|
|
+ pressure = *values;
|
|
|
+ values++;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (XIMaskIsSet(raw_event->valuators.mask, VALUATOR_TILTX)) {
|
|
|
+ tilt_x = *values;
|
|
|
+ values++;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (XIMaskIsSet(raw_event->valuators.mask, VALUATOR_TILTY)) {
|
|
|
+ tilt_y = *values;
|
|
|
+ }
|
|
|
+
|
|
|
+ Map<int, Vector3>::Element *pen_info = xi.pen_devices.find(device_id);
|
|
|
+ if (pen_info) {
|
|
|
+ Vector3 mult = pen_info->value();
|
|
|
+ if (mult.x != 0.0) xi.pressure = pressure / mult.x;
|
|
|
+ if ((mult.y != 0.0) && (mult.z != 0.0)) xi.tilt = Vector2(tilt_x / mult.y, tilt_y / mult.z);
|
|
|
+ }
|
|
|
+
|
|
|
+ // https://bugs.freedesktop.org/show_bug.cgi?id=71609
|
|
|
+ // http://lists.libsdl.org/pipermail/commits-libsdl.org/2015-June/000282.html
|
|
|
+ if (raw_event->time == xi.last_relative_time && rel_x == xi.relative_motion.x && rel_y == xi.relative_motion.y) {
|
|
|
+ break; // Flush duplicate to avoid overly fast motion
|
|
|
+ }
|
|
|
+
|
|
|
+ xi.old_raw_pos.x = xi.raw_pos.x;
|
|
|
+ xi.old_raw_pos.y = xi.raw_pos.y;
|
|
|
+ xi.raw_pos.x = rel_x;
|
|
|
+ xi.raw_pos.y = rel_y;
|
|
|
+
|
|
|
+ Map<int, Vector2>::Element *abs_info = xi.absolute_devices.find(device_id);
|
|
|
+
|
|
|
+ if (abs_info) {
|
|
|
+ // Absolute mode device
|
|
|
+ Vector2 mult = abs_info->value();
|
|
|
+
|
|
|
+ xi.relative_motion.x += (xi.raw_pos.x - xi.old_raw_pos.x) * mult.x;
|
|
|
+ xi.relative_motion.y += (xi.raw_pos.y - xi.old_raw_pos.y) * mult.y;
|
|
|
+ } else {
|
|
|
+ // Relative mode device
|
|
|
+ xi.relative_motion.x = xi.raw_pos.x;
|
|
|
+ xi.relative_motion.y = xi.raw_pos.y;
|
|
|
+ }
|
|
|
+
|
|
|
+ xi.last_relative_time = raw_event->time;
|
|
|
+ } break;
|
|
|
+#ifdef TOUCH_ENABLED
|
|
|
+ case XI_TouchBegin: // Fall-through
|
|
|
+ // Disabled hand-in-hand with the grabbing
|
|
|
+ //XIAllowTouchEvents(x11_display, event_data->deviceid, event_data->detail, x11_window, XIAcceptTouch);
|
|
|
+
|
|
|
+ case XI_TouchEnd: {
|
|
|
+
|
|
|
+ bool is_begin = event_data->evtype == XI_TouchBegin;
|
|
|
+
|
|
|
+ Ref<InputEventScreenTouch> st;
|
|
|
+ st.instance();
|
|
|
+ st->set_window_id(window_id);
|
|
|
+ st->set_index(index);
|
|
|
+ st->set_position(pos);
|
|
|
+ st->set_pressed(is_begin);
|
|
|
+
|
|
|
+ if (is_begin) {
|
|
|
+ if (xi.state.has(index)) // Defensive
|
|
|
+ break;
|
|
|
+ xi.state[index] = pos;
|
|
|
+ if (xi.state.size() == 1) {
|
|
|
+ // X11 may send a motion event when a touch gesture begins, that would result
|
|
|
+ // in a spurious mouse motion event being sent to Godot; remember it to be able to filter it out
|
|
|
+ xi.mouse_pos_to_filter = pos;
|
|
|
+ }
|
|
|
+ Input::get_singleton()->accumulate_input_event(st);
|
|
|
+ } else {
|
|
|
+ if (!xi.state.has(index)) // Defensive
|
|
|
+ break;
|
|
|
+ xi.state.erase(index);
|
|
|
+ Input::get_singleton()->accumulate_input_event(st);
|
|
|
+ }
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case XI_TouchUpdate: {
|
|
|
+
|
|
|
+ Map<int, Vector2>::Element *curr_pos_elem = xi.state.find(index);
|
|
|
+ if (!curr_pos_elem) { // Defensive
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (curr_pos_elem->value() != pos) {
|
|
|
+
|
|
|
+ Ref<InputEventScreenDrag> sd;
|
|
|
+ sd.instance();
|
|
|
+ sd->set_window_id(window_id);
|
|
|
+ sd->set_index(index);
|
|
|
+ sd->set_position(pos);
|
|
|
+ sd->set_relative(pos - curr_pos_elem->value());
|
|
|
+ Input::get_singleton()->accumulate_input_event(sd);
|
|
|
+
|
|
|
+ curr_pos_elem->value() = pos;
|
|
|
+ }
|
|
|
+ } break;
|
|
|
+#endif
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ XFreeEventData(x11_display, &event.xcookie);
|
|
|
+
|
|
|
+ switch (event.type) {
|
|
|
+ case Expose:
|
|
|
+ Main::force_redraw();
|
|
|
+ break;
|
|
|
+
|
|
|
+ case NoExpose:
|
|
|
+ minimized = true;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case VisibilityNotify: {
|
|
|
+ XVisibilityEvent *visibility = (XVisibilityEvent *)&event;
|
|
|
+ minimized = (visibility->state == VisibilityFullyObscured);
|
|
|
+ } break;
|
|
|
+ case LeaveNotify: {
|
|
|
+ if (!mouse_mode_grab)
|
|
|
+ Input::get_singleton()->parse_notification(MainLoop::NOTIFICATION_WM_MOUSE_EXIT);
|
|
|
+
|
|
|
+ } break;
|
|
|
+ case EnterNotify: {
|
|
|
+ if (!mouse_mode_grab)
|
|
|
+ Input::get_singleton()->parse_notification(MainLoop::NOTIFICATION_WM_MOUSE_ENTER);
|
|
|
+ } break;
|
|
|
+ case FocusIn:
|
|
|
+ minimized = false;
|
|
|
+ window_has_focus = true;
|
|
|
+ Input::get_singleton()->parse_notification(MainLoop::NOTIFICATION_WM_FOCUS_IN);
|
|
|
+ window_focused = true;
|
|
|
+
|
|
|
+ if (mouse_mode_grab) {
|
|
|
+ // Show and update the cursor if confined and the window regained focus.
|
|
|
+
|
|
|
+ for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
|
|
|
+
|
|
|
+ if (mouse_mode == MOUSE_MODE_CONFINED)
|
|
|
+ XUndefineCursor(x11_display, E->get().x11_window);
|
|
|
+ else if (mouse_mode == MOUSE_MODE_CAPTURED) // or re-hide it in captured mode
|
|
|
+ XDefineCursor(x11_display, E->get().x11_window, null_cursor);
|
|
|
+
|
|
|
+ XGrabPointer(
|
|
|
+ x11_display, E->get().x11_window, True,
|
|
|
+ ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
|
|
|
+ GrabModeAsync, GrabModeAsync, E->get().x11_window, None, CurrentTime);
|
|
|
+ }
|
|
|
+ }
|
|
|
+#ifdef TOUCH_ENABLED
|
|
|
+ // Grab touch devices to avoid OS gesture interference
|
|
|
+ /*for (int i = 0; i < xi.touch_devices.size(); ++i) {
|
|
|
+ XIGrabDevice(x11_display, xi.touch_devices[i], x11_window, CurrentTime, None, XIGrabModeAsync, XIGrabModeAsync, False, &xi.touch_event_mask);
|
|
|
+ }*/
|
|
|
+#endif
|
|
|
+ if (windows[window_id].xic) {
|
|
|
+ XSetICFocus(windows[window_id].xic);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+ case FocusOut:
|
|
|
+ window_has_focus = false;
|
|
|
+ Input::get_singleton()->release_pressed_events();
|
|
|
+ Input::get_singleton()->parse_notification(MainLoop::NOTIFICATION_WM_FOCUS_OUT);
|
|
|
+ window_focused = false;
|
|
|
+
|
|
|
+ if (mouse_mode_grab) {
|
|
|
+ for (Map<WindowID, WindowData>::Element *E = windows.front(); E; E = E->next()) {
|
|
|
+
|
|
|
+ //dear X11, I try, I really try, but you never work, you do whathever you want.
|
|
|
+ if (mouse_mode == MOUSE_MODE_CAPTURED) {
|
|
|
+ // Show the cursor if we're in captured mode so it doesn't look weird.
|
|
|
+ XUndefineCursor(x11_display, E->get().x11_window);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ XUngrabPointer(x11_display, CurrentTime);
|
|
|
+ }
|
|
|
+#ifdef TOUCH_ENABLED
|
|
|
+ // Ungrab touch devices so input works as usual while we are unfocused
|
|
|
+ /*for (int i = 0; i < xi.touch_devices.size(); ++i) {
|
|
|
+ XIUngrabDevice(x11_display, xi.touch_devices[i], CurrentTime);
|
|
|
+ }*/
|
|
|
+
|
|
|
+ // Release every pointer to avoid sticky points
|
|
|
+ for (Map<int, Vector2>::Element *E = xi.state.front(); E; E = E->next()) {
|
|
|
+
|
|
|
+ Ref<InputEventScreenTouch> st;
|
|
|
+ st.instance();
|
|
|
+ st->set_index(E->key());
|
|
|
+ st->set_window_id(window_id);
|
|
|
+ st->set_position(E->get());
|
|
|
+ Input::get_singleton()->accumulate_input_event(st);
|
|
|
+ }
|
|
|
+ xi.state.clear();
|
|
|
+#endif
|
|
|
+ if (windows[window_id].xic) {
|
|
|
+ XSetICFocus(windows[window_id].xic);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+ case ConfigureNotify:
|
|
|
+ _window_changed(&event);
|
|
|
+ break;
|
|
|
+ case ButtonPress:
|
|
|
+ case ButtonRelease: {
|
|
|
+
|
|
|
+ /* exit in case of a mouse button press */
|
|
|
+ last_timestamp = event.xbutton.time;
|
|
|
+ if (mouse_mode == MOUSE_MODE_CAPTURED) {
|
|
|
+ event.xbutton.x = last_mouse_pos.x;
|
|
|
+ event.xbutton.y = last_mouse_pos.y;
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<InputEventMouseButton> mb;
|
|
|
+ mb.instance();
|
|
|
+
|
|
|
+ mb->set_window_id(window_id);
|
|
|
+ _get_key_modifier_state(event.xbutton.state, mb);
|
|
|
+ mb->set_button_index(event.xbutton.button);
|
|
|
+ if (mb->get_button_index() == 2)
|
|
|
+ mb->set_button_index(3);
|
|
|
+ else if (mb->get_button_index() == 3)
|
|
|
+ mb->set_button_index(2);
|
|
|
+ mb->set_button_mask(_get_mouse_button_state(mb->get_button_index(), event.xbutton.type));
|
|
|
+ mb->set_position(Vector2(event.xbutton.x, event.xbutton.y));
|
|
|
+ mb->set_global_position(mb->get_position());
|
|
|
+
|
|
|
+ mb->set_pressed((event.type == ButtonPress));
|
|
|
+
|
|
|
+ if (event.type == ButtonPress) {
|
|
|
+
|
|
|
+ uint64_t diff = OS::get_singleton()->get_ticks_usec() / 1000 - last_click_ms;
|
|
|
+
|
|
|
+ if (mb->get_button_index() == last_click_button_index) {
|
|
|
+
|
|
|
+ if (diff < 400 && Vector2(last_click_pos).distance_to(Vector2(event.xbutton.x, event.xbutton.y)) < 5) {
|
|
|
+
|
|
|
+ last_click_ms = 0;
|
|
|
+ last_click_pos = Point2i(-100, -100);
|
|
|
+ last_click_button_index = -1;
|
|
|
+ mb->set_doubleclick(true);
|
|
|
+ }
|
|
|
+
|
|
|
+ } else if (mb->get_button_index() < 4 || mb->get_button_index() > 7) {
|
|
|
+ last_click_button_index = mb->get_button_index();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!mb->is_doubleclick()) {
|
|
|
+ last_click_ms += diff;
|
|
|
+ last_click_pos = Point2i(event.xbutton.x, event.xbutton.y);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ Input::get_singleton()->accumulate_input_event(mb);
|
|
|
+
|
|
|
+ } break;
|
|
|
+ case MotionNotify: {
|
|
|
+
|
|
|
+ // The X11 API requires filtering one-by-one through the motion
|
|
|
+ // notify events, in order to figure out which event is the one
|
|
|
+ // generated by warping the mouse pointer.
|
|
|
+
|
|
|
+ while (true) {
|
|
|
+ if (mouse_mode == MOUSE_MODE_CAPTURED && event.xmotion.x == windows[MAIN_WINDOW_ID].size.width / 2 && event.xmotion.y == windows[MAIN_WINDOW_ID].size.height / 2) {
|
|
|
+ //this is likely the warp event since it was warped here
|
|
|
+ center = Vector2(event.xmotion.x, event.xmotion.y);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (XPending(x11_display) > 0) {
|
|
|
+ XEvent tevent;
|
|
|
+ XPeekEvent(x11_display, &tevent);
|
|
|
+ if (tevent.type == MotionNotify) {
|
|
|
+ XNextEvent(x11_display, &event);
|
|
|
+ } else {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ last_timestamp = event.xmotion.time;
|
|
|
+
|
|
|
+ // Motion is also simple.
|
|
|
+ // A little hack is in order
|
|
|
+ // to be able to send relative motion events.
|
|
|
+ Point2i pos(event.xmotion.x, event.xmotion.y);
|
|
|
+
|
|
|
+ // Avoidance of spurious mouse motion (see handling of touch)
|
|
|
+ bool filter = false;
|
|
|
+ // Adding some tolerance to match better Point2i to Vector2
|
|
|
+ if (xi.state.size() && Vector2(pos).distance_squared_to(xi.mouse_pos_to_filter) < 2) {
|
|
|
+ filter = true;
|
|
|
+ }
|
|
|
+ // Invalidate to avoid filtering a possible legitimate similar event coming later
|
|
|
+ xi.mouse_pos_to_filter = Vector2(1e10, 1e10);
|
|
|
+ if (filter) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (mouse_mode == MOUSE_MODE_CAPTURED) {
|
|
|
+ if (xi.relative_motion.x == 0 && xi.relative_motion.y == 0) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ Point2i new_center = pos;
|
|
|
+ pos = last_mouse_pos + xi.relative_motion;
|
|
|
+ center = new_center;
|
|
|
+ do_mouse_warp = window_has_focus; // warp the cursor if we're focused in
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!last_mouse_pos_valid) {
|
|
|
+
|
|
|
+ last_mouse_pos = pos;
|
|
|
+ last_mouse_pos_valid = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Hackish but relative mouse motion is already handled in the RawMotion event.
|
|
|
+ // RawMotion does not provide the absolute mouse position (whereas MotionNotify does).
|
|
|
+ // Therefore, RawMotion cannot be the authority on absolute mouse position.
|
|
|
+ // RawMotion provides more precision than MotionNotify, which doesn't sense subpixel motion.
|
|
|
+ // Therefore, MotionNotify cannot be the authority on relative mouse motion.
|
|
|
+ // This means we need to take a combined approach...
|
|
|
+ Point2i rel;
|
|
|
+
|
|
|
+ // Only use raw input if in capture mode. Otherwise use the classic behavior.
|
|
|
+ if (mouse_mode == MOUSE_MODE_CAPTURED) {
|
|
|
+ rel = xi.relative_motion;
|
|
|
+ } else {
|
|
|
+ rel = pos - last_mouse_pos;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Reset to prevent lingering motion
|
|
|
+ xi.relative_motion.x = 0;
|
|
|
+ xi.relative_motion.y = 0;
|
|
|
+
|
|
|
+ if (mouse_mode == MOUSE_MODE_CAPTURED) {
|
|
|
+ pos = Point2i(windows[MAIN_WINDOW_ID].size.width / 2, windows[MAIN_WINDOW_ID].size.height / 2);
|
|
|
+ }
|
|
|
+
|
|
|
+ Ref<InputEventMouseMotion> mm;
|
|
|
+ mm.instance();
|
|
|
+
|
|
|
+ mm->set_window_id(window_id);
|
|
|
+ mm->set_pressure(xi.pressure);
|
|
|
+ mm->set_tilt(xi.tilt);
|
|
|
+
|
|
|
+ // Make the absolute position integral so it doesn't look _too_ weird :)
|
|
|
+ Point2i posi(pos);
|
|
|
+
|
|
|
+ _get_key_modifier_state(event.xmotion.state, mm);
|
|
|
+ mm->set_button_mask(mouse_get_button_state());
|
|
|
+ mm->set_position(posi);
|
|
|
+ mm->set_global_position(posi);
|
|
|
+ Input::get_singleton()->set_mouse_position(posi);
|
|
|
+ mm->set_speed(Input::get_singleton()->get_last_mouse_speed());
|
|
|
+
|
|
|
+ mm->set_relative(rel);
|
|
|
+
|
|
|
+ last_mouse_pos = pos;
|
|
|
+
|
|
|
+ // printf("rel: %d,%d\n", rel.x, rel.y );
|
|
|
+ // Don't propagate the motion event unless we have focus
|
|
|
+ // this is so that the relative motion doesn't get messed up
|
|
|
+ // after we regain focus.
|
|
|
+ if (window_has_focus || !mouse_mode_grab)
|
|
|
+ Input::get_singleton()->accumulate_input_event(mm);
|
|
|
+
|
|
|
+ } break;
|
|
|
+ case KeyPress:
|
|
|
+ case KeyRelease: {
|
|
|
+
|
|
|
+ last_timestamp = event.xkey.time;
|
|
|
+
|
|
|
+ // key event is a little complex, so
|
|
|
+ // it will be handled in its own function.
|
|
|
+ _handle_key_event(window_id, (XKeyEvent *)&event);
|
|
|
+ } break;
|
|
|
+ case SelectionRequest: {
|
|
|
+
|
|
|
+ XSelectionRequestEvent *req;
|
|
|
+ XEvent e, respond;
|
|
|
+ e = event;
|
|
|
+
|
|
|
+ req = &(e.xselectionrequest);
|
|
|
+ if (req->target == XInternAtom(x11_display, "UTF8_STRING", 0) ||
|
|
|
+ req->target == XInternAtom(x11_display, "COMPOUND_TEXT", 0) ||
|
|
|
+ req->target == XInternAtom(x11_display, "TEXT", 0) ||
|
|
|
+ req->target == XA_STRING ||
|
|
|
+ req->target == XInternAtom(x11_display, "text/plain;charset=utf-8", 0) ||
|
|
|
+ req->target == XInternAtom(x11_display, "text/plain", 0)) {
|
|
|
+ CharString clip = clipboard_get().utf8();
|
|
|
+ XChangeProperty(x11_display,
|
|
|
+ req->requestor,
|
|
|
+ req->property,
|
|
|
+ req->target,
|
|
|
+ 8,
|
|
|
+ PropModeReplace,
|
|
|
+ (unsigned char *)clip.get_data(),
|
|
|
+ clip.length());
|
|
|
+ respond.xselection.property = req->property;
|
|
|
+ } else if (req->target == XInternAtom(x11_display, "TARGETS", 0)) {
|
|
|
+
|
|
|
+ Atom data[7];
|
|
|
+ data[0] = XInternAtom(x11_display, "TARGETS", 0);
|
|
|
+ data[1] = XInternAtom(x11_display, "UTF8_STRING", 0);
|
|
|
+ data[2] = XInternAtom(x11_display, "COMPOUND_TEXT", 0);
|
|
|
+ data[3] = XInternAtom(x11_display, "TEXT", 0);
|
|
|
+ data[4] = XA_STRING;
|
|
|
+ data[5] = XInternAtom(x11_display, "text/plain;charset=utf-8", 0);
|
|
|
+ data[6] = XInternAtom(x11_display, "text/plain", 0);
|
|
|
+
|
|
|
+ XChangeProperty(x11_display,
|
|
|
+ req->requestor,
|
|
|
+ req->property,
|
|
|
+ XA_ATOM,
|
|
|
+ 32,
|
|
|
+ PropModeReplace,
|
|
|
+ (unsigned char *)&data,
|
|
|
+ sizeof(data) / sizeof(data[0]));
|
|
|
+ respond.xselection.property = req->property;
|
|
|
+
|
|
|
+ } else {
|
|
|
+ char *targetname = XGetAtomName(x11_display, req->target);
|
|
|
+ printf("No Target '%s'\n", targetname);
|
|
|
+ if (targetname)
|
|
|
+ XFree(targetname);
|
|
|
+ respond.xselection.property = None;
|
|
|
+ }
|
|
|
+
|
|
|
+ respond.xselection.type = SelectionNotify;
|
|
|
+ respond.xselection.display = req->display;
|
|
|
+ respond.xselection.requestor = req->requestor;
|
|
|
+ respond.xselection.selection = req->selection;
|
|
|
+ respond.xselection.target = req->target;
|
|
|
+ respond.xselection.time = req->time;
|
|
|
+ XSendEvent(x11_display, req->requestor, True, NoEventMask, &respond);
|
|
|
+ XFlush(x11_display);
|
|
|
+ } break;
|
|
|
+
|
|
|
+ case SelectionNotify:
|
|
|
+
|
|
|
+ if (event.xselection.target == requested) {
|
|
|
+
|
|
|
+ Property p = _read_property(x11_display, windows[window_id].x11_window, XInternAtom(x11_display, "PRIMARY", 0));
|
|
|
+
|
|
|
+ Vector<String> files = String((char *)p.data).split("\n", false);
|
|
|
+ for (int i = 0; i < files.size(); i++) {
|
|
|
+ files.write[i] = files[i].replace("file://", "").http_unescape().strip_edges();
|
|
|
+ }
|
|
|
+ Input::get_singleton()->parse_drop_files(files);
|
|
|
+
|
|
|
+ //Reply that all is well.
|
|
|
+ XClientMessageEvent m;
|
|
|
+ memset(&m, 0, sizeof(m));
|
|
|
+ m.type = ClientMessage;
|
|
|
+ m.display = x11_display;
|
|
|
+ m.window = xdnd_source_window;
|
|
|
+ m.message_type = xdnd_finished;
|
|
|
+ m.format = 32;
|
|
|
+ m.data.l[0] = windows[window_id].x11_window;
|
|
|
+ m.data.l[1] = 1;
|
|
|
+ m.data.l[2] = xdnd_action_copy; //We only ever copy.
|
|
|
+
|
|
|
+ XSendEvent(x11_display, xdnd_source_window, False, NoEventMask, (XEvent *)&m);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+ case ClientMessage:
|
|
|
+
|
|
|
+ if ((unsigned int)event.xclient.data.l[0] == (unsigned int)wm_delete)
|
|
|
+ Input::get_singleton()->parse_notification(MainLoop::NOTIFICATION_WM_QUIT_REQUEST);
|
|
|
+
|
|
|
+ else if ((unsigned int)event.xclient.message_type == (unsigned int)xdnd_enter) {
|
|
|
+
|
|
|
+ //File(s) have been dragged over the window, check for supported target (text/uri-list)
|
|
|
+ xdnd_version = (event.xclient.data.l[1] >> 24);
|
|
|
+ Window source = event.xclient.data.l[0];
|
|
|
+ bool more_than_3 = event.xclient.data.l[1] & 1;
|
|
|
+ if (more_than_3) {
|
|
|
+ Property p = _read_property(x11_display, source, XInternAtom(x11_display, "XdndTypeList", False));
|
|
|
+ requested = pick_target_from_list(x11_display, (Atom *)p.data, p.nitems);
|
|
|
+ } else
|
|
|
+ requested = pick_target_from_atoms(x11_display, event.xclient.data.l[2], event.xclient.data.l[3], event.xclient.data.l[4]);
|
|
|
+ } else if ((unsigned int)event.xclient.message_type == (unsigned int)xdnd_position) {
|
|
|
+
|
|
|
+ //xdnd position event, reply with an XDND status message
|
|
|
+ //just depending on type of data for now
|
|
|
+ XClientMessageEvent m;
|
|
|
+ memset(&m, 0, sizeof(m));
|
|
|
+ m.type = ClientMessage;
|
|
|
+ m.display = event.xclient.display;
|
|
|
+ m.window = event.xclient.data.l[0];
|
|
|
+ m.message_type = xdnd_status;
|
|
|
+ m.format = 32;
|
|
|
+ m.data.l[0] = windows[window_id].x11_window;
|
|
|
+ m.data.l[1] = (requested != None);
|
|
|
+ m.data.l[2] = 0; //empty rectangle
|
|
|
+ m.data.l[3] = 0;
|
|
|
+ m.data.l[4] = xdnd_action_copy;
|
|
|
+
|
|
|
+ XSendEvent(x11_display, event.xclient.data.l[0], False, NoEventMask, (XEvent *)&m);
|
|
|
+ XFlush(x11_display);
|
|
|
+ } else if ((unsigned int)event.xclient.message_type == (unsigned int)xdnd_drop) {
|
|
|
+
|
|
|
+ if (requested != None) {
|
|
|
+ xdnd_source_window = event.xclient.data.l[0];
|
|
|
+ if (xdnd_version >= 1)
|
|
|
+ XConvertSelection(x11_display, xdnd_selection, requested, XInternAtom(x11_display, "PRIMARY", 0), windows[window_id].x11_window, event.xclient.data.l[2]);
|
|
|
+ else
|
|
|
+ XConvertSelection(x11_display, xdnd_selection, requested, XInternAtom(x11_display, "PRIMARY", 0), windows[window_id].x11_window, CurrentTime);
|
|
|
+ } else {
|
|
|
+ //Reply that we're not interested.
|
|
|
+ XClientMessageEvent m;
|
|
|
+ memset(&m, 0, sizeof(m));
|
|
|
+ m.type = ClientMessage;
|
|
|
+ m.display = event.xclient.display;
|
|
|
+ m.window = event.xclient.data.l[0];
|
|
|
+ m.message_type = xdnd_finished;
|
|
|
+ m.format = 32;
|
|
|
+ m.data.l[0] = windows[window_id].x11_window;
|
|
|
+ m.data.l[1] = 0;
|
|
|
+ m.data.l[2] = None; //Failed.
|
|
|
+ XSendEvent(x11_display, event.xclient.data.l[0], False, NoEventMask, (XEvent *)&m);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ XFlush(x11_display);
|
|
|
+
|
|
|
+ if (do_mouse_warp) {
|
|
|
+
|
|
|
+ XWarpPointer(x11_display, None, windows[MAIN_WINDOW_ID].x11_window,
|
|
|
+ 0, 0, 0, 0, (int)windows[MAIN_WINDOW_ID].size.width / 2, (int)windows[MAIN_WINDOW_ID].size.height / 2);
|
|
|
+
|
|
|
+ /*
|
|
|
+ Window root, child;
|
|
|
+ int root_x, root_y;
|
|
|
+ int win_x, win_y;
|
|
|
+ unsigned int mask;
|
|
|
+ XQueryPointer( x11_display, x11_window, &root, &child, &root_x, &root_y, &win_x, &win_y, &mask );
|
|
|
+
|
|
|
+ printf("Root: %d,%d\n", root_x, root_y);
|
|
|
+ printf("Win: %d,%d\n", win_x, win_y);
|
|
|
+ */
|
|
|
+ }
|
|
|
+
|
|
|
+ Input::get_singleton()->flush_accumulated_events();
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::release_rendering_thread() {
|
|
|
+ WARN_PRINT("Rendering thread not supported by this display server.");
|
|
|
+}
|
|
|
+void DisplayServerX11::make_rendering_thread() {
|
|
|
+ WARN_PRINT("Rendering thread not supported by this display server.");
|
|
|
+}
|
|
|
+void DisplayServerX11::swap_buffers() {
|
|
|
+ WARN_PRINT("Swap buffers not supported by this display server.");
|
|
|
+}
|
|
|
+
|
|
|
+void DisplayServerX11::set_native_icon(const String &p_filename) {
|
|
|
+ WARN_PRINT("Native icon not supported by this display server.");
|
|
|
+}
|
|
|
+void DisplayServerX11::set_icon(const Ref<Image> &p_icon) {
|
|
|
+ WARN_PRINT("Icon not supported by this display server.");
|
|
|
+}
|
|
|
+
|
|
|
+DisplayServer *DisplayServerX11::create_func(const String &p_video_driver, WindowMode p_mode, uint32_t p_flags, const Vector2i &p_resolution, Error &r_error) {
|
|
|
+
|
|
|
+ return memnew(DisplayServerX11(p_video_driver, p_mode, p_flags, p_resolution, r_error));
|
|
|
+}
|
|
|
+
|
|
|
+DisplayServerX11::WindowID DisplayServerX11::_create_window(WindowMode p_mode, const Vector2i &p_resolution) {
|
|
|
+
|
|
|
+ //Create window
|
|
|
+
|
|
|
+ long visualMask = VisualScreenMask;
|
|
|
+ int numberOfVisuals;
|
|
|
+ XVisualInfo vInfoTemplate = {};
|
|
|
+ vInfoTemplate.screen = DefaultScreen(x11_display);
|
|
|
+ XVisualInfo *visualInfo = XGetVisualInfo(x11_display, visualMask, &vInfoTemplate, &numberOfVisuals);
|
|
|
+
|
|
|
+ Colormap colormap = XCreateColormap(x11_display, RootWindow(x11_display, vInfoTemplate.screen), visualInfo->visual, AllocNone);
|
|
|
+
|
|
|
+ XSetWindowAttributes windowAttributes = {};
|
|
|
+ windowAttributes.colormap = colormap;
|
|
|
+ windowAttributes.background_pixel = 0xFFFFFFFF;
|
|
|
+ windowAttributes.border_pixel = 0;
|
|
|
+ windowAttributes.event_mask = KeyPressMask | KeyReleaseMask | StructureNotifyMask | ExposureMask;
|
|
|
+
|
|
|
+ unsigned long valuemask = CWBorderPixel | CWColormap | CWEventMask;
|
|
|
+
|
|
|
+ WindowID id;
|
|
|
+ {
|
|
|
+ WindowData wd;
|
|
|
+ wd.x11_window = XCreateWindow(x11_display, RootWindow(x11_display, visualInfo->screen), 0, 0, OS::get_singleton()->get_video_mode().width, OS::get_singleton()->get_video_mode().height, 0, visualInfo->depth, InputOutput, visualInfo->visual, valuemask, &windowAttributes);
|
|
|
+
|
|
|
+ //set_class_hint(x11_display, wd.x11_window);
|
|
|
+ XMapWindow(x11_display, wd.x11_window);
|
|
|
+ XFlush(x11_display);
|
|
|
+
|
|
|
+ XSync(x11_display, False);
|
|
|
+ //XSetErrorHandler(oldHandler);
|
|
|
+
|
|
|
+ XFree(visualInfo);
|
|
|
+
|
|
|
+#if defined(VULKAN_ENABLED)
|
|
|
+ if (context_vulkan) {
|
|
|
+ wd.vulkan_window = context_vulkan->window_create(wd.x11_window, x11_display, p_resolution.width, p_resolution.height);
|
|
|
+ ERR_FAIL_COND_V_MSG(wd.vulkan_window == -1, INVALID_WINDOW_ID, "Can't create a Vulkan window");
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+ //associate PID
|
|
|
+
|
|
|
+ // make PID known to X11
|
|
|
+ {
|
|
|
+ const long pid = OS::get_singleton()->get_process_id();
|
|
|
+ Atom net_wm_pid = XInternAtom(x11_display, "_NET_WM_PID", False);
|
|
|
+ XChangeProperty(x11_display, wd.x11_window, net_wm_pid, XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&pid, 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ long im_event_mask = 0;
|
|
|
+
|
|
|
+ {
|
|
|
+ XIEventMask all_event_mask;
|
|
|
+ XSetWindowAttributes new_attr;
|
|
|
+
|
|
|
+ new_attr.event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask |
|
|
|
+ ButtonReleaseMask | EnterWindowMask |
|
|
|
+ LeaveWindowMask | PointerMotionMask |
|
|
|
+ Button1MotionMask |
|
|
|
+ Button2MotionMask | Button3MotionMask |
|
|
|
+ Button4MotionMask | Button5MotionMask |
|
|
|
+ ButtonMotionMask | KeymapStateMask |
|
|
|
+ ExposureMask | VisibilityChangeMask |
|
|
|
+ StructureNotifyMask |
|
|
|
+ SubstructureNotifyMask | SubstructureRedirectMask |
|
|
|
+ FocusChangeMask | PropertyChangeMask |
|
|
|
+ ColormapChangeMask | OwnerGrabButtonMask |
|
|
|
+ im_event_mask;
|
|
|
+
|
|
|
+ XChangeWindowAttributes(x11_display, wd.x11_window, CWEventMask, &new_attr);
|
|
|
+
|
|
|
+ static unsigned char all_mask_data[XIMaskLen(XI_LASTEVENT)] = {};
|
|
|
+
|
|
|
+ all_event_mask.deviceid = XIAllDevices;
|
|
|
+ all_event_mask.mask_len = sizeof(all_mask_data);
|
|
|
+ all_event_mask.mask = all_mask_data;
|
|
|
+
|
|
|
+ XISetMask(all_event_mask.mask, XI_HierarchyChanged);
|
|
|
+
|
|
|
+#ifdef TOUCH_ENABLED
|
|
|
+ if (xi.touch_devices.size()) {
|
|
|
+ XISetMask(all_event_mask.mask, XI_TouchBegin);
|
|
|
+ XISetMask(all_event_mask.mask, XI_TouchUpdate);
|
|
|
+ XISetMask(all_event_mask.mask, XI_TouchEnd);
|
|
|
+ XISetMask(all_event_mask.mask, XI_TouchOwnership);
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+ XISelectEvents(x11_display, wd.x11_window, &all_event_mask, 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* set the titlebar name */
|
|
|
+ XStoreName(x11_display, wd.x11_window, "Godot");
|
|
|
+ XSetWMProtocols(x11_display, wd.x11_window, &wm_delete, 1);
|
|
|
+ XChangeProperty(x11_display, wd.x11_window, xdnd_aware, XA_ATOM, 32, PropModeReplace, (unsigned char *)&xdnd_version, 1);
|
|
|
+
|
|
|
+ if (xim && xim_style) {
|
|
|
+
|
|
|
+ wd.xic = XCreateIC(xim, XNInputStyle, xim_style, XNClientWindow, wd.x11_window, XNFocusWindow, wd.x11_window, (char *)NULL);
|
|
|
+ if (XGetICValues(wd.xic, XNFilterEvents, &im_event_mask, NULL) != NULL) {
|
|
|
+ WARN_PRINT("XGetICValues couldn't obtain XNFilterEvents value");
|
|
|
+ XDestroyIC(wd.xic);
|
|
|
+ wd.xic = NULL;
|
|
|
+ }
|
|
|
+ if (wd.xic) {
|
|
|
+ XUnsetICFocus(wd.xic);
|
|
|
+ } else {
|
|
|
+ WARN_PRINT("XCreateIC couldn't create wd.xic");
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+
|
|
|
+ wd.xic = NULL;
|
|
|
+ WARN_PRINT("XCreateIC couldn't create wd.xic");
|
|
|
+ }
|
|
|
+
|
|
|
+ id = window_id_counter++;
|
|
|
+
|
|
|
+ windows[id] = wd;
|
|
|
+ }
|
|
|
+
|
|
|
+ WindowData &wd = windows[id];
|
|
|
+
|
|
|
+ window_set_mode(p_mode, id);
|
|
|
+
|
|
|
+ //set cursor
|
|
|
+ if (cursors[current_cursor] != None) {
|
|
|
+
|
|
|
+ XDefineCursor(x11_display, wd.x11_window, cursors[current_cursor]);
|
|
|
+ }
|
|
|
+ return id;
|
|
|
+}
|
|
|
+
|
|
|
+DisplayServerX11::DisplayServerX11(const String &p_video_driver, WindowMode p_mode, uint32_t p_flags, const Vector2i &p_resolution, Error &r_error) {
|
|
|
+
|
|
|
+ r_error = OK;
|
|
|
+
|
|
|
+ last_button_state = 0;
|
|
|
+
|
|
|
+ xmbstring = NULL;
|
|
|
+
|
|
|
+ last_click_ms = 0;
|
|
|
+ last_click_button_index = -1;
|
|
|
+ last_click_pos = Point2i(-100, -100);
|
|
|
+
|
|
|
+ last_timestamp = 0;
|
|
|
+ last_mouse_pos_valid = false;
|
|
|
+ last_keyrelease_time = 0;
|
|
|
+
|
|
|
+ if (OS::get_singleton()->get_render_thread_mode() == OS::RENDER_SEPARATE_THREAD) {
|
|
|
+ XInitThreads();
|
|
|
+ }
|
|
|
+
|
|
|
+ /** XLIB INITIALIZATION **/
|
|
|
+ x11_display = XOpenDisplay(NULL);
|
|
|
+
|
|
|
+ if (!x11_display) {
|
|
|
+ ERR_PRINT("X11 Display is not available");
|
|
|
+ r_error = ERR_UNAVAILABLE;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ char *modifiers = NULL;
|
|
|
+ Bool xkb_dar = False;
|
|
|
+ XAutoRepeatOn(x11_display);
|
|
|
+ xkb_dar = XkbSetDetectableAutoRepeat(x11_display, True, NULL);
|
|
|
+
|
|
|
+ // Try to support IME if detectable auto-repeat is supported
|
|
|
+ if (xkb_dar == True) {
|
|
|
+
|
|
|
+#ifdef X_HAVE_UTF8_STRING
|
|
|
+ // Xutf8LookupString will be used later instead of XmbLookupString before
|
|
|
+ // the multibyte sequences can be converted to unicode string.
|
|
|
+ modifiers = XSetLocaleModifiers("");
|
|
|
+#endif
|
|
|
+ }
|
|
|
+
|
|
|
+ if (modifiers == NULL) {
|
|
|
+ if (OS::get_singleton()->is_stdout_verbose()) {
|
|
|
+ WARN_PRINT("IME is disabled");
|
|
|
+ }
|
|
|
+ XSetLocaleModifiers("@im=none");
|
|
|
+ WARN_PRINT("Error setting locale modifiers");
|
|
|
+ }
|
|
|
+
|
|
|
+ const char *err;
|
|
|
+ xrr_get_monitors = NULL;
|
|
|
+ xrr_free_monitors = NULL;
|
|
|
+ int xrandr_major = 0;
|
|
|
+ int xrandr_minor = 0;
|
|
|
+ int event_base, error_base;
|
|
|
+ xrandr_ext_ok = XRRQueryExtension(x11_display, &event_base, &error_base);
|
|
|
+ xrandr_handle = dlopen("libXrandr.so.2", RTLD_LAZY);
|
|
|
+ if (!xrandr_handle) {
|
|
|
+ err = dlerror();
|
|
|
+ fprintf(stderr, "could not load libXrandr.so.2, Error: %s\n", err);
|
|
|
+ } else {
|
|
|
+ XRRQueryVersion(x11_display, &xrandr_major, &xrandr_minor);
|
|
|
+ if (((xrandr_major << 8) | xrandr_minor) >= 0x0105) {
|
|
|
+ xrr_get_monitors = (xrr_get_monitors_t)dlsym(xrandr_handle, "XRRGetMonitors");
|
|
|
+ if (!xrr_get_monitors) {
|
|
|
+ err = dlerror();
|
|
|
+ fprintf(stderr, "could not find symbol XRRGetMonitors\nError: %s\n", err);
|
|
|
+ } else {
|
|
|
+ xrr_free_monitors = (xrr_free_monitors_t)dlsym(xrandr_handle, "XRRFreeMonitors");
|
|
|
+ if (!xrr_free_monitors) {
|
|
|
+ err = dlerror();
|
|
|
+ fprintf(stderr, "could not find XRRFreeMonitors\nError: %s\n", err);
|
|
|
+ xrr_get_monitors = NULL;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!_refresh_device_info()) {
|
|
|
+ OS::get_singleton()->alert("Your system does not support XInput 2.\n"
|
|
|
+ "Please upgrade your distribution.",
|
|
|
+ "Unable to initialize XInput");
|
|
|
+ r_error = ERR_UNAVAILABLE;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ xim = XOpenIM(x11_display, NULL, NULL, NULL);
|
|
|
+
|
|
|
+ if (xim == NULL) {
|
|
|
+ WARN_PRINT("XOpenIM failed");
|
|
|
+ xim_style = 0L;
|
|
|
+ } else {
|
|
|
+ ::XIMCallback im_destroy_callback;
|
|
|
+ im_destroy_callback.client_data = (::XPointer)(this);
|
|
|
+ im_destroy_callback.callback = (::XIMProc)(_xim_destroy_callback);
|
|
|
+ if (XSetIMValues(xim, XNDestroyCallback, &im_destroy_callback,
|
|
|
+ NULL) != NULL) {
|
|
|
+ WARN_PRINT("Error setting XIM destroy callback");
|
|
|
+ }
|
|
|
+
|
|
|
+ ::XIMStyles *xim_styles = NULL;
|
|
|
+ xim_style = 0L;
|
|
|
+ char *imvalret = XGetIMValues(xim, XNQueryInputStyle, &xim_styles, NULL);
|
|
|
+ if (imvalret != NULL || xim_styles == NULL) {
|
|
|
+ fprintf(stderr, "Input method doesn't support any styles\n");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (xim_styles) {
|
|
|
+ xim_style = 0L;
|
|
|
+ for (int i = 0; i < xim_styles->count_styles; i++) {
|
|
|
+
|
|
|
+ if (xim_styles->supported_styles[i] ==
|
|
|
+ (XIMPreeditNothing | XIMStatusNothing)) {
|
|
|
+
|
|
|
+ xim_style = xim_styles->supported_styles[i];
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ XFree(xim_styles);
|
|
|
+ }
|
|
|
+ XFree(imvalret);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Atorm internment */
|
|
|
+ wm_delete = XInternAtom(x11_display, "WM_DELETE_WINDOW", true);
|
|
|
+ //Set Xdnd (drag & drop) support
|
|
|
+ xdnd_aware = XInternAtom(x11_display, "XdndAware", False);
|
|
|
+ xdnd_version = 5;
|
|
|
+ xdnd_enter = XInternAtom(x11_display, "XdndEnter", False);
|
|
|
+ xdnd_position = XInternAtom(x11_display, "XdndPosition", False);
|
|
|
+ xdnd_status = XInternAtom(x11_display, "XdndStatus", False);
|
|
|
+ xdnd_action_copy = XInternAtom(x11_display, "XdndActionCopy", False);
|
|
|
+ xdnd_drop = XInternAtom(x11_display, "XdndDrop", False);
|
|
|
+ xdnd_finished = XInternAtom(x11_display, "XdndFinished", False);
|
|
|
+ xdnd_selection = XInternAtom(x11_display, "XdndSelection", False);
|
|
|
+
|
|
|
+ //!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
+ //TODO - do Vulkan and GLES2 support checks, driver selection and fallback
|
|
|
+ video_driver = p_video_driver;
|
|
|
+
|
|
|
+#ifndef _MSC_VER
|
|
|
+#warning Forcing vulkan video driver because OpenGL not implemented yet
|
|
|
+#endif
|
|
|
+ video_driver = "vulkan";
|
|
|
+
|
|
|
+#if defined(VULKAN_ENABLED)
|
|
|
+ if (video_driver == "vulkan") {
|
|
|
+
|
|
|
+ context_vulkan = memnew(VulkanContextX11);
|
|
|
+ if (context_vulkan->initialize() != OK) {
|
|
|
+ memdelete(context_vulkan);
|
|
|
+ context_vulkan = NULL;
|
|
|
+ r_error = ERR_CANT_CREATE;
|
|
|
+ ERR_FAIL_MSG("Could not initialize Vulkan");
|
|
|
+ }
|
|
|
+
|
|
|
+ //temporary
|
|
|
+ rendering_device_vulkan = memnew(RenderingDeviceVulkan);
|
|
|
+ rendering_device_vulkan->initialize(context_vulkan);
|
|
|
+
|
|
|
+ RasterizerRD::make_current();
|
|
|
+ }
|
|
|
+#endif
|
|
|
+ // Init context and rendering device
|
|
|
+#if defined(OPENGL_ENABLED)
|
|
|
+ if (video_driver == "opengl_es") {
|
|
|
+ if (getenv("DRI_PRIME") == NULL) {
|
|
|
+ int use_prime = -1;
|
|
|
+
|
|
|
+ if (getenv("PRIMUS_DISPLAY") ||
|
|
|
+ getenv("PRIMUS_libGLd") ||
|
|
|
+ getenv("PRIMUS_libGLa") ||
|
|
|
+ getenv("PRIMUS_libGL") ||
|
|
|
+ getenv("PRIMUS_LOAD_GLOBAL") ||
|
|
|
+ getenv("BUMBLEBEE_SOCKET")) {
|
|
|
+
|
|
|
+ print_verbose("Optirun/primusrun detected. Skipping GPU detection");
|
|
|
+ use_prime = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (getenv("LD_LIBRARY_PATH")) {
|
|
|
+ String ld_library_path(getenv("LD_LIBRARY_PATH"));
|
|
|
+ Vector<String> libraries = ld_library_path.split(":");
|
|
|
+
|
|
|
+ for (int i = 0; i < libraries.size(); ++i) {
|
|
|
+ if (FileAccess::exists(libraries[i] + "/libGL.so.1") ||
|
|
|
+ FileAccess::exists(libraries[i] + "/libGL.so")) {
|
|
|
+
|
|
|
+ print_verbose("Custom libGL override detected. Skipping GPU detection");
|
|
|
+ use_prime = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (use_prime == -1) {
|
|
|
+ print_verbose("Detecting GPUs, set DRI_PRIME in the environment to override GPU detection logic.");
|
|
|
+ use_prime = detect_prime();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (use_prime) {
|
|
|
+ print_line("Found discrete GPU, setting DRI_PRIME=1 to use it.");
|
|
|
+ print_line("Note: Set DRI_PRIME=0 in the environment to disable Godot from using the discrete GPU.");
|
|
|
+ setenv("DRI_PRIME", "1", 1);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ContextGL_X11::ContextType opengl_api_type = ContextGL_X11::GLES_2_0_COMPATIBLE;
|
|
|
+
|
|
|
+ context_gles2 = memnew(ContextGL_X11(x11_display, x11_window, current_videomode, opengl_api_type));
|
|
|
+
|
|
|
+ if (context_gles2->initialize() != OK) {
|
|
|
+ memdelete(context_gles2);
|
|
|
+ context_gles2 = NULL;
|
|
|
+ ERR_FAIL_V(ERR_UNAVAILABLE);
|
|
|
+ }
|
|
|
+
|
|
|
+ context_gles2->set_use_vsync(current_videomode.use_vsync);
|
|
|
+
|
|
|
+ if (RasterizerGLES2::is_viable() == OK) {
|
|
|
+ RasterizerGLES2::register_config();
|
|
|
+ RasterizerGLES2::make_current();
|
|
|
+ } else {
|
|
|
+ memdelete(context_gles2);
|
|
|
+ context_gles2 = NULL;
|
|
|
+ ERR_FAIL_V(ERR_UNAVAILABLE);
|
|
|
+ }
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+ WindowID main_window = _create_window(p_mode, p_resolution);
|
|
|
+ for (int i = 0; i < WINDOW_FLAG_MAX; i++) {
|
|
|
+ if (p_flags & (1 << i)) {
|
|
|
+ window_set_flag(WindowFlags(i), true, main_window);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /*
|
|
|
+ visual_server = memnew(VisualServerRaster);
|
|
|
+ if (get_render_thread_mode() != RENDER_THREAD_UNSAFE) {
|
|
|
+ visual_server = memnew(VisualServerWrapMT(visual_server, get_render_thread_mode() == RENDER_SEPARATE_THREAD));
|
|
|
+ }
|
|
|
+ */
|
|
|
+
|
|
|
+ {
|
|
|
+ //set all event master mask
|
|
|
+ XIEventMask all_master_event_mask;
|
|
|
+ static unsigned char all_master_mask_data[XIMaskLen(XI_LASTEVENT)] = {};
|
|
|
+ all_master_event_mask.deviceid = XIAllMasterDevices;
|
|
|
+ all_master_event_mask.mask_len = sizeof(all_master_mask_data);
|
|
|
+ all_master_event_mask.mask = all_master_mask_data;
|
|
|
+ XISetMask(all_master_event_mask.mask, XI_DeviceChanged);
|
|
|
+ XISetMask(all_master_event_mask.mask, XI_RawMotion);
|
|
|
+ XISelectEvents(x11_display, DefaultRootWindow(x11_display), &all_master_event_mask, 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ // Disabled by now since grabbing also blocks mouse events
|
|
|
+ // (they are received as extended events instead of standard events)
|
|
|
+ /*XIClearMask(xi.touch_event_mask.mask, XI_TouchOwnership);
|
|
|
+
|
|
|
+ // Grab touch devices to avoid OS gesture interference
|
|
|
+ for (int i = 0; i < xi.touch_devices.size(); ++i) {
|
|
|
+ XIGrabDevice(x11_display, xi.touch_devices[i], x11_window, CurrentTime, None, XIGrabModeAsync, XIGrabModeAsync, False, &xi.touch_event_mask);
|
|
|
+ }*/
|
|
|
+
|
|
|
+ cursor_size = XcursorGetDefaultSize(x11_display);
|
|
|
+ cursor_theme = XcursorGetTheme(x11_display);
|
|
|
+
|
|
|
+ if (!cursor_theme) {
|
|
|
+ print_verbose("XcursorGetTheme could not get cursor theme");
|
|
|
+ cursor_theme = "default";
|
|
|
+ }
|
|
|
+
|
|
|
+ for (int i = 0; i < CURSOR_MAX; i++) {
|
|
|
+
|
|
|
+ cursors[i] = None;
|
|
|
+ img[i] = NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ current_cursor = CURSOR_ARROW;
|
|
|
+
|
|
|
+ for (int i = 0; i < CURSOR_MAX; i++) {
|
|
|
+
|
|
|
+ static const char *cursor_file[] = {
|
|
|
+ "left_ptr",
|
|
|
+ "xterm",
|
|
|
+ "hand2",
|
|
|
+ "cross",
|
|
|
+ "watch",
|
|
|
+ "left_ptr_watch",
|
|
|
+ "fleur",
|
|
|
+ "dnd-move",
|
|
|
+ "crossed_circle",
|
|
|
+ "v_double_arrow",
|
|
|
+ "h_double_arrow",
|
|
|
+ "size_bdiag",
|
|
|
+ "size_fdiag",
|
|
|
+ "move",
|
|
|
+ "row_resize",
|
|
|
+ "col_resize",
|
|
|
+ "question_arrow"
|
|
|
+ };
|
|
|
+
|
|
|
+ img[i] = XcursorLibraryLoadImage(cursor_file[i], cursor_theme, cursor_size);
|
|
|
+ if (!img[i]) {
|
|
|
+ const char *fallback = NULL;
|
|
|
+
|
|
|
+ switch (i) {
|
|
|
+ case CURSOR_POINTING_HAND:
|
|
|
+ fallback = "pointer";
|
|
|
+ break;
|
|
|
+ case CURSOR_CROSS:
|
|
|
+ fallback = "crosshair";
|
|
|
+ break;
|
|
|
+ case CURSOR_WAIT:
|
|
|
+ fallback = "wait";
|
|
|
+ break;
|
|
|
+ case CURSOR_BUSY:
|
|
|
+ fallback = "progress";
|
|
|
+ break;
|
|
|
+ case CURSOR_DRAG:
|
|
|
+ fallback = "grabbing";
|
|
|
+ break;
|
|
|
+ case CURSOR_CAN_DROP:
|
|
|
+ fallback = "hand1";
|
|
|
+ break;
|
|
|
+ case CURSOR_FORBIDDEN:
|
|
|
+ fallback = "forbidden";
|
|
|
+ break;
|
|
|
+ case CURSOR_VSIZE:
|
|
|
+ fallback = "ns-resize";
|
|
|
+ break;
|
|
|
+ case CURSOR_HSIZE:
|
|
|
+ fallback = "ew-resize";
|
|
|
+ break;
|
|
|
+ case CURSOR_BDIAGSIZE:
|
|
|
+ fallback = "fd_double_arrow";
|
|
|
+ break;
|
|
|
+ case CURSOR_FDIAGSIZE:
|
|
|
+ fallback = "bd_double_arrow";
|
|
|
+ break;
|
|
|
+ case CURSOR_MOVE:
|
|
|
+ img[i] = img[CURSOR_DRAG];
|
|
|
+ break;
|
|
|
+ case CURSOR_VSPLIT:
|
|
|
+ fallback = "sb_v_double_arrow";
|
|
|
+ break;
|
|
|
+ case CURSOR_HSPLIT:
|
|
|
+ fallback = "sb_h_double_arrow";
|
|
|
+ break;
|
|
|
+ case CURSOR_HELP:
|
|
|
+ fallback = "help";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if (fallback != NULL) {
|
|
|
+ img[i] = XcursorLibraryLoadImage(fallback, cursor_theme, cursor_size);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (img[i]) {
|
|
|
+ cursors[i] = XcursorImageLoadCursor(x11_display, img[i]);
|
|
|
+ } else {
|
|
|
+ print_verbose("Failed loading custom cursor: " + String(cursor_file[i]));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ {
|
|
|
+ // Creating an empty/transparent cursor
|
|
|
+
|
|
|
+ // Create 1x1 bitmap
|
|
|
+ Pixmap cursormask = XCreatePixmap(x11_display,
|
|
|
+ RootWindow(x11_display, DefaultScreen(x11_display)), 1, 1, 1);
|
|
|
+
|
|
|
+ // Fill with zero
|
|
|
+ XGCValues xgc;
|
|
|
+ xgc.function = GXclear;
|
|
|
+ GC gc = XCreateGC(x11_display, cursormask, GCFunction, &xgc);
|
|
|
+ XFillRectangle(x11_display, cursormask, gc, 0, 0, 1, 1);
|
|
|
+
|
|
|
+ // Color value doesn't matter. Mask zero means no foreground or background will be drawn
|
|
|
+ XColor col = {};
|
|
|
+
|
|
|
+ Cursor cursor = XCreatePixmapCursor(x11_display,
|
|
|
+ cursormask, // source (using cursor mask as placeholder, since it'll all be ignored)
|
|
|
+ cursormask, // mask
|
|
|
+ &col, &col, 0, 0);
|
|
|
+
|
|
|
+ XFreePixmap(x11_display, cursormask);
|
|
|
+ XFreeGC(x11_display, gc);
|
|
|
+
|
|
|
+ if (cursor == None) {
|
|
|
+ ERR_PRINT("FAILED CREATING CURSOR");
|
|
|
+ }
|
|
|
+
|
|
|
+ null_cursor = cursor;
|
|
|
+ }
|
|
|
+ cursor_set_shape(CURSOR_BUSY);
|
|
|
+
|
|
|
+ requested = None;
|
|
|
+
|
|
|
+ visual_server->init();
|
|
|
+
|
|
|
+ window_has_focus = true; // Set focus to true at init
|
|
|
+
|
|
|
+ /*if (p_desired.layered) {
|
|
|
+ set_window_per_pixel_transparency_enabled(true);
|
|
|
+ }*/
|
|
|
+
|
|
|
+ XEvent xevent;
|
|
|
+ while (XPending(x11_display) > 0) {
|
|
|
+ XNextEvent(x11_display, &xevent);
|
|
|
+ if (xevent.type == ConfigureNotify) {
|
|
|
+ _window_changed(&xevent);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ _update_real_mouse_position(windows[MAIN_WINDOW_ID]);
|
|
|
+
|
|
|
+ r_error = OK;
|
|
|
+}
|
|
|
+DisplayServerX11::~DisplayServerX11() {
|
|
|
+}
|
|
|
+
|
|
|
+#endif // X11 enabled
|
Juan Linietsky