godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/platform/x11/os_x11.cpp

4091 lines
116 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* os_x11.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 12:16:55 +00:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/*************************************************************************/
Update copyright statements to 2021 Happy new year to the wonderful Godot community! 2020 has been a tough year for most of us personally, but a good year for Godot development nonetheless with a huge amount of work done towards Godot 4.0 and great improvements backported to the long-lived 3.2 branch. We've had close to 400 contributors to engine code this year, authoring near 7,000 commit! (And that's only for the `master` branch and for the engine code, there's a lot more when counting docs, demos and other first-party repos.) Here's to a great year 2021 for all Godot users 🎆 (cherry picked from commit b5334d14f7a471f94bcbd64d5bae2ad853d0b7f1)
2021-01-01 19:13:46 +00:00
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/* */
/* 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. */
/*************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-04 23:50:27 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#include "os_x11.h"
Properly detect when to use DRI_PRIME We fork off twice once with and once without DIR_PRIME=1 set. We then use the vendor string to determine what GPU to use. We prefer (in order) 1) AMDGPU/AMDGPU-PRO/NVidia non-free driver 2) Intel driver 3) Nouveau 4) Software rendering If a driver can't be detected it will default to DRI_PRIME=0
2019-01-27 22:31:38 +00:00
Make core/ includes absolute, remove subfolders from include path This allows more consistency in the manner we include core headers, where previously there would be a mix of absolute, relative and include path-dependent includes.
2018-09-11 16:13:45 +00:00
#include "core/os/dir_access.h"
#include "core/print_string.h"
X11: Ensure XGetWindowProperty data gets freed Fixes a small memory leak reported by lsan: ``` Direct leak of 73 byte(s) in 1 object(s) allocated from: #0 0x7f29825f3e70 in malloc (/lib64/liblsan.so.0+0xee70) #1 0x7f29824a5729 in XGetWindowProperty (/lib64/libX11.so.6+0x29729) ```
2020-06-29 11:02:34 +00:00
#include "detect_prime.h"
add GLES 2 renderer for 2D This commit adds a new rendering backend, GLES2, and adds a project setting to enable it. Currently this backend can only be used on the X11 platform, but integrating into other platforms is planned.
2017-12-04 12:41:34 +00:00
#include "drivers/gles2/rasterizer_gles2.h"
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#include "drivers/gles3/rasterizer_gles3.h"
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#include "key_mapping_x11.h"
X11: Ensure XGetWindowProperty data gets freed Fixes a small memory leak reported by lsan: ``` Direct leak of 73 byte(s) in 1 object(s) allocated from: #0 0x7f29825f3e70 in malloc (/lib64/liblsan.so.0+0xee70) #1 0x7f29824a5729 in XGetWindowProperty (/lib64/libX11.so.6+0x29729) ```
2020-06-29 11:02:34 +00:00
#include "main/main.h"
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#include "servers/visual/visual_server_raster.h"
-Restored multithread capability to VisualServer -Restored resource previews!
2017-06-09 03:23:50 +00:00
#include "servers/visual/visual_server_wrap_mt.h"
Fix BSD compile issues
2017-10-17 16:50:41 +00:00
#ifdef HAVE_MNTENT
FileSystemDock will now remove files/dirs to trashcan using OS::move_to_trash
2017-09-25 13:15:11 +00:00
#include <mntent.h>
Fix BSD compile issues
2017-10-17 16:50:41 +00:00
#endif
X11: Ensure XGetWindowProperty data gets freed Fixes a small memory leak reported by lsan: ``` Direct leak of 73 byte(s) in 1 object(s) allocated from: #0 0x7f29825f3e70 in malloc (/lib64/liblsan.so.0+0xee70) #1 0x7f29824a5729 in XGetWindowProperty (/lib64/libX11.so.6+0x29729) ```
2020-06-29 11:02:34 +00:00
#include <errno.h>
X11: Include limits.h for LONG_MAX Fixes #44030. (cherry picked from commit f1a9de9c592c4643a5cf0886d0ec5482e25212f7)
2020-12-02 14:43:29 +00:00
#include <limits.h>
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#include <stdio.h>
#include <stdlib.h>
Include string.h for memset() on OpenBSD
2014-11-19 21:16:00 +00:00
#include <string.h>
ability to run 2D physics in a thread also, 2D physics is now thread safe too. see physics_2d/thread_model
2015-05-26 04:05:08 +00:00
X11: Ensure XGetWindowProperty data gets freed Fixes a small memory leak reported by lsan: ``` Direct leak of 73 byte(s) in 1 object(s) allocated from: #0 0x7f29825f3e70 in malloc (/lib64/liblsan.so.0+0xee70) #1 0x7f29824a5729 in XGetWindowProperty (/lib64/libX11.so.6+0x29729) ```
2020-06-29 11:02:34 +00:00
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#include <X11/extensions/Xinerama.h>
[3.2] Add window click-through support.
2020-06-29 09:31:13 +00:00
#include <X11/extensions/shape.h>
fixes to new window management API -needs testing on Linux -needs testing on Windows -NEED SOMEONE TO IMPLEMENT IT ON OSX!! PLEASE HELP!
2015-03-22 22:00:50 +00:00
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
// ICCCM
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#define WM_NormalState 1L // window normal state
#define WM_IconicState 3L // window minimized
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
// EWMH
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#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
fixes to new window management API -needs testing on Linux -needs testing on Windows -NEED SOMEONE TO IMPLEMENT IT ON OSX!! PLEASE HELP!
2015-03-22 22:00:50 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#include <dlfcn.h>
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#include <fcntl.h>
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#include <sys/stat.h>
#include <sys/types.h>
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#include <unistd.h>
Only include linux/joystick.h on linux
2014-02-23 20:20:27 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//stupid linux.h
#ifdef KEY_TAB
#undef KEY_TAB
#endif
#undef CursorShape
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
#include <X11/XKBlib.h>
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
// 2.2 is the first release with multitouch
#define XINPUT_CLIENT_VERSION_MAJOR 2
#define XINPUT_CLIENT_VERSION_MINOR 2
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
#define VALUATOR_ABSX 0
#define VALUATOR_ABSY 1
#define VALUATOR_PRESSURE 2
#define VALUATOR_TILTX 3
#define VALUATOR_TILTY 4
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
static const double abs_resolution_mult = 10000.0;
static const double abs_resolution_range_mult = 10.0;
Added a crash handler to dump the backtrace on Windows, Linux and OS X
2017-09-08 01:01:49 +00:00
void OS_X11::initialize_core() {
crash_handler.initialize();
OS_Unix::initialize_core();
}
-Project/Editor settings now use new inspector -Project/Editor settings now show tooltips properly -Settings thar require restart now will show a restart warning -Video driver is now visible all the time, can be changed easily -Added function to request current video driver
2018-07-19 21:58:15 +00:00
int OS_X11::get_current_video_driver() const {
return video_driver_index;
}
Change OS::initialize signature to return Error (fix segfault on x11)
2018-01-03 17:26:44 +00:00
Error OS_X11::initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver) {
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
long im_event_mask = 0;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
last_button_state = 0;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
xmbstring = nullptr;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
x11_window = 0;
last_click_ms = 0;
Added double clicking to all buttons
2018-07-20 16:16:09 +00:00
last_click_button_index = -1;
last_click_pos = Point2(-100, -100);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
args = OS::get_singleton()->get_cmdline_args();
current_videomode = p_desired;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
main_loop = nullptr;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
last_timestamp = 0;
last_mouse_pos_valid = false;
last_keyrelease_time = 0;
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
xdnd_version = 0;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
XInitThreads();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/** XLIB INITIALIZATION **/
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
x11_display = XOpenDisplay(nullptr);
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Change OS::initialize signature to return Error (fix segfault on x11)
2018-01-03 17:26:44 +00:00
if (!x11_display) {
ERR_PRINT("X11 Display is not available");
return ERR_UNAVAILABLE;
}
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
char *modifiers = nullptr;
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
Bool xkb_dar = False;
Change OS::initialize signature to return Error (fix segfault on x11)
2018-01-03 17:26:44 +00:00
XAutoRepeatOn(x11_display);
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
xkb_dar = XkbSetDetectableAutoRepeat(x11_display, True, nullptr);
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
Change OS::initialize signature to return Error (fix segfault on x11)
2018-01-03 17:26:44 +00:00
// Try to support IME if detectable auto-repeat is supported
if (xkb_dar == True) {
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
#ifdef X_HAVE_UTF8_STRING
Change OS::initialize signature to return Error (fix segfault on x11)
2018-01-03 17:26:44 +00:00
// Xutf8LookupString will be used later instead of XmbLookupString before
// the multibyte sequences can be converted to unicode string.
modifiers = XSetLocaleModifiers("");
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
#endif
}
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
if (modifiers == nullptr) {
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
if (is_stdout_verbose()) {
WARN_PRINT("IME is disabled");
}
Some code changed with Clang-Tidy
2019-06-26 13:08:25 +00:00
XSetLocaleModifiers("@im=none");
Avoid crash if setting modifiers fails, closes #5158
2016-07-08 14:26:48 +00:00
WARN_PRINT("Error setting locale modifiers");
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const char *err;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
xrr_get_monitors = nullptr;
xrr_free_monitors = nullptr;
x11: fix XRandr GetMonitors
2016-06-12 13:29:02 +00:00
int xrandr_major = 0;
int xrandr_minor = 0;
int event_base, error_base;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
xrandr_ext_ok = XRRQueryExtension(x11_display, &event_base, &error_base);
x11: Use proper sonames for loading libXrandr.
2016-08-11 15:25:13 +00:00
xrandr_handle = dlopen("libXrandr.so.2", RTLD_LAZY);
x11: Implemented dpi detection depends on XRandR. Had to dynamically load `XRRGetMonitors` as Ubuntu 12.04 doesn't have it. Also removed libudev from travis install list.
2016-06-09 16:54:06 +00:00
if (!xrandr_handle) {
x11: Use proper sonames for loading libXrandr.
2016-08-11 15:25:13 +00:00
err = dlerror();
X11: Try to load libXrandr.so.3 if libXrandr.so.2 isn't found All Linux distros, and FreeBSD and OpenBSD seem to have libXrandr.so.2, but for some reason recent NetBSD versions seem to have libXrandr.so.3 now. (cherry picked from commit 413ff7938df54c6c0bf6dc3ecd86c2c713f6f43a)
2020-09-18 09:55:12 +00:00
// For some arcane reason, NetBSD now ships libXrandr.so.3 while the rest of the world has libXrandr.so.2...
// In case this happens for other X11 platforms in the future, let's give it a try too before failing.
xrandr_handle = dlopen("libXrandr.so.3", RTLD_LAZY);
if (!xrandr_handle) {
fprintf(stderr, "could not load libXrandr.so.2, Error: %s\n", err);
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else {
x11: fix XRandr GetMonitors
2016-06-12 13:29:02 +00:00
XRRQueryVersion(x11_display, &xrandr_major, &xrandr_minor);
if (((xrandr_major << 8) | xrandr_minor) >= 0x0105) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
xrr_get_monitors = (xrr_get_monitors_t)dlsym(xrandr_handle, "XRRGetMonitors");
x11: fix XRandr GetMonitors
2016-06-12 13:29:02 +00:00
if (!xrr_get_monitors) {
err = dlerror();
fprintf(stderr, "could not find symbol XRRGetMonitors\nError: %s\n", err);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else {
xrr_free_monitors = (xrr_free_monitors_t)dlsym(xrandr_handle, "XRRFreeMonitors");
x11: fix XRandr GetMonitors
2016-06-12 13:29:02 +00:00
if (!xrr_free_monitors) {
err = dlerror();
fprintf(stderr, "could not find XRRFreeMonitors\nError: %s\n", err);
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
xrr_get_monitors = nullptr;
x11: fix XRandr GetMonitors
2016-06-12 13:29:02 +00:00
}
}
}
x11: Implemented dpi detection depends on XRandR. Had to dynamically load `XRRGetMonitors` as Ubuntu 12.04 doesn't have it. Also removed libudev from travis install list.
2016-06-09 16:54:06 +00:00
}
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
if (!refresh_device_info()) {
OS::get_singleton()->alert("Your system does not support XInput 2.\n"
"Please upgrade your distribution.",
"Unable to initialize XInput");
return ERR_UNAVAILABLE;
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
}
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
xim = XOpenIM(x11_display, nullptr, nullptr, nullptr);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
if (xim == nullptr) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
WARN_PRINT("XOpenIM failed");
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
xim_style = 0L;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} else {
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
::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,
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
NULL) != nullptr) {
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
WARN_PRINT("Error setting XIM destroy callback");
}
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
::XIMStyles *xim_styles = nullptr;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
xim_style = 0L;
Removed unnecessary assignments
2017-08-21 19:15:36 +00:00
char *imvalret = XGetIMValues(xim, XNQueryInputStyle, &xim_styles, NULL);
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
if (imvalret != nullptr || xim_styles == nullptr) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
fprintf(stderr, "Input method doesn't support any styles\n");
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (xim_styles) {
fixing the warnings in os_x11.cpp
2015-01-16 05:44:41 +00:00
xim_style = 0L;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < xim_styles->count_styles; i++) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (xim_styles->supported_styles[i] ==
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
(XIMPreeditNothing | XIMStatusNothing)) {
xim_style = xim_styles->supported_styles[i];
break;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XFree(xim_styles);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XFree(imvalret);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
/*
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
char* windowid = getenv("GODOT_WINDOWID");
if (windowid) {
//freopen("/home/punto/stdout", "w", stdout);
//reopen("/home/punto/stderr", "w", stderr);
x11_window = atol(windowid);
XWindowAttributes xwa;
XGetWindowAttributes(x11_display,x11_window,&xwa);
current_videomode.width = xwa.width;
current_videomode.height = xwa.height;
};
*/
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
// maybe contextgl wants to be in charge of creating the window
Drop unusued LEGACYGL_ENABLED check [ci skip]
2017-10-12 22:18:04 +00:00
#if defined(OPENGL_ENABLED)
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
if (getenv("DRI_PRIME") == nullptr) {
Detect when primusrun/optirun is in use It seems that bumblebee doesn't like us creating multiple GL contexts to avoid this we now detect whether we're running with this software and don't do anything.
2019-02-14 15:25:37 +00:00
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;
}
Linux: Fix PRIME detection on Steam To avoid trying to do PRIME detection on fake `libGL.so` as used by e.g. Renderdoc or Primus, we skip detection if there's a `libGL.so` in `LD_LIBRARY_PATH`... and our luck is that Steam defines it and includes system paths too, thus the actual system `libGL`... 🤦 So if we detect Steam, we skip this check. Co-authored-by: Hein-Pieter van Braam-Stewart <hp@tmm.cx> (cherry picked from commit 562b1cd2cda2098e62c7501dae87393def99c23a)
2021-03-08 15:03:24 +00:00
// Some tools use fake libGL libraries and have them override the real one using
// LD_LIBRARY_PATH, so we skip them. *But* Steam also sets LD_LIBRARY_PATH for its
// runtime and includes system `/lib` and `/lib64`... so ignore Steam.
if (use_prime == -1 && getenv("LD_LIBRARY_PATH") && !getenv("STEAM_RUNTIME_LIBRARY_PATH")) {
Detect when primusrun/optirun is in use It seems that bumblebee doesn't like us creating multiple GL contexts to avoid this we now detect whether we're running with this software and don't do anything.
2019-02-14 15:25:37 +00:00
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();
}
Properly detect when to use DRI_PRIME We fork off twice once with and once without DIR_PRIME=1 set. We then use the vendor string to determine what GPU to use. We prefer (in order) 1) AMDGPU/AMDGPU-PRO/NVidia non-free driver 2) Intel driver 3) Nouveau 4) Software rendering If a driver can't be detected it will default to DRI_PRIME=0
2019-01-27 22:31:38 +00:00
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);
Don't enable DRI_PRIME if nouveau is loaded
2018-12-20 10:51:26 +00:00
}
}
First attempt of restoring the window at the old position
2015-01-10 17:07:23 +00:00
add GLES 2 renderer for 2D This commit adds a new rendering backend, GLES2, and adds a project setting to enable it. Currently this backend can only be used on the X11 platform, but integrating into other platforms is planned.
2017-12-04 12:41:34 +00:00
ContextGL_X11::ContextType opengl_api_type = ContextGL_X11::GLES_3_0_COMPATIBLE;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fix `--help` output, allow renderer override from command line (`--video-driver`).
2018-03-01 21:17:34 +00:00
if (p_video_driver == VIDEO_DRIVER_GLES2) {
add GLES 2 renderer for 2D This commit adds a new rendering backend, GLES2, and adds a project setting to enable it. Currently this backend can only be used on the X11 platform, but integrating into other platforms is planned.
2017-12-04 12:41:34 +00:00
opengl_api_type = ContextGL_X11::GLES_2_0_COMPATIBLE;
}
Fall back to GLES2 if GLES3 is not working This adds a static is_viable() method to all rasterizers which has to be called before initializing the rasterizer. This allows us to check what rasterizer to use in OS::initialize together with the GL context initialization. This commit also adds a new project setting "rendering/quality/driver/driver_fallback" which allows the creator of a project to specify whether or not fallback to GLES2 is allowed. This setting is ignored for the editor so the editor will always open even if the project itself cannot run. This will hopefully reduce confusion for users downloading projects from the internet. We also no longer crash when GLES3 is not functioning on a platform. This fixes #15324
2018-08-24 22:04:25 +00:00
bool editor = Engine::get_singleton()->is_editor_hint();
bool gl_initialization_error = false;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
context_gl = nullptr;
Fall back to GLES2 if GLES3 is not working This adds a static is_viable() method to all rasterizers which has to be called before initializing the rasterizer. This allows us to check what rasterizer to use in OS::initialize together with the GL context initialization. This commit also adds a new project setting "rendering/quality/driver/driver_fallback" which allows the creator of a project to specify whether or not fallback to GLES2 is allowed. This setting is ignored for the editor so the editor will always open even if the project itself cannot run. This will hopefully reduce confusion for users downloading projects from the internet. We also no longer crash when GLES3 is not functioning on a platform. This fixes #15324
2018-08-24 22:04:25 +00:00
while (!context_gl) {
context_gl = memnew(ContextGL_X11(x11_display, x11_window, current_videomode, opengl_api_type));
if (context_gl->initialize() != OK) {
memdelete(context_gl);
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
context_gl = nullptr;
Fall back to GLES2 if GLES3 is not working This adds a static is_viable() method to all rasterizers which has to be called before initializing the rasterizer. This allows us to check what rasterizer to use in OS::initialize together with the GL context initialization. This commit also adds a new project setting "rendering/quality/driver/driver_fallback" which allows the creator of a project to specify whether or not fallback to GLES2 is allowed. This setting is ignored for the editor so the editor will always open even if the project itself cannot run. This will hopefully reduce confusion for users downloading projects from the internet. We also no longer crash when GLES3 is not functioning on a platform. This fixes #15324
2018-08-24 22:04:25 +00:00
Disable driver fallback to GLES2 by default GLES2 is not designed to be a drop-in replacement for the GLES3 backend, so the fallback mode has to be used knowingly. It *can* make sense for simple projects which make sure to handle the differences between both rendering backends, but most users should stick to one supported backend. By making it opt-in, we can now use this parameter to define whether to export ETC textures to Android and iOS when using GLES3 + Fallback. When using GLES3 without Fallback on Android, set the proper min GLES version in the AndroidManifest. Also made the option boolean and renamed it for clarity and to avoid conflict with the previous String option (which would always evaluate as "true" otherwise). Fixes #26569.
2019-03-05 12:46:51 +00:00
if (GLOBAL_GET("rendering/quality/driver/fallback_to_gles2") || editor) {
Fall back to GLES2 if GLES3 is not working This adds a static is_viable() method to all rasterizers which has to be called before initializing the rasterizer. This allows us to check what rasterizer to use in OS::initialize together with the GL context initialization. This commit also adds a new project setting "rendering/quality/driver/driver_fallback" which allows the creator of a project to specify whether or not fallback to GLES2 is allowed. This setting is ignored for the editor so the editor will always open even if the project itself cannot run. This will hopefully reduce confusion for users downloading projects from the internet. We also no longer crash when GLES3 is not functioning on a platform. This fixes #15324
2018-08-24 22:04:25 +00:00
if (p_video_driver == VIDEO_DRIVER_GLES2) {
gl_initialization_error = true;
break;
}
p_video_driver = VIDEO_DRIVER_GLES2;
opengl_api_type = ContextGL_X11::GLES_2_0_COMPATIBLE;
} else {
gl_initialization_error = true;
break;
}
}
}
while (true) {
if (opengl_api_type == ContextGL_X11::GLES_3_0_COMPATIBLE) {
if (RasterizerGLES3::is_viable() == OK) {
RasterizerGLES3::register_config();
RasterizerGLES3::make_current();
break;
} else {
Disable driver fallback to GLES2 by default GLES2 is not designed to be a drop-in replacement for the GLES3 backend, so the fallback mode has to be used knowingly. It *can* make sense for simple projects which make sure to handle the differences between both rendering backends, but most users should stick to one supported backend. By making it opt-in, we can now use this parameter to define whether to export ETC textures to Android and iOS when using GLES3 + Fallback. When using GLES3 without Fallback on Android, set the proper min GLES version in the AndroidManifest. Also made the option boolean and renamed it for clarity and to avoid conflict with the previous String option (which would always evaluate as "true" otherwise). Fixes #26569.
2019-03-05 12:46:51 +00:00
if (GLOBAL_GET("rendering/quality/driver/fallback_to_gles2") || editor) {
Fall back to GLES2 if GLES3 is not working This adds a static is_viable() method to all rasterizers which has to be called before initializing the rasterizer. This allows us to check what rasterizer to use in OS::initialize together with the GL context initialization. This commit also adds a new project setting "rendering/quality/driver/driver_fallback" which allows the creator of a project to specify whether or not fallback to GLES2 is allowed. This setting is ignored for the editor so the editor will always open even if the project itself cannot run. This will hopefully reduce confusion for users downloading projects from the internet. We also no longer crash when GLES3 is not functioning on a platform. This fixes #15324
2018-08-24 22:04:25 +00:00
p_video_driver = VIDEO_DRIVER_GLES2;
opengl_api_type = ContextGL_X11::GLES_2_0_COMPATIBLE;
continue;
} else {
gl_initialization_error = true;
break;
}
}
}
if (opengl_api_type == ContextGL_X11::GLES_2_0_COMPATIBLE) {
if (RasterizerGLES2::is_viable() == OK) {
RasterizerGLES2::register_config();
RasterizerGLES2::make_current();
break;
} else {
gl_initialization_error = true;
break;
}
}
add GLES 2 renderer for 2D This commit adds a new rendering backend, GLES2, and adds a project setting to enable it. Currently this backend can only be used on the X11 platform, but integrating into other platforms is planned.
2017-12-04 12:41:34 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fall back to GLES2 if GLES3 is not working This adds a static is_viable() method to all rasterizers which has to be called before initializing the rasterizer. This allows us to check what rasterizer to use in OS::initialize together with the GL context initialization. This commit also adds a new project setting "rendering/quality/driver/driver_fallback" which allows the creator of a project to specify whether or not fallback to GLES2 is allowed. This setting is ignored for the editor so the editor will always open even if the project itself cannot run. This will hopefully reduce confusion for users downloading projects from the internet. We also no longer crash when GLES3 is not functioning on a platform. This fixes #15324
2018-08-24 22:04:25 +00:00
if (gl_initialization_error) {
OS::get_singleton()->alert("Your video card driver does not support any of the supported OpenGL versions.\n"
Point at software OpenGL when OpenGL fails to initialize on X11
2021-08-05 16:23:33 +00:00
"Please update your drivers or if you have a very old or integrated GPU, upgrade it.\n"
Mention that rebooting is required after updating graphics driver on X11
2021-09-15 16:25:49 +00:00
"If you have updated your graphics drivers recently, try rebooting.\n"
Point at software OpenGL when OpenGL fails to initialize on X11
2021-08-05 16:23:33 +00:00
"Alternatively, you can force software rendering by running Godot with the `LIBGL_ALWAYS_SOFTWARE=1`\n"
"environment variable set, but this will be very slow.",
Fall back to GLES2 if GLES3 is not working This adds a static is_viable() method to all rasterizers which has to be called before initializing the rasterizer. This allows us to check what rasterizer to use in OS::initialize together with the GL context initialization. This commit also adds a new project setting "rendering/quality/driver/driver_fallback" which allows the creator of a project to specify whether or not fallback to GLES2 is allowed. This setting is ignored for the editor so the editor will always open even if the project itself cannot run. This will hopefully reduce confusion for users downloading projects from the internet. We also no longer crash when GLES3 is not functioning on a platform. This fixes #15324
2018-08-24 22:04:25 +00:00
"Unable to initialize Video driver");
return ERR_UNAVAILABLE;
}
video_driver_index = p_video_driver;
-Project/Editor settings now use new inspector -Project/Editor settings now show tooltips properly -Settings thar require restart now will show a restart warning -Video driver is now visible all the time, can be changed easily -Added function to request current video driver
2018-07-19 21:58:15 +00:00
Fixes vsync setting ignored when using a separate thread for rendering Setting the vsync in the main thread, after the rendering thread starts and takes the OpenGL context fails, so we need to do that before. Also, for some reason, the main thread cannot make current the context anymore. Fixes #13447
2017-12-08 16:58:28 +00:00
context_gl->set_use_vsync(current_videomode.use_vsync);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 19:33:42 +00:00
#endif
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fix init of VisualServerRaster Contrarily to what #23434 assumed, this is not a memory leak, the VisualServerRaster instance is passed as a parameter to VisualServerWrapMT's constructor. Fixes #23437.
2018-11-01 18:22:15 +00:00
visual_server = memnew(VisualServerRaster);
-Restored multithread capability to VisualServer -Restored resource previews!
2017-06-09 03:23:50 +00:00
if (get_render_thread_mode() != RENDER_THREAD_UNSAFE) {
visual_server = memnew(VisualServerWrapMT(visual_server, get_render_thread_mode() == RENDER_SEPARATE_THREAD));
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Fix init of VisualServerRaster Contrarily to what #23434 assumed, this is not a memory leak, the VisualServerRaster instance is passed as a parameter to VisualServerWrapMT's constructor. Fixes #23437.
2018-11-01 18:22:15 +00:00
Fix x11 boot logo position in fullscreen and in maximized
2017-10-24 19:35:28 +00:00
if (current_videomode.maximized) {
current_videomode.maximized = false;
set_window_maximized(true);
// borderless fullscreen window mode
} else if (current_videomode.fullscreen) {
current_videomode.fullscreen = false;
set_window_fullscreen(true);
Implemented borderless window functions on Linux.
2017-07-05 15:19:24 +00:00
} else if (current_videomode.borderless_window) {
Hints hints;
Atom property;
hints.flags = 2;
hints.decorations = 0;
property = XInternAtom(x11_display, "_MOTIF_WM_HINTS", True);
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
if (property != None) {
XChangeProperty(x11_display, x11_window, property, property, 32, PropModeReplace, (unsigned char *)&hints, 5);
}
borderless fullscreen window support for x11 move disable resize x11 code from context_gl to os_x11
2014-08-25 06:54:10 +00:00
}
[X11] set PID as window attribute This allows other programs to find out the PID of a Godot instance just by the X11 window ID.
2019-09-11 08:13:48 +00:00
// make PID known to X11
{
const long pid = this->get_process_id();
Atom net_wm_pid = XInternAtom(x11_display, "_NET_WM_PID", False);
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
if (net_wm_pid != None) {
XChangeProperty(x11_display, x11_window, net_wm_pid, XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&pid, 1);
}
[X11] set PID as window attribute This allows other programs to find out the PID of a Godot instance just by the X11 window ID.
2019-09-11 08:13:48 +00:00
}
WIP -- set_resizable() + is_resizable added
2015-01-15 13:50:23 +00:00
// disable resizable window
Fix X11 running a project with fullscreen setting on and resizable off with multiple screens
2018-11-19 02:03:54 +00:00
if (!current_videomode.resizable && !current_videomode.fullscreen) {
borderless fullscreen window support for x11 move disable resize x11 code from context_gl to os_x11
2014-08-25 06:54:10 +00:00
XSizeHints *xsh;
xsh = XAllocSizeHints();
xsh->flags = PMinSize | PMaxSize;
XWindowAttributes xwa;
if (current_videomode.fullscreen) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XGetWindowAttributes(x11_display, DefaultRootWindow(x11_display), &xwa);
cleanup
2014-09-16 06:49:31 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XGetWindowAttributes(x11_display, x11_window, &xwa);
borderless fullscreen window support for x11 move disable resize x11 code from context_gl to os_x11
2014-08-25 06:54:10 +00:00
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
xsh->min_width = xwa.width;
borderless fullscreen window support for x11 move disable resize x11 code from context_gl to os_x11
2014-08-25 06:54:10 +00:00
xsh->max_width = xwa.width;
xsh->min_height = xwa.height;
xsh->max_height = xwa.height;
XSetWMNormalHints(x11_display, x11_window, xsh);
WIP -- set_resizable() + is_resizable added
2015-01-15 13:50:23 +00:00
XFree(xsh);
borderless fullscreen window support for x11 move disable resize x11 code from context_gl to os_x11
2014-08-25 06:54:10 +00:00
}
* multi_screen testing + bugfixes * ALT-TAB is working * tested on Ubuntu 14.10 Unity + LXDE * minor cleanup
2015-01-17 15:28:04 +00:00
Add new window setting: always on top Implemented for Windows and Linux.
2017-12-27 19:51:19 +00:00
if (current_videomode.always_on_top) {
current_videomode.always_on_top = false;
set_window_always_on_top(true);
}
Change OS::initialize signature to return Error (fix segfault on x11)
2018-01-03 17:26:44 +00:00
ERR_FAIL_COND_V(!visual_server, ERR_UNAVAILABLE);
ERR_FAIL_COND_V(x11_window == 0, ERR_UNAVAILABLE);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
XSetWindowAttributes new_attr;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
new_attr.event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask |
clang-format: Disable alignment of operands, too unreliable Sets `AlignOperands` to `DontAlign`. `clang-format` developers seem to mostly care about space-based indentation and every other version of clang-format breaks the bad mismatch of tabs and spaces that it seems to use for operand alignment. So it's better without, so that it respects our two-tabs `ContinuationIndentWidth`.
2021-10-28 11:23:24 +00:00
ButtonReleaseMask | EnterWindowMask |
LeaveWindowMask | PointerMotionMask |
Button1MotionMask |
Button2MotionMask | Button3MotionMask |
Button4MotionMask | Button5MotionMask |
ButtonMotionMask | KeymapStateMask |
ExposureMask | VisibilityChangeMask |
StructureNotifyMask |
SubstructureNotifyMask | SubstructureRedirectMask |
FocusChangeMask | PropertyChangeMask |
ColormapChangeMask | OwnerGrabButtonMask |
im_event_mask;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XChangeWindowAttributes(x11_display, x11_window, CWEventMask, &new_attr);
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
static unsigned char all_mask_data[XIMaskLen(XI_LASTEVENT)] = {};
static unsigned char all_master_mask_data[XIMaskLen(XI_LASTEVENT)] = {};
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
xi.all_event_mask.deviceid = XIAllDevices;
xi.all_event_mask.mask_len = sizeof(all_mask_data);
xi.all_event_mask.mask = all_mask_data;
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
xi.all_master_event_mask.deviceid = XIAllMasterDevices;
xi.all_master_event_mask.mask_len = sizeof(all_master_mask_data);
xi.all_master_event_mask.mask = all_master_mask_data;
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
XISetMask(xi.all_event_mask.mask, XI_HierarchyChanged);
XISetMask(xi.all_master_event_mask.mask, XI_DeviceChanged);
XISetMask(xi.all_master_event_mask.mask, XI_RawMotion);
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
#ifdef TOUCH_ENABLED
if (xi.touch_devices.size()) {
XISetMask(xi.all_event_mask.mask, XI_TouchBegin);
XISetMask(xi.all_event_mask.mask, XI_TouchUpdate);
XISetMask(xi.all_event_mask.mask, XI_TouchEnd);
XISetMask(xi.all_event_mask.mask, XI_TouchOwnership);
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
}
#endif
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
XISelectEvents(x11_display, x11_window, &xi.all_event_mask, 1);
XISelectEvents(x11_display, DefaultRootWindow(x11_display), &xi.all_master_event_mask, 1);
WIP -- set_resizable() + is_resizable added
2015-01-15 13:50:23 +00:00
/* set the titlebar name */
XStoreName(x11_display, x11_window, "Godot");
added XClassHint to windows in OS_X11::initialize for improved window management in x11.
2014-05-22 06:05:05 +00:00
remove trailing whitespace
2016-03-08 23:00:52 +00:00
wm_delete = XInternAtom(x11_display, "WM_DELETE_WINDOW", true);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
XSetWMProtocols(x11_display, x11_window, &wm_delete, 1);
remove trailing whitespace
2016-03-08 23:00:52 +00:00
IME context detection.
2018-06-07 20:16:57 +00:00
im_active = false;
im_position = Vector2();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (xim && xim_style) {
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
xic = XCreateIC(xim, XNInputStyle, xim_style, XNClientWindow, x11_window, XNFocusWindow, x11_window, (char *)nullptr);
if (XGetICValues(xic, XNFilterEvents, &im_event_mask, NULL) != nullptr) {
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
WARN_PRINT("XGetICValues couldn't obtain XNFilterEvents value");
XDestroyIC(xic);
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
xic = nullptr;
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
}
if (xic) {
IME context detection.
2018-06-07 20:16:57 +00:00
XUnsetICFocus(xic);
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
} else {
WARN_PRINT("XCreateIC couldn't create xic");
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} else {
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
xic = nullptr;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
WARN_PRINT("XCreateIC couldn't create xic");
remove trailing whitespace
2016-03-08 23:00:52 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
cursor_size = XcursorGetDefaultSize(x11_display);
cursor_theme = XcursorGetTheme(x11_display);
if (!cursor_theme) {
Add print_verbose to print to stdout only in verbose mode Equivalent of the cumbersome: if (OS::get_singleton()->is_stdout_verbose()) print_line(msg);
2018-08-24 06:47:34 +00:00
print_verbose("XcursorGetTheme could not get cursor theme");
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
cursor_theme = "default";
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < CURSOR_MAX; i++) {
cursors[i] = None;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
img[i] = nullptr;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
current_cursor = CURSOR_ARROW;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Small fixes to static analyzer bugs
2019-04-04 20:00:16 +00:00
for (int i = 0; i < CURSOR_MAX; i++) {
static const char *cursor_file[] = {
"left_ptr",
"xterm",
"hand2",
"cross",
"watch",
"left_ptr_watch",
"fleur",
"hand1",
"X_cursor",
"sb_v_double_arrow",
"sb_h_double_arrow",
"size_bdiag",
"size_fdiag",
"hand1",
"sb_v_double_arrow",
"sb_h_double_arrow",
"question_arrow"
};
img[i] = XcursorLibraryLoadImage(cursor_file[i], 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]));
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
}
{
Fixed uninitialised variable in x11 null cursor creation Fully initialised color var. Clarified intent a little with comments/layout.
2019-05-23 10:47:28 +00:00
// Creating an empty/transparent cursor
// Create 1x1 bitmap
Pixmap cursormask = XCreatePixmap(x11_display,
RootWindow(x11_display, DefaultScreen(x11_display)), 1, 1, 1);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fixed uninitialised variable in x11 null cursor creation Fully initialised color var. Clarified intent a little with comments/layout.
2019-05-23 10:47:28 +00:00
// Fill with zero
XGCValues xgc;
Fixing memory leaks
2015-10-25 14:15:56 +00:00
xgc.function = GXclear;
Fixed uninitialised variable in x11 null cursor creation Fully initialised color var. Clarified intent a little with comments/layout.
2019-05-23 10:47:28 +00:00
GC gc = XCreateGC(x11_display, cursormask, GCFunction, &xgc);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
XFillRectangle(x11_display, cursormask, gc, 0, 0, 1, 1);
Fixed uninitialised variable in x11 null cursor creation Fully initialised color var. Clarified intent a little with comments/layout.
2019-05-23 10:47:28 +00:00
// 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
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
&col, &col, 0, 0);
Fixed uninitialised variable in x11 null cursor creation Fully initialised color var. Clarified intent a little with comments/layout.
2019-05-23 10:47:28 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XFreePixmap(x11_display, cursormask);
XFreeGC(x11_display, gc);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (cursor == None) {
ERR_PRINT("FAILED CREATING CURSOR");
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
null_cursor = cursor;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
set_cursor_shape(CURSOR_BUSY);
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
//Set Xdnd (drag & drop) support
Atom XdndAware = XInternAtom(x11_display, "XdndAware", False);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Atom version = 5;
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
if (XdndAware != None) {
XChangeProperty(x11_display, x11_window, XdndAware, XA_ATOM, 32, PropModeReplace, (unsigned char *)&version, 1);
}
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
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);
requested = None;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
visual_server->init();
Fall back to GLES2 if GLES3 is not working This adds a static is_viable() method to all rasterizers which has to be called before initializing the rasterizer. This allows us to check what rasterizer to use in OS::initialize together with the GL context initialization. This commit also adds a new project setting "rendering/quality/driver/driver_fallback" which allows the creator of a project to specify whether or not fallback to GLES2 is allowed. This setting is ignored for the editor so the editor will always open even if the project itself cannot run. This will hopefully reduce confusion for users downloading projects from the internet. We also no longer crash when GLES3 is not functioning on a platform. This fixes #15324
2018-08-24 22:04:25 +00:00
AudioDriverManager::initialize(p_audio_driver);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
input = memnew(InputDefault);
Added focus tracking in X11 and Windows classes, added new confined mouse mode (#7162)
2017-01-25 18:21:41 +00:00
window_has_focus = true; // Set focus to true at init
Check pkg-config for libudev and enable gamepad code only if found. Linux only for now
2015-12-21 21:39:03 +00:00
#ifdef JOYDEV_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
joypad = memnew(JoypadLinux(input));
Better gamepad support
2015-12-18 05:12:53 +00:00
#endif
Fixes power management on x11 platform and removes explicit NULL pointer dereference.
2017-07-26 21:29:51 +00:00
power_manager = memnew(PowerX11);
Fix x11 boot logo position in fullscreen and in maximized
2017-10-24 19:35:28 +00:00
Removes redundant "display/window/per_pixel_transparency/splash" setting, improves per pixel transparency documentation.
2019-06-04 08:21:29 +00:00
if (p_desired.layered) {
Experimental support for windows with per-pixel transparency (macOS, X11 and Windows).
2017-12-10 18:38:26 +00:00
set_window_per_pixel_transparency_enabled(true);
}
Fix x11 boot logo position in fullscreen and in maximized
2017-10-24 19:35:28 +00:00
XEvent xevent;
X11: Process entire event queue at startup. Should fix #14336
2017-12-09 22:21:34 +00:00
while (XPending(x11_display) > 0) {
XNextEvent(x11_display, &xevent);
if (xevent.type == ConfigureNotify) {
_window_changed(&xevent);
}
Fix x11 boot logo position in fullscreen and in maximized
2017-10-24 19:35:28 +00:00
}
X11: Add missing return in OS_X11::initialize().
2018-01-05 11:10:47 +00:00
Modernize Thread - Based on C++11's `thread` and `thread_local` - No more need to allocate-deallocate or check for null - No pointer anymore, just a member variable - Platform-specific implementations no longer needed (except for the few cases of non-portable functions) - Simpler for `NO_THREADS` - Thread ids are now the same across platforms (main is 1; others follow)
2021-01-27 19:10:10 +00:00
events_thread.start(_poll_events_thread, this);
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
Update X11 global mouse position at startup When we start the engine we haven't yet gotten any X11 motion events so we don't yet know where our mouse cursor is located. Instead we now query the X server for this information when we start and update the appropriate values. In addition when we move the window we also update the mouse position based off of X server knowledge as we will also not have received any mouse motion events. this fixes #8145 (for X11 only)
2018-09-09 20:13:50 +00:00
update_real_mouse_position();
X11: Add missing return in OS_X11::initialize().
2018-01-05 11:10:47 +00:00
return OK;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Fixing memory leaks
2015-10-25 14:15:56 +00:00
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
bool OS_X11::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];
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (!dev->enabled) {
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
continue;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
if (!(dev->use == XIMasterPointer || dev->use == XIFloatingSlave)) {
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
continue;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
bool direct_touch = false;
bool absolute_mode = false;
int resolution_x = 0;
int resolution_y = 0;
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
double abs_x_min = 0;
double abs_x_max = 0;
double abs_y_min = 0;
double abs_y_max = 0;
double pressure_min = 0;
double pressure_max = 0;
double tilt_x_min = 0;
double tilt_x_max = 0;
double tilt_y_min = 0;
double tilt_y_max = 0;
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
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];
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
if (class_info->number == VALUATOR_ABSX && class_info->mode == XIModeAbsolute) {
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
resolution_x = class_info->resolution;
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
abs_x_min = class_info->min;
abs_y_max = class_info->max;
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
absolute_mode = true;
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
} else if (class_info->number == VALUATOR_ABSY && class_info->mode == XIModeAbsolute) {
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
resolution_y = class_info->resolution;
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
abs_y_min = class_info->min;
abs_y_max = class_info->max;
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
absolute_mode = true;
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
} else if (class_info->number == VALUATOR_PRESSURE && class_info->mode == XIModeAbsolute) {
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
pressure_min = class_info->min;
pressure_max = class_info->max;
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
} else if (class_info->number == VALUATOR_TILTX && class_info->mode == XIModeAbsolute) {
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
tilt_x_min = class_info->min;
tilt_x_max = class_info->max;
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
} else if (class_info->number == VALUATOR_TILTY && class_info->mode == XIModeAbsolute) {
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
tilt_x_min = class_info->min;
tilt_x_max = class_info->max;
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
}
}
}
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) {
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
resolution_x = (abs_x_max - abs_x_min) * abs_resolution_range_mult;
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
}
if (resolution_y <= 0) {
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
resolution_y = (abs_y_max - abs_y_min) * abs_resolution_range_mult;
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
}
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));
}
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
xi.pressure = 0;
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
xi.pen_pressure_range[dev->deviceid] = Vector2(pressure_min, pressure_max);
xi.pen_tilt_x_range[dev->deviceid] = Vector2(tilt_x_min, tilt_x_max);
xi.pen_tilt_y_range[dev->deviceid] = Vector2(tilt_y_min, tilt_y_max);
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
}
XIFreeDeviceInfo(info);
#ifdef TOUCH_ENABLED
if (!xi.touch_devices.size()) {
print_verbose("XInput: No touch devices found.");
}
#endif
return true;
}
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
void OS_X11::xim_destroy_callback(::XIM im, ::XPointer client_data,
::XPointer call_data) {
WARN_PRINT("Input method stopped");
OS_X11 *os = reinterpret_cast<OS_X11 *>(client_data);
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
os->xim = nullptr;
os->xic = nullptr;
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
}
IME context detection.
2018-06-07 20:16:57 +00:00
void OS_X11::set_ime_active(const bool p_active) {
im_active = p_active;
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
if (!xic) {
IME context detection.
2018-06-07 20:16:57 +00:00
return;
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
}
IME context detection.
2018-06-07 20:16:57 +00:00
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
// Block events polling while changing input focus
// because it triggers some event polling internally.
IME context detection.
2018-06-07 20:16:57 +00:00
if (p_active) {
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
{
MutexLock mutex_lock(events_mutex);
XSetICFocus(xic);
}
IME context detection.
2018-06-07 20:16:57 +00:00
set_ime_position(im_position);
} else {
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
MutexLock mutex_lock(events_mutex);
IME context detection.
2018-06-07 20:16:57 +00:00
XUnsetICFocus(xic);
}
}
IME window follow the input cursor. Abstruct set_ime_position to OS class. Update ime position for LineEdit and TextEdit.
2017-06-25 15:50:45 +00:00
void OS_X11::set_ime_position(const Point2 &p_pos) {
IME context detection.
2018-06-07 20:16:57 +00:00
im_position = p_pos;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (!xic) {
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
IME window follow the input cursor. Abstruct set_ime_position to OS class. Update ime position for LineEdit and TextEdit.
2017-06-25 15:50:45 +00:00
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
::XPoint spot;
IME window follow the input cursor. Abstruct set_ime_position to OS class. Update ime position for LineEdit and TextEdit.
2017-06-25 15:50:45 +00:00
spot.x = short(p_pos.x);
spot.y = short(p_pos.y);
XVaNestedList preedit_attr = XVaCreateNestedList(0, XNSpotLocation, &spot, NULL);
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
{
// Block events polling during this call
// because it triggers some event polling internally.
MutexLock mutex_lock(events_mutex);
XSetICValues(xic, XNPreeditAttributes, preedit_attr, NULL);
}
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
XFree(preedit_attr);
}
X11: implement OS.get_unique_id
2018-01-20 13:42:19 +00:00
String OS_X11::get_unique_id() const {
static String machine_id;
if (machine_id.empty()) {
if (FileAccess *f = FileAccess::open("/etc/machine-id", FileAccess::READ)) {
while (machine_id.empty() && !f->eof_reached()) {
machine_id = f->get_line().strip_edges();
}
f->close();
memdelete(f);
}
}
return machine_id;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
void OS_X11::finalize() {
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
events_thread_done = true;
Modernize Thread - Based on C++11's `thread` and `thread_local` - No more need to allocate-deallocate or check for null - No pointer anymore, just a member variable - Platform-specific implementations no longer needed (except for the few cases of non-portable functions) - Simpler for `NO_THREADS` - Thread ids are now the same across platforms (main is 1; others follow)
2021-01-27 19:10:10 +00:00
events_thread.wait_to_finish();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (main_loop) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
memdelete(main_loop);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
main_loop = nullptr;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Style: Apply new clang-format 5.0 style to all files
2017-12-06 20:36:34 +00:00
/*
Style: Fix whole-line commented code They do not play well with clang-format which aligns the `//` part with the rest of the code block, thus producing badly indented commented code.
2017-01-14 11:26:56 +00:00
if (debugger_connection_console) {
memdelete(debugger_connection_console);
}
*/
Added a new MIDIDriver class
2018-07-14 12:11:28 +00:00
#ifdef ALSAMIDI_ENABLED
driver_alsamidi.close();
#endif
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
fix x11 crash on exit
2016-01-05 22:35:54 +00:00
#ifdef JOYDEV_ENABLED
renamed joystick to joypad everywhere around source code!
2017-01-08 20:05:51 +00:00
memdelete(joypad);
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
#endif
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
xi.touch_devices.clear();
xi.state.clear();
-Fix parsing of comments in VariantParser, fixes #3175
2015-12-31 13:25:21 +00:00
memdelete(input);
Fix crash caused by a9a0d0fb15cc5e028dbf8dab8b46d3dc197c4678
2019-07-24 17:57:59 +00:00
cursors_cache.clear();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
visual_server->finish();
memdelete(visual_server);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 19:33:42 +00:00
//memdelete(rasterizer);
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Fixed several memory leaks
2017-08-24 16:51:28 +00:00
memdelete(power_manager);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (xrandr_handle) {
x11: Implemented dpi detection depends on XRandR. Had to dynamically load `XRRGetMonitors` as Ubuntu 12.04 doesn't have it. Also removed libudev from travis install list.
2016-06-09 16:54:06 +00:00
dlclose(xrandr_handle);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
x11: Implemented dpi detection depends on XRandR. Had to dynamically load `XRRGetMonitors` as Ubuntu 12.04 doesn't have it. Also removed libudev from travis install list.
2016-06-09 16:54:06 +00:00
Implement no-window mode for X11 and MacOS Bonus: Homogeinize and improve OS::alert() for no-window mode
2020-09-23 11:43:51 +00:00
if (!OS::get_singleton()->is_no_window_mode_enabled()) {
XUnmapWindow(x11_display, x11_window);
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XDestroyWindow(x11_display, x11_window);
Fixing memory leaks
2015-10-25 14:15:56 +00:00
Drop unusued LEGACYGL_ENABLED check [ci skip]
2017-10-12 22:18:04 +00:00
#if defined(OPENGL_ENABLED)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
memdelete(context_gl);
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < CURSOR_MAX; i++) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (cursors[i] != None) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XFreeCursor(x11_display, cursors[i]);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
if (img[i] != nullptr) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XcursorImageDestroy(img[i]);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
};
Fixing memory leaks
2015-10-25 14:15:56 +00:00
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
if (xic) {
XDestroyIC(xic);
}
if (xim) {
XCloseIM(xim);
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
XCloseDisplay(x11_display);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (xmbstring) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
memfree(xmbstring);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Fixing memory leaks
2015-10-25 14:15:56 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
args.clear();
}
Add off-screen GL context
2021-09-24 12:07:44 +00:00
bool OS_X11::is_offscreen_gl_available() const {
#if defined(OPENGL_ENABLED)
return context_gl->is_offscreen_available();
#else
return false;
#endif
}
void OS_X11::set_offscreen_gl_current(bool p_current) {
#if defined(OPENGL_ENABLED)
if (p_current) {
return context_gl->make_offscreen_current();
} else {
return context_gl->release_offscreen_current();
}
#endif
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
void OS_X11::set_mouse_mode(MouseMode p_mode) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (p_mode == mouse_mode) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (mouse_mode == MOUSE_MODE_CAPTURED || mouse_mode == MOUSE_MODE_CONFINED) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
XUngrabPointer(x11_display, CurrentTime);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Added focus tracking in X11 and Windows classes, added new confined mouse mode (#7162)
2017-01-25 18:21:41 +00:00
// The only modes that show a cursor are VISIBLE and CONFINED
bool showCursor = (p_mode == MOUSE_MODE_VISIBLE || p_mode == MOUSE_MODE_CONFINED);
if (showCursor) {
Fix custom cursor when it's hidden [Linux] Ensures that the custom cursor will be used when changing to MOUSE_MODE_VISIBLE. Fix #3086 [Windows] Fix cursor flickering when MOUSE_MODE_HIDDEN. [Mac] Fix possible cursor flicker when MOUSE_MODE_HIDDEN.
2018-04-09 00:59:51 +00:00
XDefineCursor(x11_display, x11_window, cursors[current_cursor]); // show cursor
Added focus tracking in X11 and Windows classes, added new confined mouse mode (#7162)
2017-01-25 18:21:41 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XDefineCursor(x11_display, x11_window, null_cursor); // hide cursor
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
mouse_mode = p_mode;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (mouse_mode == MOUSE_MODE_CAPTURED || mouse_mode == MOUSE_MODE_CONFINED) {
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
//flush pending motion events
flush_mouse_motion();
-fixes to capture mode -ability to drag spinboxes and tree ranges to change values, like in Unity or Unreal
2015-08-29 04:43:21 +00:00
Style: Various fixes to play nice with clang-format
2017-01-15 21:15:47 +00:00
if (XGrabPointer(
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
x11_display, x11_window, True,
ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
GrabModeAsync, GrabModeAsync, x11_window, None, CurrentTime) != GrabSuccess) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
ERR_PRINT("NO GRAB");
}
Fixes to mouse mode confined and captured These modes will work on Linux in the same way as Windows.
2018-09-04 13:11:37 +00:00
if (mouse_mode == MOUSE_MODE_CAPTURED) {
center.x = current_videomode.width / 2;
center.y = current_videomode.height / 2;
XWarpPointer(x11_display, None, x11_window,
0, 0, 0, 0, (int)center.x, (int)center.y);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fixes to mouse mode confined and captured These modes will work on Linux in the same way as Windows.
2018-09-04 13:11:37 +00:00
input->set_mouse_position(center);
}
-fixes to capture mode -ability to drag spinboxes and tree ranges to change values, like in Unity or Unreal
2015-08-29 04:43:21 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
do_mouse_warp = false;
cleanup + MouseGrab
2015-02-12 14:58:00 +00:00
}
x11: Flush the X output buffer after changing mouse mode
2016-04-12 14:20:28 +00:00
XFlush(x11_display);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Rename pos to position in user facing methods and variables Rename user facing methods and variables as well as the corresponding C++ methods according to the folloming changes: * pos -> position * rot -> rotation * loc -> location C++ variables are left as is.
2017-09-10 13:37:49 +00:00
void OS_X11::warp_mouse_position(const Point2 &p_to) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (mouse_mode == MOUSE_MODE_CAPTURED) {
last_mouse_pos = p_to;
- more fixes on #672 on windows - added #660, but need help on osx, help please I don't have a mac! - fixed #667 and #668 (eol detection in comments) - added #670 (hint when using method without () )
2014-09-20 00:01:41 +00:00
} else {
fixes to mouse warp -can warp now from viewport and control, in their respective coordinate systems -warp is now local to the window on Windows and OSX. IF YOU RUN OSX, PLEASE TEST THIS! And make sure it works!, new code is in OS_OSX::warp_mouse_pos. I don't have OSX so i can't test!
2015-02-14 22:22:06 +00:00
/*XWindowAttributes xwa;
XGetWindowAttributes(x11_display, x11_window, &xwa);
printf("%d %d\n", xwa.x, xwa.y); needed? */
- more fixes on #672 on windows - added #660, but need help on osx, help please I don't have a mac! - fixed #667 and #668 (eol detection in comments) - added #670 (hint when using method without () )
2014-09-20 00:01:41 +00:00
XWarpPointer(x11_display, None, x11_window,
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
0, 0, 0, 0, (int)p_to.x, (int)p_to.y);
- more fixes on #672 on windows - added #660, but need help on osx, help please I don't have a mac! - fixed #667 and #668 (eol detection in comments) - added #670 (hint when using method without () )
2014-09-20 00:01:41 +00:00
}
}
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
void OS_X11::flush_mouse_motion() {
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
// Block events polling while flushing motion events.
MutexLock mutex_lock(events_mutex);
for (uint32_t event_index = 0; event_index < polled_events.size(); ++event_index) {
XEvent &event = polled_events[event_index];
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) {
XFreeEventData(x11_display, &event.xcookie);
polled_events.remove(event_index--);
continue;
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
}
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
XFreeEventData(x11_display, &event.xcookie);
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
break;
}
}
xi.relative_motion.x = 0;
xi.relative_motion.y = 0;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
OS::MouseMode OS_X11::get_mouse_mode() const {
return mouse_mode;
}
int OS_X11::get_mouse_button_state() const {
return last_button_state;
}
Rename [gs]et_pos to [gs]et_position for Controls Control set_pos -> set_position Control set_global_pos -> set_global_position [gs]et_mouse_pos -> [gs]et_mouse_position [gs]et_global_mouse_pos -> [gs]et_global_mouse_position fixes #8005
2017-03-29 15:29:38 +00:00
Point2 OS_X11::get_mouse_position() const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return last_mouse_pos;
}
Experimental support for windows with per-pixel transparency (macOS, X11 and Windows).
2017-12-10 18:38:26 +00:00
bool OS_X11::get_window_per_pixel_transparency_enabled() const {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (!is_layered_allowed()) {
Style: clang-format: Disable AllowShortIfStatementsOnASingleLine
2021-05-04 12:28:27 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Experimental support for windows with per-pixel transparency (macOS, X11 and Windows).
2017-12-10 18:38:26 +00:00
return layered_window;
}
void OS_X11::set_window_per_pixel_transparency_enabled(bool p_enabled) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (!is_layered_allowed()) {
Style: clang-format: Disable AllowShortIfStatementsOnASingleLine
2021-05-04 12:28:27 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Experimental support for windows with per-pixel transparency (macOS, X11 and Windows).
2017-12-10 18:38:26 +00:00
if (layered_window != p_enabled) {
if (p_enabled) {
layered_window = true;
} else {
layered_window = false;
}
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
void OS_X11::set_window_title(const String &p_title) {
XStoreName(x11_display, x11_window, p_title.utf8().get_data());
x11: set _net_wm_name property
2016-02-03 23:39:53 +00:00
Atom _net_wm_name = XInternAtom(x11_display, "_NET_WM_NAME", false);
Atom utf8_string = XInternAtom(x11_display, "UTF8_STRING", false);
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
if (_net_wm_name != None && utf8_string != None) {
XChangeProperty(x11_display, x11_window, _net_wm_name, utf8_string, 8, PropModeReplace, (unsigned char *)p_title.utf8().get_data(), p_title.utf8().length());
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
[3.2] Add window click-through support.
2020-06-29 09:31:13 +00:00
void OS_X11::set_window_mouse_passthrough(const PoolVector2Array &p_region) {
int event_base, error_base;
const Bool ext_okay = XShapeQueryExtension(x11_display, &event_base, &error_base);
if (ext_okay) {
Region region;
if (p_region.size() == 0) {
region = XCreateRegion();
XRectangle rect;
rect.x = 0;
rect.y = 0;
rect.width = get_real_window_size().x;
rect.height = get_real_window_size().y;
XUnionRectWithRegion(&rect, region, region);
} else {
XPoint *points = (XPoint *)memalloc(sizeof(XPoint) * p_region.size());
for (int i = 0; i < p_region.size(); i++) {
points[i].x = p_region[i].x;
points[i].y = p_region[i].y;
}
region = XPolygonRegion(points, p_region.size(), EvenOddRule);
memfree(points);
}
XShapeCombineRegion(x11_display, x11_window, ShapeInput, 0, 0, region, ShapeSet);
XDestroyRegion(region);
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
void OS_X11::set_video_mode(const VideoMode &p_video_mode, int p_screen) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Made the Atom net_wm_icon local
2015-10-25 17:36:27 +00:00
OS::VideoMode OS_X11::get_video_mode(int p_screen) const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return current_videomode;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
void OS_X11::get_fullscreen_mode_list(List<VideoMode> *p_list, int p_screen) const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Make fullscreen-switching is working with LXDE/Openbox
2015-01-10 13:50:31 +00:00
void OS_X11::set_wm_fullscreen(bool p_enabled) {
Remove window decorations for fullscreen on X11
2018-02-16 20:49:17 +00:00
if (p_enabled && !get_borderless_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);
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
if (property != None) {
XChangeProperty(x11_display, x11_window, property, property, 32, PropModeReplace, (unsigned char *)&hints, 5);
}
Remove window decorations for fullscreen on X11
2018-02-16 20:49:17 +00:00
}
Fix fullscreen on X11 for non-resizable windows
2017-07-12 17:20:29 +00:00
if (p_enabled && !is_window_resizable()) {
// 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, x11_window, xsh);
XFree(xsh);
}
Fix typos with codespell Found via `codespell -q 3 --skip="./thirdparty,./editor/translations" -I ../godot-word-whitelist.txt` Whitelist consists of: ``` ang doubleclick lod nd que te unselect ```
2018-02-21 16:30:55 +00:00
// Using EWMH -- Extended Window Manager Hints
x11-fullscreen support through GDScript( OS.set_fullscreen(bool) )
2015-01-10 07:47:34 +00:00
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 = x11_window;
xev.xclient.message_type = wm_state;
xev.xclient.format = 32;
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
xev.xclient.data.l[0] = p_enabled ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
x11-fullscreen support through GDScript( OS.set_fullscreen(bool) )
2015-01-10 07:47:34 +00:00
xev.xclient.data.l[1] = wm_fullscreen;
xev.xclient.data.l[2] = 0;
* cleanup window state handling * first attemps in handling ALT+TABa (WIP)
2015-01-17 10:43:12 +00:00
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
Hint the window manager to disable desktop compositing in fullscreen mode.
2017-09-09 21:24:19 +00:00
// set bypass compositor hint
Atom bypass_compositor = XInternAtom(x11_display, "_NET_WM_BYPASS_COMPOSITOR", False);
unsigned long compositing_disable_on = p_enabled ? 1 : 0;
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
if (bypass_compositor != None) {
XChangeProperty(x11_display, x11_window, bypass_compositor, XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&compositing_disable_on, 1);
}
Hint the window manager to disable desktop compositing in fullscreen mode.
2017-09-09 21:24:19 +00:00
Fix fullscreen on X11 for non-resizable windows
2017-07-12 17:20:29 +00:00
XFlush(x11_display);
Add ability to limit maximum/minimum window size.
2019-06-13 12:31:08 +00:00
if (!p_enabled) {
Fix fullscreen on X11 for non-resizable windows
2017-07-12 17:20:29 +00:00
// Reset the non-resizable flags if we un-set these before.
Size2 size = get_window_size();
XSizeHints *xsh;
xsh = XAllocSizeHints();
Add ability to limit maximum/minimum window size.
2019-06-13 12:31:08 +00:00
if (!is_window_resizable()) {
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 (min_size != Size2()) {
xsh->flags |= PMinSize;
xsh->min_width = min_size.x;
xsh->min_height = min_size.y;
}
if (max_size != Size2()) {
xsh->flags |= PMaxSize;
xsh->max_width = max_size.x;
xsh->max_height = max_size.y;
}
}
Fix fullscreen on X11 for non-resizable windows
2017-07-12 17:20:29 +00:00
XSetWMNormalHints(x11_display, x11_window, xsh);
XFree(xsh);
Adding borders back to a borderless window was not working.
2017-09-10 04:41:34 +00:00
[X11] Add window borderless state detection, fix borderless state restoration after exiting fullscreen.
2019-06-11 09:07:48 +00:00
// put back or remove decorations according to the last set borderless state
Adding borders back to a borderless window was not working.
2017-09-10 04:41:34 +00:00
Hints hints;
Atom property;
hints.flags = 2;
[X11] Add window borderless state detection, fix borderless state restoration after exiting fullscreen.
2019-06-11 09:07:48 +00:00
hints.decorations = current_videomode.borderless_window ? 0 : 1;
Adding borders back to a borderless window was not working.
2017-09-10 04:41:34 +00:00
property = XInternAtom(x11_display, "_MOTIF_WM_HINTS", True);
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
if (property != None) {
XChangeProperty(x11_display, x11_window, property, property, 32, PropModeReplace, (unsigned char *)&hints, 5);
}
Adding borders back to a borderless window was not working.
2017-09-10 04:41:34 +00:00
}
Make fullscreen-switching is working with LXDE/Openbox
2015-01-10 13:50:31 +00:00
}
Add new window setting: always on top Implemented for Windows and Linux.
2017-12-27 19:51:19 +00:00
void OS_X11::set_wm_above(bool p_enabled) {
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 = 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);
}
get_screen_count() added
2015-01-11 10:52:42 +00:00
int OS_X11::get_screen_count() const {
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
// Using Xinerama Extension
Using Xinerama extension for getting screen info
2015-01-13 13:01:24 +00:00
int event_base, error_base;
const Bool ext_okay = XineramaQueryExtension(x11_display, &event_base, &error_base);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (!ext_okay) {
Style: clang-format: Disable AllowShortIfStatementsOnASingleLine
2021-05-04 12:28:27 +00:00
return 0;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Using Xinerama extension for getting screen info
2015-01-13 13:01:24 +00:00
int count;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XineramaScreenInfo *xsi = XineramaQueryScreens(x11_display, &count);
Using Xinerama extension for getting screen info
2015-01-13 13:01:24 +00:00
XFree(xsi);
return count;
get_screen_count() added
2015-01-11 10:52:42 +00:00
}
fixes to new window management API -needs testing on Linux -needs testing on Windows -NEED SOMEONE TO IMPLEMENT IT ON OSX!! PLEASE HELP!
2015-03-22 22:00:50 +00:00
int OS_X11::get_current_screen() const {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int x, y;
Window child;
XTranslateCoordinates(x11_display, x11_window, DefaultRootWindow(x11_display), 0, 0, &x, &y, &child);
get_screen() + set_screen() added
2015-01-14 04:02:59 +00:00
int count = get_screen_count();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < count; i++) {
get_screen() + set_screen() added
2015-01-14 04:02:59 +00:00
Point2i pos = get_screen_position(i);
Size2i size = get_screen_size(i);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if ((x >= pos.x && x < pos.x + size.width) && (y >= pos.y && y < pos.y + size.height)) {
remove trailing whitespace
2016-03-08 23:00:52 +00:00
return i;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
get_screen() + set_screen() added
2015-01-14 04:02:59 +00:00
}
return 0;
}
fixes to new window management API -needs testing on Linux -needs testing on Windows -NEED SOMEONE TO IMPLEMENT IT ON OSX!! PLEASE HELP!
2015-03-22 22:00:50 +00:00
void OS_X11::set_current_screen(int p_screen) {
Fix out of bounds array access on OS_X11 code The problem happened on methods `get_screen_position`, `get_screen_size` and `set_current_screen` when they were passed a negative screen value. Fixes: - #46184 - #46185 - #46186
2021-02-28 17:11:25 +00:00
if (p_screen == -1) {
p_screen = get_current_screen();
}
// Check if screen is valid
ERR_FAIL_INDEX(p_screen, get_screen_count());
remove trailing whitespace
2016-03-08 23:00:52 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (current_videomode.fullscreen) {
get_screen() + set_screen() added
2015-01-14 04:02:59 +00:00
Point2i position = get_screen_position(p_screen);
Size2i size = get_screen_size(p_screen);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XMoveResizeWindow(x11_display, x11_window, position.x, position.y, size.x, size.y);
} else {
if (p_screen != get_current_screen()) {
get_screen() + set_screen() added
2015-01-14 04:02:59 +00:00
Point2i position = get_screen_position(p_screen);
XMoveWindow(x11_display, x11_window, position.x, position.y);
}
}
}
get_screen_position() added
2015-01-13 09:25:50 +00:00
Point2 OS_X11::get_screen_position(int p_screen) const {
p_screen param from get_screen_* funcs now default to the current screen
2017-08-20 19:12:29 +00:00
if (p_screen == -1) {
p_screen = get_current_screen();
}
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
// Using Xinerama Extension
Using Xinerama extension for getting screen info
2015-01-13 13:01:24 +00:00
int event_base, error_base;
const Bool ext_okay = XineramaQueryExtension(x11_display, &event_base, &error_base);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (!ext_okay) {
return Point2i(0, 0);
new editor settings customization of where to run the game from the editor
2015-08-31 02:36:46 +00:00
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Using Xinerama extension for getting screen info
2015-01-13 13:01:24 +00:00
int count;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XineramaScreenInfo *xsi = XineramaQueryScreens(x11_display, &count);
Fix out of bounds array access on OS_X11 code The problem happened on methods `get_screen_position`, `get_screen_size` and `set_current_screen` when they were passed a negative screen value. Fixes: - #46184 - #46185 - #46186
2021-02-28 17:11:25 +00:00
// Check if screen is valid
ERR_FAIL_INDEX_V(p_screen, count, Point2i(0, 0));
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Using Xinerama extension for getting screen info
2015-01-13 13:01:24 +00:00
Point2i position = Point2i(xsi[p_screen].x_org, xsi[p_screen].y_org);
new editor settings customization of where to run the game from the editor
2015-08-31 02:36:46 +00:00
Using Xinerama extension for getting screen info
2015-01-13 13:01:24 +00:00
XFree(xsi);
new editor settings customization of where to run the game from the editor
2015-08-31 02:36:46 +00:00
Using Xinerama extension for getting screen info
2015-01-13 13:01:24 +00:00
return position;
get_screen_position() added
2015-01-13 09:25:50 +00:00
}
get_screen_size() added
2015-01-11 11:35:53 +00:00
Size2 OS_X11::get_screen_size(int p_screen) const {
p_screen param from get_screen_* funcs now default to the current screen
2017-08-20 19:12:29 +00:00
if (p_screen == -1) {
p_screen = get_current_screen();
}
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
// Using Xinerama Extension
Using Xinerama extension for getting screen info
2015-01-13 13:01:24 +00:00
int event_base, error_base;
const Bool ext_okay = XineramaQueryExtension(x11_display, &event_base, &error_base);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (!ext_okay) {
Style: clang-format: Disable AllowShortIfStatementsOnASingleLine
2021-05-04 12:28:27 +00:00
return Size2i(0, 0);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Using Xinerama extension for getting screen info
2015-01-13 13:01:24 +00:00
int count;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XineramaScreenInfo *xsi = XineramaQueryScreens(x11_display, &count);
Fix out of bounds array access on OS_X11 code The problem happened on methods `get_screen_position`, `get_screen_size` and `set_current_screen` when they were passed a negative screen value. Fixes: - #46184 - #46185 - #46186
2021-02-28 17:11:25 +00:00
// Check if screen is valid
ERR_FAIL_INDEX_V(p_screen, count, Size2i(0, 0));
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Using Xinerama extension for getting screen info
2015-01-13 13:01:24 +00:00
Size2i size = Point2i(xsi[p_screen].width, xsi[p_screen].height);
XFree(xsi);
return size;
get_screen_size() added
2015-01-11 11:35:53 +00:00
}
x11: Implemented dpi detection depends on XRandR. Had to dynamically load `XRRGetMonitors` as Ubuntu 12.04 doesn't have it. Also removed libudev from travis install list.
2016-06-09 16:54:06 +00:00
int OS_X11::get_screen_dpi(int p_screen) const {
p_screen param from get_screen_* funcs now default to the current screen
2017-08-20 19:12:29 +00:00
if (p_screen == -1) {
p_screen = get_current_screen();
}
x11: Implemented dpi detection depends on XRandR. Had to dynamically load `XRRGetMonitors` as Ubuntu 12.04 doesn't have it. Also removed libudev from travis install list.
2016-06-09 16:54:06 +00:00
//invalid screen?
ERR_FAIL_INDEX_V(p_screen, get_screen_count(), 0);
//Get physical monitor Dimensions through XRandR and calculate dpi
Size2 sc = get_screen_size(p_screen);
x11: fix XRandr GetMonitors
2016-06-12 13:29:02 +00:00
if (xrandr_ext_ok) {
x11: Implemented dpi detection depends on XRandR. Had to dynamically load `XRRGetMonitors` as Ubuntu 12.04 doesn't have it. Also removed libudev from travis install list.
2016-06-09 16:54:06 +00:00
int count = 0;
if (xrr_get_monitors) {
xrr_monitor_info *monitors = xrr_get_monitors(x11_display, x11_window, true, &count);
if (p_screen < count) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
double xdpi = sc.width / (double)monitors[p_screen].mwidth * 25.4;
double ydpi = sc.height / (double)monitors[p_screen].mheight * 25.4;
x11: fix XRandr GetMonitors
2016-06-12 13:29:02 +00:00
xrr_free_monitors(monitors);
x11: Implemented dpi detection depends on XRandR. Had to dynamically load `XRRGetMonitors` as Ubuntu 12.04 doesn't have it. Also removed libudev from travis install list.
2016-06-09 16:54:06 +00:00
return (xdpi + ydpi) / 2;
}
x11: fix XRandr GetMonitors
2016-06-12 13:29:02 +00:00
xrr_free_monitors(monitors);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (p_screen == 0) {
x11: Implemented dpi detection depends on XRandR. Had to dynamically load `XRRGetMonitors` as Ubuntu 12.04 doesn't have it. Also removed libudev from travis install list.
2016-06-09 16:54:06 +00:00
XRRScreenSize *sizes = XRRSizes(x11_display, 0, &count);
if (sizes) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
double xdpi = sc.width / (double)sizes[0].mwidth * 25.4;
double ydpi = sc.height / (double)sizes[0].mheight * 25.4;
x11: Implemented dpi detection depends on XRandR. Had to dynamically load `XRRGetMonitors` as Ubuntu 12.04 doesn't have it. Also removed libudev from travis install list.
2016-06-09 16:54:06 +00:00
return (xdpi + ydpi) / 2;
}
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int width_mm = DisplayWidthMM(x11_display, p_screen);
x11: Implemented dpi detection depends on XRandR. Had to dynamically load `XRRGetMonitors` as Ubuntu 12.04 doesn't have it. Also removed libudev from travis install list.
2016-06-09 16:54:06 +00:00
int height_mm = DisplayHeightMM(x11_display, p_screen);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
double xdpi = (width_mm ? sc.width / (double)width_mm * 25.4 : 0);
double ydpi = (height_mm ? sc.height / (double)height_mm * 25.4 : 0);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (xdpi || ydpi) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
return (xdpi + ydpi) / (xdpi && ydpi ? 2 : 1);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
x11: Implemented dpi detection depends on XRandR. Had to dynamically load `XRRGetMonitors` as Ubuntu 12.04 doesn't have it. Also removed libudev from travis install list.
2016-06-09 16:54:06 +00:00
//could not get dpi
return 96;
}
get_window_position() + set_window_position() added
2015-01-11 07:47:27 +00:00
Point2 OS_X11::get_window_position() const {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int x, y;
get_window_position() + set_window_position() added
2015-01-11 07:47:27 +00:00
Window child;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XTranslateCoordinates(x11_display, x11_window, DefaultRootWindow(x11_display), 0, 0, &x, &y, &child);
[X11] Fix `get_window_position` to return absolute coordinates, change `set_window_position` to take window decorations into account.
2019-03-12 17:09:16 +00:00
return Point2i(x, y);
get_window_position() + set_window_position() added
2015-01-11 07:47:27 +00:00
}
First attempt of restoring the window at the old position
2015-01-10 17:07:23 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
void OS_X11::set_window_position(const Point2 &p_position) {
[X11] Fix `get_window_position` to return absolute coordinates, change `set_window_position` to take window decorations into account.
2019-03-12 17:09:16 +00:00
int x = 0;
int y = 0;
Some code changed with Clang-Tidy
2019-06-26 13:08:25 +00:00
if (!get_borderless_window()) {
[X11] Fix `get_window_position` to return absolute coordinates, change `set_window_position` to take window decorations into account.
2019-03-12 17:09:16 +00:00
//exclude window decorations
XSync(x11_display, False);
Atom prop = XInternAtom(x11_display, "_NET_FRAME_EXTENTS", True);
X11: Check if "_NET_FRAME_EXTENTS" atom is supported.
2019-05-09 16:12:31 +00:00
if (prop != None) {
Atom type;
int format;
unsigned long len;
unsigned long remaining;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
unsigned char *data = nullptr;
X11: Check if "_NET_FRAME_EXTENTS" atom is supported.
2019-05-09 16:12:31 +00:00
if (XGetWindowProperty(x11_display, 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);
Fixed game crash, regression of #26977 Co-authored-by: bruvzg <7645683+bruvzg@users.noreply.github.com>
2019-05-01 07:49:10 +00:00
}
[X11] Fix `get_window_position` to return absolute coordinates, change `set_window_position` to take window decorations into account.
2019-03-12 17:09:16 +00:00
}
}
XMoveWindow(x11_display, x11_window, p_position.x - x, p_position.y - y);
Update X11 global mouse position at startup When we start the engine we haven't yet gotten any X11 motion events so we don't yet know where our mouse cursor is located. Instead we now query the X server for this information when we start and update the appropriate values. In addition when we move the window we also update the mouse position based off of X server knowledge as we will also not have received any mouse motion events. this fixes #8145 (for X11 only)
2018-09-09 20:13:50 +00:00
update_real_mouse_position();
get_window_position() + set_window_position() added
2015-01-11 07:47:27 +00:00
}
Make fullscreen-switching is working with LXDE/Openbox
2015-01-10 13:50:31 +00:00
get_window_size() + set_window_size() added
2015-01-11 09:36:56 +00:00
Size2 OS_X11::get_window_size() const {
Fix issues with set_window_resizable on x11
2017-01-30 16:25:48 +00:00
// Use current_videomode width and height instead of XGetWindowAttributes
// since right after a XResizeWindow the attributes may not be updated yet
return Size2i(current_videomode.width, current_videomode.height);
get_window_size() + set_window_size() added
2015-01-11 09:36:56 +00:00
}
Added OS::center_window to center the window precisely on desktop platforms
2018-02-12 17:17:29 +00:00
Size2 OS_X11::get_real_window_size() const {
XWindowAttributes xwa;
XSync(x11_display, False);
XGetWindowAttributes(x11_display, x11_window, &xwa);
int w = xwa.width;
int h = xwa.height;
Atom prop = XInternAtom(x11_display, "_NET_FRAME_EXTENTS", True);
X11: Check if "_NET_FRAME_EXTENTS" atom is supported.
2019-05-09 16:12:31 +00:00
if (prop != None) {
Atom type;
int format;
unsigned long len;
unsigned long remaining;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
unsigned char *data = nullptr;
X11: Check if "_NET_FRAME_EXTENTS" atom is supported.
2019-05-09 16:12:31 +00:00
if (XGetWindowProperty(x11_display, 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);
Fixed game crash, regression of #26977 Co-authored-by: bruvzg <7645683+bruvzg@users.noreply.github.com>
2019-05-01 07:49:10 +00:00
}
Added OS::center_window to center the window precisely on desktop platforms
2018-02-12 17:17:29 +00:00
}
return Size2(w, h);
}
Add ability to limit maximum/minimum window size.
2019-06-13 12:31:08 +00:00
Size2 OS_X11::get_max_window_size() const {
return max_size;
}
Size2 OS_X11::get_min_window_size() const {
return min_size;
}
void OS_X11::set_min_window_size(const Size2 p_size) {
if ((p_size != Size2()) && (max_size != Size2()) && ((p_size.x > max_size.x) || (p_size.y > max_size.y))) {
Turn `OS.set_min/max_window_size()` warnings into errors Since invalid values will cause the setting to be discarded, it makes more sense to display an error message instead of a warning message.
2019-07-30 12:50:52 +00:00
ERR_PRINT("Minimum window size can't be larger than maximum window size!");
Add ability to limit maximum/minimum window size.
2019-06-13 12:31:08 +00:00
return;
}
min_size = p_size;
if (is_window_resizable()) {
XSizeHints *xsh;
xsh = XAllocSizeHints();
xsh->flags = 0L;
if (min_size != Size2()) {
xsh->flags |= PMinSize;
xsh->min_width = min_size.x;
xsh->min_height = min_size.y;
}
if (max_size != Size2()) {
xsh->flags |= PMaxSize;
xsh->max_width = max_size.x;
xsh->max_height = max_size.y;
}
XSetWMNormalHints(x11_display, x11_window, xsh);
XFree(xsh);
XFlush(x11_display);
}
}
void OS_X11::set_max_window_size(const Size2 p_size) {
if ((p_size != Size2()) && ((p_size.x < min_size.x) || (p_size.y < min_size.y))) {
Turn `OS.set_min/max_window_size()` warnings into errors Since invalid values will cause the setting to be discarded, it makes more sense to display an error message instead of a warning message.
2019-07-30 12:50:52 +00:00
ERR_PRINT("Maximum window size can't be smaller than minimum window size!");
Add ability to limit maximum/minimum window size.
2019-06-13 12:31:08 +00:00
return;
}
max_size = p_size;
if (is_window_resizable()) {
XSizeHints *xsh;
xsh = XAllocSizeHints();
xsh->flags = 0L;
if (min_size != Size2()) {
xsh->flags |= PMinSize;
xsh->min_width = min_size.x;
xsh->min_height = min_size.y;
}
if (max_size != Size2()) {
xsh->flags |= PMaxSize;
xsh->max_width = max_size.x;
xsh->max_height = max_size.y;
}
XSetWMNormalHints(x11_display, x11_window, xsh);
XFree(xsh);
XFlush(x11_display);
}
}
get_window_size() + set_window_size() added
2015-01-11 09:36:56 +00:00
void OS_X11::set_window_size(const Size2 p_size) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (current_videomode.width == p_size.width && current_videomode.height == p_size.height) {
When resizing an X11 window wait for the WM to process our request On X11 when we send an XResizeWindow request to the X server it is happy to say it is done when the request has been handed over to the window manager. The window manager itself may however take some time to actually do the resize. Godot expects that a resize request is immediate. To work around this issue we could implement the whole _NET_WM_SYNC_REQUEST protocol. However this protocol does not fit very well with the way we currently process X events and would when implemented in the current framework still cause a 1 frame delay between a resize request and the actual resize happening. This fixes #21720
2018-09-09 22:08:21 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
When resizing an X11 window wait for the WM to process our request On X11 when we send an XResizeWindow request to the X server it is happy to say it is done when the request has been handed over to the window manager. The window manager itself may however take some time to actually do the resize. Godot expects that a resize request is immediate. To work around this issue we could implement the whole _NET_WM_SYNC_REQUEST protocol. However this protocol does not fit very well with the way we currently process X events and would when implemented in the current framework still cause a 1 frame delay between a resize request and the actual resize happening. This fixes #21720
2018-09-09 22:08:21 +00:00
XWindowAttributes xwa;
XSync(x11_display, False);
XGetWindowAttributes(x11_display, x11_window, &xwa);
int old_w = xwa.width;
int old_h = xwa.height;
Prevent invalid values when resizing window (X11)
2021-03-01 12:19:09 +00:00
Size2 size = p_size;
size.x = MAX(1, size.x);
size.y = MAX(1, size.y);
Fix issues with set_window_resizable on x11
2017-01-30 16:25:48 +00:00
// If window resizable is disabled we need to update the attributes first
Add ability to limit maximum/minimum window size.
2019-06-13 12:31:08 +00:00
XSizeHints *xsh;
xsh = XAllocSizeHints();
Remove redundant "== false" code Some of this code has been re-organized. f
2018-10-06 20:20:41 +00:00
if (!is_window_resizable()) {
Fix issues with set_window_resizable on x11
2017-01-30 16:25:48 +00:00
xsh->flags = PMinSize | PMaxSize;
Prevent invalid values when resizing window (X11)
2021-03-01 12:19:09 +00:00
xsh->min_width = size.x;
xsh->max_width = size.x;
xsh->min_height = size.y;
xsh->max_height = size.y;
Add ability to limit maximum/minimum window size.
2019-06-13 12:31:08 +00:00
} else {
xsh->flags = 0L;
if (min_size != Size2()) {
xsh->flags |= PMinSize;
xsh->min_width = min_size.x;
xsh->min_height = min_size.y;
}
if (max_size != Size2()) {
xsh->flags |= PMaxSize;
xsh->max_width = max_size.x;
xsh->max_height = max_size.y;
}
Fix issues with set_window_resizable on x11
2017-01-30 16:25:48 +00:00
}
Add ability to limit maximum/minimum window size.
2019-06-13 12:31:08 +00:00
XSetWMNormalHints(x11_display, x11_window, xsh);
XFree(xsh);
Fix issues with set_window_resizable on x11
2017-01-30 16:25:48 +00:00
// Resize the window
Prevent invalid values when resizing window (X11)
2021-03-01 12:19:09 +00:00
XResizeWindow(x11_display, x11_window, size.x, size.y);
Fix issues with set_window_resizable on x11
2017-01-30 16:25:48 +00:00
// Update our videomode width and height
Prevent invalid values when resizing window (X11)
2021-03-01 12:19:09 +00:00
current_videomode.width = size.x;
current_videomode.height = size.y;
When resizing an X11 window wait for the WM to process our request On X11 when we send an XResizeWindow request to the X server it is happy to say it is done when the request has been handed over to the window manager. The window manager itself may however take some time to actually do the resize. Godot expects that a resize request is immediate. To work around this issue we could implement the whole _NET_WM_SYNC_REQUEST protocol. However this protocol does not fit very well with the way we currently process X events and would when implemented in the current framework still cause a 1 frame delay between a resize request and the actual resize happening. This fixes #21720
2018-09-09 22:08:21 +00:00
for (int timeout = 0; timeout < 50; ++timeout) {
XSync(x11_display, False);
XGetWindowAttributes(x11_display, x11_window, &xwa);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (old_w != xwa.width || old_h != xwa.height) {
When resizing an X11 window wait for the WM to process our request On X11 when we send an XResizeWindow request to the X server it is happy to say it is done when the request has been handed over to the window manager. The window manager itself may however take some time to actually do the resize. Godot expects that a resize request is immediate. To work around this issue we could implement the whole _NET_WM_SYNC_REQUEST protocol. However this protocol does not fit very well with the way we currently process X events and would when implemented in the current framework still cause a 1 frame delay between a resize request and the actual resize happening. This fixes #21720
2018-09-09 22:08:21 +00:00
break;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
When resizing an X11 window wait for the WM to process our request On X11 when we send an XResizeWindow request to the X server it is happy to say it is done when the request has been handed over to the window manager. The window manager itself may however take some time to actually do the resize. Godot expects that a resize request is immediate. To work around this issue we could implement the whole _NET_WM_SYNC_REQUEST protocol. However this protocol does not fit very well with the way we currently process X events and would when implemented in the current framework still cause a 1 frame delay between a resize request and the actual resize happening. This fixes #21720
2018-09-09 22:08:21 +00:00
usleep(10000);
}
get_window_size() + set_window_size() added
2015-01-11 09:36:56 +00:00
}
fixes to new window management API -needs testing on Linux -needs testing on Windows -NEED SOMEONE TO IMPLEMENT IT ON OSX!! PLEASE HELP!
2015-03-22 22:00:50 +00:00
void OS_X11::set_window_fullscreen(bool p_enabled) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (current_videomode.fullscreen == p_enabled) {
Add new window setting: always on top Implemented for Windows and Linux.
2017-12-27 19:51:19 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Add new window setting: always on top Implemented for Windows and Linux.
2017-12-27 19:51:19 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (layered_window) {
Experimental support for windows with per-pixel transparency (macOS, X11 and Windows).
2017-12-10 18:38:26 +00:00
set_window_per_pixel_transparency_enabled(false);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Experimental support for windows with per-pixel transparency (macOS, X11 and Windows).
2017-12-10 18:38:26 +00:00
Add new window setting: always on top Implemented for Windows and Linux.
2017-12-27 19:51:19 +00:00
if (p_enabled && current_videomode.always_on_top) {
// Fullscreen + Always-on-top requires a maximized window on some window managers (Metacity)
set_window_maximized(true);
}
* cleanup window state handling * first attemps in handling ALT+TABa (WIP)
2015-01-17 10:43:12 +00:00
set_wm_fullscreen(p_enabled);
Fix restoring window from fullscreen to normal on Linux (cherry picked from commit 8737269275c371c8d56fcb56d783f8df1aaa2b88)
2020-02-03 14:15:24 +00:00
if (!p_enabled && current_videomode.always_on_top) {
Add new window setting: always on top Implemented for Windows and Linux.
2017-12-27 19:51:19 +00:00
// Restore
set_window_maximized(false);
}
Restores correct window position after fullscreen toggling off on Linux (cherry picked from commit 90f00c0813b8335605c81b5d5063922efe5519e3)
2020-02-03 15:14:41 +00:00
if (!p_enabled) {
set_window_position(last_position_before_fs);
} else {
last_position_before_fs = get_window_position();
}
* cleanup window state handling * first attemps in handling ALT+TABa (WIP)
2015-01-17 10:43:12 +00:00
current_videomode.fullscreen = p_enabled;
x11-fullscreen support through GDScript( OS.set_fullscreen(bool) )
2015-01-10 07:47:34 +00:00
}
fixes to new window management API -needs testing on Linux -needs testing on Windows -NEED SOMEONE TO IMPLEMENT IT ON OSX!! PLEASE HELP!
2015-03-22 22:00:50 +00:00
bool OS_X11::is_window_fullscreen() const {
Make GDScript-Function ( bool OS.is_fullscreen() ) work
2015-01-10 08:01:01 +00:00
return current_videomode.fullscreen;
x11-fullscreen support through GDScript( OS.set_fullscreen(bool) )
2015-01-10 07:47:34 +00:00
}
WIP -- set_resizable() + is_resizable added
2015-01-15 13:50:23 +00:00
fixes to new window management API -needs testing on Linux -needs testing on Windows -NEED SOMEONE TO IMPLEMENT IT ON OSX!! PLEASE HELP!
2015-03-22 22:00:50 +00:00
void OS_X11::set_window_resizable(bool p_enabled) {
Add ability to limit maximum/minimum window size.
2019-06-13 12:31:08 +00:00
XSizeHints *xsh;
* cleanup window state handling * first attemps in handling ALT+TABa (WIP)
2015-01-17 10:43:12 +00:00
xsh = XAllocSizeHints();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (!p_enabled) {
Add ability to limit maximum/minimum window size.
2019-06-13 12:31:08 +00:00
Size2 size = get_window_size();
xsh->flags = PMinSize | PMaxSize;
Fix issues with set_window_resizable on x11
2017-01-30 16:25:48 +00:00
xsh->min_width = size.x;
xsh->max_width = size.x;
xsh->min_height = size.y;
xsh->max_height = size.y;
Add ability to limit maximum/minimum window size.
2019-06-13 12:31:08 +00:00
} else {
xsh->flags = 0L;
if (min_size != Size2()) {
xsh->flags |= PMinSize;
xsh->min_width = min_size.x;
xsh->min_height = min_size.y;
}
if (max_size != Size2()) {
xsh->flags |= PMaxSize;
xsh->max_width = max_size.x;
xsh->max_height = max_size.y;
}
WIP -- set_resizable() + is_resizable added
2015-01-15 13:50:23 +00:00
}
Add ability to limit maximum/minimum window size.
2019-06-13 12:31:08 +00:00
* cleanup window state handling * first attemps in handling ALT+TABa (WIP)
2015-01-17 10:43:12 +00:00
XSetWMNormalHints(x11_display, x11_window, xsh);
XFree(xsh);
Add ability to limit maximum/minimum window size.
2019-06-13 12:31:08 +00:00
* cleanup window state handling * first attemps in handling ALT+TABa (WIP)
2015-01-17 10:43:12 +00:00
current_videomode.resizable = p_enabled;
Add ability to limit maximum/minimum window size.
2019-06-13 12:31:08 +00:00
XFlush(x11_display);
WIP -- set_resizable() + is_resizable added
2015-01-15 13:50:23 +00:00
}
fixes to new window management API -needs testing on Linux -needs testing on Windows -NEED SOMEONE TO IMPLEMENT IT ON OSX!! PLEASE HELP!
2015-03-22 22:00:50 +00:00
bool OS_X11::is_window_resizable() const {
WIP -- set_resizable() + is_resizable added
2015-01-15 13:50:23 +00:00
return current_videomode.resizable;
}
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
fixes to new window management API -needs testing on Linux -needs testing on Windows -NEED SOMEONE TO IMPLEMENT IT ON OSX!! PLEASE HELP!
2015-03-22 22:00:50 +00:00
void OS_X11::set_window_minimized(bool p_enabled) {
Ignore query to maximize/minimize window on Windows and X11 This makes these platform behave as MacOS in that regard and also fixes the editor window appearing in some cases even when --no-window has been passed.
2020-11-17 23:33:39 +00:00
if (is_no_window_mode_enabled()) {
return;
}
Code cleanup in platform/x11
2016-07-21 19:11:34 +00:00
// Using ICCCM -- Inter-Client Communication Conventions Manual
XEvent xev;
Atom wm_change = XInternAtom(x11_display, "WM_CHANGE_STATE", False);
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
Code cleanup in platform/x11
2016-07-21 19:11:34 +00:00
memset(&xev, 0, sizeof(xev));
xev.type = ClientMessage;
xev.xclient.window = x11_window;
xev.xclient.message_type = wm_change;
xev.xclient.format = 32;
xev.xclient.data.l[0] = p_enabled ? WM_IconicState : WM_NormalState;
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
Code cleanup in platform/x11
2016-07-21 19:11:34 +00:00
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
remove trailing whitespace
2016-03-08 23:00:52 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
Atom wm_hidden = XInternAtom(x11_display, "_NET_WM_STATE_HIDDEN", False);
Make it set_minimized() + set_maximized() work in both worlds: Unity and LXDE
2015-01-16 17:36:07 +00:00
memset(&xev, 0, sizeof(xev));
xev.type = ClientMessage;
xev.xclient.window = 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;
remove trailing whitespace
2016-03-08 23:00:52 +00:00
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
}
fixes to new window management API -needs testing on Linux -needs testing on Windows -NEED SOMEONE TO IMPLEMENT IT ON OSX!! PLEASE HELP!
2015-03-22 22:00:50 +00:00
bool OS_X11::is_window_minimized() const {
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
// Using ICCCM -- Inter-Client Communication Conventions Manual
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Atom property = XInternAtom(x11_display, "WM_STATE", True);
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
if (property == None) {
return false;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Atom type;
int format;
unsigned long len;
unsigned long remaining;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
unsigned char *data = nullptr;
X11: Ensure XGetWindowProperty data gets freed Fixes a small memory leak reported by lsan: ``` Direct leak of 73 byte(s) in 1 object(s) allocated from: #0 0x7f29825f3e70 in malloc (/lib64/liblsan.so.0+0xee70) #1 0x7f29824a5729 in XGetWindowProperty (/lib64/libX11.so.6+0x29729) ```
2020-06-29 11:02:34 +00:00
bool retval = false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int result = XGetWindowProperty(
x11_display,
x11_window,
property,
0,
32,
False,
AnyPropertyType,
&type,
&format,
&len,
&remaining,
&data);
if (result == Success) {
long *state = (long *)data;
X11: Ensure XGetWindowProperty data gets freed Fixes a small memory leak reported by lsan: ``` Direct leak of 73 byte(s) in 1 object(s) allocated from: #0 0x7f29825f3e70 in malloc (/lib64/liblsan.so.0+0xee70) #1 0x7f29824a5729 in XGetWindowProperty (/lib64/libX11.so.6+0x29729) ```
2020-06-29 11:02:34 +00:00
if (state[0] == WM_IconicState) {
retval = true;
}
XFree(data);
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
}
X11: Ensure XGetWindowProperty data gets freed Fixes a small memory leak reported by lsan: ``` Direct leak of 73 byte(s) in 1 object(s) allocated from: #0 0x7f29825f3e70 in malloc (/lib64/liblsan.so.0+0xee70) #1 0x7f29824a5729 in XGetWindowProperty (/lib64/libX11.so.6+0x29729) ```
2020-06-29 11:02:34 +00:00
return retval;
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
}
fixes to new window management API -needs testing on Linux -needs testing on Windows -NEED SOMEONE TO IMPLEMENT IT ON OSX!! PLEASE HELP!
2015-03-22 22:00:50 +00:00
void OS_X11::set_window_maximized(bool p_enabled) {
Ignore query to maximize/minimize window on Windows and X11 This makes these platform behave as MacOS in that regard and also fixes the editor window appearing in some cases even when --no-window has been passed.
2020-11-17 23:33:39 +00:00
if (is_no_window_mode_enabled()) {
return;
}
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (is_window_maximized() == p_enabled) {
Fix x11 boot logo position in fullscreen and in maximized
2017-10-24 19:35:28 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Fix x11 boot logo position in fullscreen and in maximized
2017-10-24 19:35:28 +00:00
remove trailing whitespace
2016-03-08 23:00:52 +00:00
// Using EWMH -- Extended Window Manager Hints
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
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 = 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;
Make it set_minimized() + set_maximized() work in both worlds: Unity and LXDE
2015-01-16 17:36:07 +00:00
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
having active items is pointless in input map
2016-01-03 21:52:42 +00:00
OS_X11::set_window_maximized gives up after 0.5s Spinning forever is clearly worse, especially since this happens on at least FVWM even though the window actually is maximized.
2019-08-10 19:09:21 +00:00
if (p_enabled && is_window_maximize_allowed()) {
// 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; !is_window_maximized() && attempt < 50; attempt++) {
usleep(10000);
Fix infinite loop introduced by 6f3486c4 on tiling windows managers
2017-12-27 10:25:57 +00:00
}
x11: Fix maximized splash-boot screen bug. Fixes #14336
2017-12-23 23:59:51 +00:00
}
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
maximized = p_enabled;
}
X11: Ensure XGetWindowProperty data gets freed Fixes a small memory leak reported by lsan: ``` Direct leak of 73 byte(s) in 1 object(s) allocated from: #0 0x7f29825f3e70 in malloc (/lib64/liblsan.so.0+0xee70) #1 0x7f29824a5729 in XGetWindowProperty (/lib64/libX11.so.6+0x29729) ```
2020-06-29 11:02:34 +00:00
// Just a helper to reduce code duplication in `is_window_maximize_allowed`
// and `is_window_maximized`.
bool OS_X11::window_maximize_check(const char *p_atom_name) const {
Atom property = XInternAtom(x11_display, p_atom_name, False);
Fix infinite loop introduced by 6f3486c4 on tiling windows managers
2017-12-27 10:25:57 +00:00
Atom type;
int format;
unsigned long len;
unsigned long remaining;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
unsigned char *data = nullptr;
X11: Ensure XGetWindowProperty data gets freed Fixes a small memory leak reported by lsan: ``` Direct leak of 73 byte(s) in 1 object(s) allocated from: #0 0x7f29825f3e70 in malloc (/lib64/liblsan.so.0+0xee70) #1 0x7f29824a5729 in XGetWindowProperty (/lib64/libX11.so.6+0x29729) ```
2020-06-29 11:02:34 +00:00
bool retval = false;
Fix infinite loop introduced by 6f3486c4 on tiling windows managers
2017-12-27 10:25:57 +00:00
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
if (property == None) {
return false;
}
Fix infinite loop introduced by 6f3486c4 on tiling windows managers
2017-12-27 10:25:57 +00:00
int result = XGetWindowProperty(
x11_display,
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;
Changed some code found by Clang Tidy and Coverity
2019-09-22 16:45:08 +00:00
for (uint64_t i = 0; i < len; i++) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (atoms[i] == wm_act_max_horz) {
Fix infinite loop introduced by 6f3486c4 on tiling windows managers
2017-12-27 10:25:57 +00:00
found_wm_act_max_horz = true;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
if (atoms[i] == wm_act_max_vert) {
Fix infinite loop introduced by 6f3486c4 on tiling windows managers
2017-12-27 10:25:57 +00:00
found_wm_act_max_vert = true;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Fix infinite loop introduced by 6f3486c4 on tiling windows managers
2017-12-27 10:25:57 +00:00
X11: Ensure XGetWindowProperty data gets freed Fixes a small memory leak reported by lsan: ``` Direct leak of 73 byte(s) in 1 object(s) allocated from: #0 0x7f29825f3e70 in malloc (/lib64/liblsan.so.0+0xee70) #1 0x7f29824a5729 in XGetWindowProperty (/lib64/libX11.so.6+0x29729) ```
2020-06-29 11:02:34 +00:00
if (found_wm_act_max_horz || found_wm_act_max_vert) {
Fix various valgrind reported uninitialized variable uses
2018-02-28 20:55:13 +00:00
retval = true;
break;
}
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
}
X11: Ensure XGetWindowProperty data gets freed Fixes a small memory leak reported by lsan: ``` Direct leak of 73 byte(s) in 1 object(s) allocated from: #0 0x7f29825f3e70 in malloc (/lib64/liblsan.so.0+0xee70) #1 0x7f29824a5729 in XGetWindowProperty (/lib64/libX11.so.6+0x29729) ```
2020-06-29 11:02:34 +00:00
XFree(data);
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
}
Fix various valgrind reported uninitialized variable uses
2018-02-28 20:55:13 +00:00
return retval;
added the following methods: * set_minimized(bool) * bool is_minimized() * set_maximized(bool) * bool is_maximized()
2015-01-16 15:18:45 +00:00
}
fixes to new window management API -needs testing on Linux -needs testing on Windows -NEED SOMEONE TO IMPLEMENT IT ON OSX!! PLEASE HELP!
2015-03-22 22:00:50 +00:00
X11: Ensure XGetWindowProperty data gets freed Fixes a small memory leak reported by lsan: ``` Direct leak of 73 byte(s) in 1 object(s) allocated from: #0 0x7f29825f3e70 in malloc (/lib64/liblsan.so.0+0xee70) #1 0x7f29824a5729 in XGetWindowProperty (/lib64/libX11.so.6+0x29729) ```
2020-06-29 11:02:34 +00:00
bool OS_X11::is_window_maximize_allowed() const {
return window_maximize_check("_NET_WM_ALLOWED_ACTIONS");
}
bool OS_X11::is_window_maximized() const {
// Using EWMH -- Extended Window Manager Hints
return window_maximize_check("_NET_WM_STATE");
}
Add new window setting: always on top Implemented for Windows and Linux.
2017-12-27 19:51:19 +00:00
void OS_X11::set_window_always_on_top(bool p_enabled) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (is_window_always_on_top() == p_enabled) {
Add new window setting: always on top Implemented for Windows and Linux.
2017-12-27 19:51:19 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Add new window setting: always on top Implemented for Windows and Linux.
2017-12-27 19:51:19 +00:00
if (p_enabled && current_videomode.fullscreen) {
// Fullscreen + Always-on-top requires a maximized window on some window managers (Metacity)
set_window_maximized(true);
}
set_wm_above(p_enabled);
if (!p_enabled && !current_videomode.fullscreen) {
// Restore
set_window_maximized(false);
}
current_videomode.always_on_top = p_enabled;
}
bool OS_X11::is_window_always_on_top() const {
return current_videomode.always_on_top;
}
Add an `OS.is_window_focused()` getter This makes it possible to know whether the window is focused at a given time, without having to track the focus state manually using `NOTIFICATION_WM_FOCUS_IN` and `NOTIFICATION_WM_FOCUS_OUT`. This partially addresses #33928.
2019-11-28 12:41:07 +00:00
bool OS_X11::is_window_focused() const {
return window_focused;
}
Fix type mismatch in OS::set_borderless_window Closes #14663.
2017-12-14 18:15:46 +00:00
void OS_X11::set_borderless_window(bool p_borderless) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (get_borderless_window() == p_borderless) {
Implemented borderless window functions on Linux.
2017-07-05 15:19:24 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Implemented borderless window functions on Linux.
2017-07-05 15:19:24 +00:00
current_videomode.borderless_window = p_borderless;
Hints hints;
Atom property;
hints.flags = 2;
hints.decorations = current_videomode.borderless_window ? 0 : 1;
property = XInternAtom(x11_display, "_MOTIF_WM_HINTS", True);
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
if (property != None) {
XChangeProperty(x11_display, x11_window, property, property, 32, PropModeReplace, (unsigned char *)&hints, 5);
}
More fixes to set_borderless_window [x11] Preserve window size when calling this method. [osx] Make sure it don't make the window resizable if it's not needed. [windows] clean up the code.
2018-05-23 19:25:41 +00:00
// Preserve window size
set_window_size(Size2(current_videomode.width, current_videomode.height));
Implemented borderless window functions on Linux.
2017-07-05 15:19:24 +00:00
}
bool OS_X11::get_borderless_window() {
[X11] Add window borderless state detection, fix borderless state restoration after exiting fullscreen.
2019-06-11 09:07:48 +00:00
bool borderless = current_videomode.borderless_window;
Atom prop = XInternAtom(x11_display, "_MOTIF_WM_HINTS", True);
if (prop != None) {
Atom type;
int format;
unsigned long len;
unsigned long remaining;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
unsigned char *data = nullptr;
[X11] Add window borderless state detection, fix borderless state restoration after exiting fullscreen.
2019-06-11 09:07:48 +00:00
if (XGetWindowProperty(x11_display, 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;
Implemented borderless window functions on Linux.
2017-07-05 15:19:24 +00:00
}
Implement OS.request_attention() for X11
2016-07-21 17:40:36 +00:00
void OS_X11::request_attention() {
// 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
Replace XRaiseWindow with a _NET_ACTIVE_WINDOW ClientRequest This fixes the editor on X11 not getting put on the foreground when a debugged project hits an error or breakpoint.
2018-08-16 19:36:37 +00:00
Implement OS.request_attention() for X11
2016-07-21 17:40:36 +00:00
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 = 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);
Replace XRaiseWindow with a _NET_ACTIVE_WINDOW ClientRequest This fixes the editor on X11 not getting put on the foreground when a debugged project hits an error or breakpoint.
2018-08-16 19:36:37 +00:00
XFlush(x11_display);
Implement OS.request_attention() for X11
2016-07-21 17:40:36 +00:00
}
Add get_native_handle to OS
2020-10-03 12:13:39 +00:00
void *OS_X11::get_native_handle(int p_handle_type) {
switch (p_handle_type) {
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine
2021-05-04 12:35:44 +00:00
case APPLICATION_HANDLE:
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
return nullptr; // Do we have a value to return here?
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine
2021-05-04 12:35:44 +00:00
case DISPLAY_HANDLE:
return (void *)x11_display;
case WINDOW_HANDLE:
return (void *)x11_window;
case WINDOW_VIEW:
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
return nullptr; // Do we have a value to return here?
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine
2021-05-04 12:35:44 +00:00
case OPENGL_CONTEXT:
return context_gl->get_glx_context();
default:
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
return nullptr;
Add get_native_handle to OS
2020-10-03 12:13:39 +00:00
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
void OS_X11::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));
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Fixed button mask behavior
2018-07-08 13:12:13 +00:00
unsigned int OS_X11::get_mouse_button_state(unsigned int p_x11_button, int p_x11_type) {
unsigned int mask = 1 << (p_x11_button - 1);
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Fixed button mask behavior
2018-07-08 13:12:13 +00:00
if (p_x11_type == ButtonPress) {
last_button_state |= mask;
} else {
last_button_state &= ~mask;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Fixed button mask behavior
2018-07-08 13:12:13 +00:00
return last_button_state;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
void OS_X11::_handle_key_event(XKeyEvent *p_event, LocalVector<XEvent> &p_events, uint32_t &p_event_index, bool p_echo) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// X11 functions don't know what const is
XKeyEvent *xkeyevent = p_event;
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// This code was pretty difficult to write.
// The docs stink and every toolkit seems to
remove trailing whitespace
2016-03-08 23:00:52 +00:00
// do it in a different way.
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/* Phase 1, obtain a proper keysym */
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// This was also very difficult to figure out.
// You'd expect you could just use Keysym provided by
remove trailing whitespace
2016-03-08 23:00:52 +00:00
// XKeycodeToKeysym to obtain internationalized
// input.. WRONG!!
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// you must use XLookupString (???) which not only wastes
Fix typos in source code using codespell From https://github.com/lucasdemarchi/codespell
2017-03-24 20:45:31 +00:00
// cycles generating an unnecessary string, but also
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// 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.
remove trailing whitespace
2016-03-08 23:00:52 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
KeySym keysym_keycode = 0; // keysym used to find a keycode
KeySym keysym_unicode = 0; // keysym used to find unicode
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// XLookupString returns keysyms usable as nice scancodes/
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
char str[256 + 1];
Fix modifier keys causing key-code mismatch on Linux/X11.
2019-08-28 10:27:13 +00:00
XKeyEvent xkeyevent_no_mod = *xkeyevent;
xkeyevent_no_mod.state &= ~ShiftMask;
xkeyevent_no_mod.state &= ~ControlMask;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
XLookupString(xkeyevent, str, 256, &keysym_unicode, nullptr);
XLookupString(&xkeyevent_no_mod, nullptr, 0, &keysym_keycode, nullptr);
remove trailing whitespace
2016-03-08 23:00:52 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
// Meanwhile, XLookupString returns keysyms useful for unicode.
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (!xmbstring) {
// keep a temporary buffer for the string
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
xmbstring = (char *)memalloc(sizeof(char) * 8);
xmblen = 8;
remove trailing whitespace
2016-03-08 23:00:52 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (xkeyevent->type == KeyPress && xic) {
Status status;
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
#ifdef X_HAVE_UTF8_STRING
int utf8len = 8;
char *utf8string = (char *)memalloc(sizeof(char) * utf8len);
int utf8bytes = Xutf8LookupString(xic, xkeyevent, utf8string,
utf8len - 1, &keysym_unicode, &status);
if (status == XBufferOverflow) {
utf8len = utf8bytes + 1;
utf8string = (char *)memrealloc(utf8string, utf8len);
utf8bytes = Xutf8LookupString(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);
Add `physical_scancode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2021-03-07 15:16:42 +00:00
unsigned int physical_keycode = KeyMappingX11::get_scancode(xkeyevent->keycode);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (keycode >= 'a' && keycode <= 'z') {
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
keycode -= 'a' - 'A';
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
String tmp;
tmp.parse_utf8(utf8string, utf8bytes);
for (int i = 0; i < tmp.length(); i++) {
Ref<InputEventKey> k;
k.instance();
Add `physical_scancode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2021-03-07 15:16:42 +00:00
if (physical_keycode == 0 && keycode == 0 && tmp[i] == 0) {
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
continue;
}
Add `physical_scancode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2021-03-07 15:16:42 +00:00
if (keycode == 0) {
keycode = physical_keycode;
}
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
get_key_modifier_state(xkeyevent->state, k);
k->set_unicode(tmp[i]);
k->set_pressed(keypress);
k->set_scancode(keycode);
Add `physical_scancode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2021-03-07 15:16:42 +00:00
k->set_physical_scancode(physical_keycode);
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
k->set_echo(false);
if (k->get_scancode() == KEY_BACKTAB) {
//make it consistent across platforms.
k->set_scancode(KEY_TAB);
Add `physical_scancode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2021-03-07 15:16:42 +00:00
k->set_physical_scancode(KEY_TAB);
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
k->set_shift(true);
}
Improve input event accumulation - API has been simplified: all events now go through `parse_input_event()`. Whether they are accumulated or not depends on the `use_accumulated_input` flag. - Event accumulation is now thread-safe (it was not needed so far, but it prepares the ground for the following changes). - Touch drag events now support accumulation.
2020-09-20 19:30:34 +00:00
input->parse_input_event(k);
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
}
X11: Fix memory leak in handle_key_event Extracted from #27189.
2019-11-12 06:51:51 +00:00
memfree(utf8string);
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
return;
}
memfree(utf8string);
#else
Workaround for IME on Linux(fixes #29 #7106): Workaround for supporting input method frameworks like SCIM, IBus, Fcitx, etc. The locale is set when the application starts. Workaround for input when the input context within the specified input method is not available.
2017-06-24 13:09:39 +00:00
do {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int mnbytes = XmbLookupString(xic, xkeyevent, xmbstring, xmblen - 1, &keysym_unicode, &status);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
xmbstring[mnbytes] = '\0';
if (status == XBufferOverflow) {
xmblen = mnbytes + 1;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
xmbstring = (char *)memrealloc(xmbstring, xmblen);
remove trailing whitespace
2016-03-08 23:00:52 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} while (status == XBufferOverflow);
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
#endif
remove trailing whitespace
2016-03-08 23:00:52 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/* Phase 2, obtain a pigui keycode from the keysym */
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// 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);
Add `physical_scancode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2021-03-07 15:16:42 +00:00
unsigned int physical_keycode = KeyMappingX11::get_scancode(xkeyevent->keycode);
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Fix typos 'a' and 'an'
2017-09-02 14:19:06 +00:00
/* Phase 3, obtain a unicode character from the keysym */
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// KeyMappingX11 also translates keysym to unicode.
// It does a binary search on a table to translate
remove trailing whitespace
2016-03-08 23:00:52 +00:00
// most properly.
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
unsigned int unicode = keysym_unicode > 0 ? KeyMappingX11::get_unicode_from_keysym(keysym_unicode) : 0;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/* Phase 4, determine if event must be filtered */
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// This seems to be a side-effect of using XIM.
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
// XFilterEvent looks like a core X11 function,
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// 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;
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Add `physical_scancode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2021-03-07 15:16:42 +00:00
if (physical_keycode == 0 && keycode == 0 && unicode == 0) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Add `physical_scancode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2021-03-07 15:16:42 +00:00
if (keycode == 0) {
keycode = physical_keycode;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/* Phase 5, determine modifier mask */
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// 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.
Make some debug prints verbose-only, remove others
2018-08-24 07:35:07 +00:00
//print_verbose("mod1: "+itos(xkeyevent->state&Mod1Mask)+" mod 5: "+itos(xkeyevent->state&Mod5Mask));
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Ref<InputEventKey> k;
k.instance();
get_key_modifier_state(xkeyevent->state, k);
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/* Phase 6, determine echo character */
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// Echo characters in X11 are a keyrelease and a keypress
// one after the other with the (almot) same timestamp.
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
// To detect them, i compare to the next event in list and
// check that their difference in time is below a threshold.
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Making Godot Easier to Use.. -=-=-=-=-=-=-=-=-=-=-=-=-=-= -Auto indenter in code editor, this makes it much easier to paste external code. -Zoom in 2D viewport now uses the mouse pointer as reference. -Obscure hack to see where code/line of GDScript in C++ backtrace. -Fixed a bug where keys would get stuck on X11 if pressed simultaneously -Added Api on IP singleton to request local IPs. -Premultiplied alpha support when importing texture, editing PNGs and as a blend mode.
2014-05-24 04:35:47 +00:00
if (xkeyevent->type != KeyPress) {
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
p_echo = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// make sure there are events pending,
// so this call won't block.
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
if (p_event_index + 1 < p_events.size()) {
XEvent &peek_event = p_events[p_event_index + 1];
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Refactor 'treshold' to 'threshold'
2017-07-08 15:12:18 +00:00
// I'm using a threshold of 5 msecs,
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// 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.
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Fix all -Wtype-limits warnings.
2019-02-20 20:59:03 +00:00
::Time tresh = ABSDIFF(peek_event.xkey.time, xkeyevent->time);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (peek_event.type == KeyPress && tresh < 5) {
Making Godot Easier to Use.. -=-=-=-=-=-=-=-=-=-=-=-=-=-= -Auto indenter in code editor, this makes it much easier to paste external code. -Zoom in 2D viewport now uses the mouse pointer as reference. -Obscure hack to see where code/line of GDScript in C++ backtrace. -Fixed a bug where keys would get stuck on X11 if pressed simultaneously -Added Api on IP singleton to request local IPs. -Premultiplied alpha support when importing texture, editing PNGs and as a blend mode.
2014-05-24 04:35:47 +00:00
KeySym rk;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
XLookupString((XKeyEvent *)&peek_event, str, 256, &rk, nullptr);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (rk == keysym_keycode) {
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
// Consume to next event.
++p_event_index;
_handle_key_event((XKeyEvent *)&peek_event, p_events, p_event_index, true);
Making Godot Easier to Use.. -=-=-=-=-=-=-=-=-=-=-=-=-=-= -Auto indenter in code editor, this makes it much easier to paste external code. -Zoom in 2D viewport now uses the mouse pointer as reference. -Obscure hack to see where code/line of GDScript in C++ backtrace. -Fixed a bug where keys would get stuck on X11 if pressed simultaneously -Added Api on IP singleton to request local IPs. -Premultiplied alpha support when importing texture, editing PNGs and as a blend mode.
2014-05-24 04:35:47 +00:00
return; //ignore current, echo next
}
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// use the time from peek_event so it always works
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
// save the time to check for echo when keypress happens
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/* Phase 7, send event to Window */
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
k->set_pressed(keypress);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (keycode >= 'a' && keycode <= 'z') {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
keycode -= 'a' - 'A';
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
k->set_scancode(keycode);
Add `physical_scancode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2021-03-07 15:16:42 +00:00
k->set_physical_scancode(physical_keycode);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
k->set_unicode(unicode);
k->set_echo(p_echo);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
if (k->get_scancode() == KEY_BACKTAB) {
Fix typos in source code using codespell From https://github.com/lucasdemarchi/codespell
2017-03-24 20:45:31 +00:00
//make it consistent across platforms.
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
k->set_scancode(KEY_TAB);
Add `physical_scancode` (keyboard layout independent keycodes) to InputEventKey and InputMap. Fix non-latin keyboard layout keycodes on Linux/X11 (fallback to physical keycodes).
2021-03-07 15:16:42 +00:00
k->set_physical_scancode(KEY_TAB);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
k->set_shift(true);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
x11: Fix event.is_action() for release of modifier keys The bug was that the release events for these also had the modifier state set, so the event comparison failed. Fixes #5901
2016-09-22 10:24:44 +00:00
//don't set mod state if modifier keys are released by themselves
//else event.is_action() will not work correctly here
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
if (!k->is_pressed()) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (k->get_scancode() == KEY_SHIFT) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
k->set_shift(false);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
} else if (k->get_scancode() == KEY_CONTROL) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
k->set_control(false);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
} else if (k->get_scancode() == KEY_ALT) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
k->set_alt(false);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
} else if (k->get_scancode() == KEY_META) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
k->set_metakey(false);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
x11: Fix event.is_action() for release of modifier keys The bug was that the release events for these also had the modifier state set, so the event comparison failed. Fixes #5901
2016-09-22 10:24:44 +00:00
}
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
bool last_is_pressed = Input::get_singleton()->is_key_pressed(k->get_scancode());
if (k->is_pressed()) {
if (last_is_pressed) {
k->set_echo(true);
}
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
//printf("key: %x\n",k->get_scancode());
Improve input event accumulation - API has been simplified: all events now go through `parse_input_event()`. Whether they are accumulated or not depends on the `use_accumulated_input` flag. - Event accumulation is now thread-safe (it was not needed so far, but it prepares the ground for the following changes). - Touch drag events now support accumulation.
2020-09-20 19:30:34 +00:00
input->parse_input_event(k);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
Atom OS_X11::_process_selection_request_target(Atom p_target, Window p_requestor, Atom p_property) const {
if (p_target == XInternAtom(x11_display, "TARGETS", 0)) {
// Request to list all supported targets.
Atom data[9];
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
data[0] = XInternAtom(x11_display, "TARGETS", 0);
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
data[1] = XInternAtom(x11_display, "SAVE_TARGETS", 0);
data[2] = XInternAtom(x11_display, "MULTIPLE", 0);
data[3] = XInternAtom(x11_display, "UTF8_STRING", 0);
data[4] = XInternAtom(x11_display, "COMPOUND_TEXT", 0);
data[5] = XInternAtom(x11_display, "TEXT", 0);
data[6] = XA_STRING;
data[7] = XInternAtom(x11_display, "text/plain;charset=utf-8", 0);
data[8] = XInternAtom(x11_display, "text/plain", 0);
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
XChangeProperty(x11_display,
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
p_requestor,
p_property,
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
XA_ATOM,
32,
PropModeReplace,
(unsigned char *)&data,
sizeof(data) / sizeof(data[0]));
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
return p_property;
} else if (p_target == XInternAtom(x11_display, "SAVE_TARGETS", 0)) {
// Request to check if SAVE_TARGETS is supported, nothing special to do.
XChangeProperty(x11_display,
p_requestor,
p_property,
XInternAtom(x11_display, "NULL", False),
32,
PropModeReplace,
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
nullptr,
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
0);
return p_property;
} else if (p_target == XInternAtom(x11_display, "UTF8_STRING", 0) ||
clang-format: Disable alignment of operands, too unreliable Sets `AlignOperands` to `DontAlign`. `clang-format` developers seem to mostly care about space-based indentation and every other version of clang-format breaks the bad mismatch of tabs and spaces that it seems to use for operand alignment. So it's better without, so that it respects our two-tabs `ContinuationIndentWidth`.
2021-10-28 11:23:24 +00:00
p_target == XInternAtom(x11_display, "COMPOUND_TEXT", 0) ||
p_target == XInternAtom(x11_display, "TEXT", 0) ||
p_target == XA_STRING ||
p_target == XInternAtom(x11_display, "text/plain;charset=utf-8", 0) ||
p_target == XInternAtom(x11_display, "text/plain", 0)) {
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
// Directly using internal clipboard because we know our window
// is the owner during a selection request.
CharString clip = OS::get_clipboard().utf8();
XChangeProperty(x11_display,
p_requestor,
p_property,
p_target,
8,
PropModeReplace,
(unsigned char *)clip.get_data(),
clip.length());
return p_property;
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
} else {
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
char *target_name = XGetAtomName(x11_display, p_target);
printf("Target '%s' not supported.\n", target_name);
if (target_name) {
XFree(target_name);
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
}
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
return None;
}
}
void OS_X11::_handle_selection_request_event(XSelectionRequestEvent *p_event) const {
XEvent respond;
if (p_event->target == XInternAtom(x11_display, "MULTIPLE", 0)) {
// Request for multiple target conversions at once.
Atom atom_pair = XInternAtom(x11_display, "ATOM_PAIR", False);
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
respond.xselection.property = None;
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
Atom type;
int format;
unsigned long len;
unsigned long remaining;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
unsigned char *data = nullptr;
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
if (XGetWindowProperty(x11_display, p_event->requestor, p_event->property, 0, LONG_MAX, False, atom_pair, &type, &format, &len, &remaining, &data) == Success) {
if ((len >= 2) && data) {
Atom *targets = (Atom *)data;
for (uint64_t i = 0; i < len; i += 2) {
Atom target = targets[i];
Atom &property = targets[i + 1];
property = _process_selection_request_target(target, p_event->requestor, property);
}
XChangeProperty(x11_display,
p_event->requestor,
p_event->property,
atom_pair,
32,
PropModeReplace,
(unsigned char *)targets,
len);
respond.xselection.property = p_event->property;
}
XFree(data);
}
} else {
// Request for target conversion.
respond.xselection.property = _process_selection_request_target(p_event->target, p_event->requestor, p_event->property);
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
}
respond.xselection.type = SelectionNotify;
respond.xselection.display = p_event->display;
respond.xselection.requestor = p_event->requestor;
respond.xselection.selection = p_event->selection;
respond.xselection.target = p_event->target;
respond.xselection.time = p_event->time;
XSendEvent(x11_display, p_event->requestor, True, NoEventMask, &respond);
XFlush(x11_display);
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
struct Property {
xdnd: can handle more than 3 different target types Now dropping also works with Nemo and PCManFM(gtk)
2016-05-29 15:40:08 +00:00
unsigned char *data;
int format, nitems;
Atom type;
};
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
static Property read_property(Display *p_display, Window p_window, Atom p_property) {
Fix used uninitialized warning in os_x11.cpp
2021-02-06 10:43:02 +00:00
Atom actual_type = None;
int actual_format = 0;
unsigned long nitems = 0;
unsigned long bytes_after = 0;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
unsigned char *ret = nullptr;
xdnd: can handle more than 3 different target types Now dropping also works with Nemo and PCManFM(gtk)
2016-05-29 15:40:08 +00:00
int read_bytes = 1024;
//Keep trying to read the property until there are no
//bytes unread.
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
if (p_property != None) {
do {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (ret != nullptr) {
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
XFree(ret);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
xdnd: can handle more than 3 different target types Now dropping also works with Nemo and PCManFM(gtk)
2016-05-29 15:40:08 +00:00
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
XGetWindowProperty(p_display, p_window, p_property, 0, read_bytes, False, AnyPropertyType,
&actual_type, &actual_format, &nitems, &bytes_after,
&ret);
xdnd: can handle more than 3 different target types Now dropping also works with Nemo and PCManFM(gtk)
2016-05-29 15:40:08 +00:00
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
read_bytes *= 2;
xdnd: can handle more than 3 different target types Now dropping also works with Nemo and PCManFM(gtk)
2016-05-29 15:40:08 +00:00
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
} while (bytes_after != 0);
}
xdnd: can handle more than 3 different target types Now dropping also works with Nemo and PCManFM(gtk)
2016-05-29 15:40:08 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Property p = { ret, actual_format, (int)nitems, actual_type };
xdnd: can handle more than 3 different target types Now dropping also works with Nemo and PCManFM(gtk)
2016-05-29 15:40:08 +00:00
return p;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
static Atom pick_target_from_list(Display *p_display, Atom *p_list, int p_count) {
static const char *target_type = "text/uri-list";
xdnd: can handle more than 3 different target types Now dropping also works with Nemo and PCManFM(gtk)
2016-05-29 15:40:08 +00:00
for (int i = 0; i < p_count; i++) {
Atom atom = p_list[i];
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (atom != None && String(XGetAtomName(p_display, atom)) == target_type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
return atom;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
xdnd: can handle more than 3 different target types Now dropping also works with Nemo and PCManFM(gtk)
2016-05-29 15:40:08 +00:00
}
return None;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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";
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (p_t1 != None && String(XGetAtomName(p_disp, p_t1)) == target_type) {
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
return p_t1;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (p_t2 != None && String(XGetAtomName(p_disp, p_t2)) == target_type) {
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
return p_t2;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (p_t3 != None && String(XGetAtomName(p_disp, p_t3)) == target_type) {
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
return p_t3;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
return None;
}
Fix x11 boot logo position in fullscreen and in maximized
2017-10-24 19:35:28 +00:00
void OS_X11::_window_changed(XEvent *event) {
if (xic) {
// Not portable.
set_ime_position(Point2(0, 1));
}
if ((event->xconfigure.width == current_videomode.width) &&
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
(event->xconfigure.height == current_videomode.height)) {
Fix x11 boot logo position in fullscreen and in maximized
2017-10-24 19:35:28 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Fix x11 boot logo position in fullscreen and in maximized
2017-10-24 19:35:28 +00:00
current_videomode.width = event->xconfigure.width;
current_videomode.height = event->xconfigure.height;
}
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
void OS_X11::_poll_events_thread(void *ud) {
OS_X11 *os = (OS_X11 *)ud;
os->_poll_events();
}
Bool OS_X11::_predicate_all_events(Display *display, XEvent *event, XPointer arg) {
// Just accept all events.
return True;
}
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
bool OS_X11::_wait_for_events() const {
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
int x11_fd = ConnectionNumber(x11_display);
fd_set in_fds;
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
XFlush(x11_display);
FD_ZERO(&in_fds);
FD_SET(x11_fd, &in_fds);
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
struct timeval tv;
tv.tv_usec = 0;
tv.tv_sec = 1;
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
// Wait for next event or timeout.
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
int num_ready_fds = select(x11_fd + 1, &in_fds, nullptr, nullptr, &tv);
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
if (num_ready_fds > 0) {
// Event received.
return true;
} else {
// Error or timeout.
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
if (num_ready_fds < 0) {
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
ERR_PRINT("_wait_for_events: select error: " + itos(errno));
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
}
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
return false;
}
}
void OS_X11::_poll_events() {
while (!events_thread_done) {
_wait_for_events();
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
// Process events from the queue.
{
MutexLock mutex_lock(events_mutex);
Fix input events random delay on X11 The new system based on a thread gathering events from the X11 server was causing delays in some scenarios where some events have just been missed at the time of processing and we're waiting for a whole frame to check them again. Solved by flushing again and checking for pending events at the beginning of the process loop, in addition to events already gathered on the event thread.
2021-10-26 22:44:00 +00:00
_check_pending_events(polled_events);
}
}
}
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
Fix input events random delay on X11 The new system based on a thread gathering events from the X11 server was causing delays in some scenarios where some events have just been missed at the time of processing and we're waiting for a whole frame to check them again. Solved by flushing again and checking for pending events at the beginning of the process loop, in addition to events already gathered on the event thread.
2021-10-26 22:44:00 +00:00
void OS_X11::_check_pending_events(LocalVector<XEvent> &r_events) {
// Flush to make sure to gather all pending events.
XFlush(x11_display);
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
Fix input events random delay on X11 The new system based on a thread gathering events from the X11 server was causing delays in some scenarios where some events have just been missed at the time of processing and we're waiting for a whole frame to check them again. Solved by flushing again and checking for pending events at the beginning of the process loop, in addition to events already gathered on the event thread.
2021-10-26 22:44:00 +00:00
// Non-blocking wait for next event and remove it from the queue.
XEvent ev;
while (XCheckIfEvent(x11_display, &ev, _predicate_all_events, nullptr)) {
// Check if the input manager wants to process the event.
if (XFilterEvent(&ev, None)) {
// Event has been filtered by the Input Manager,
// it has to be ignored and a new one will be received.
continue;
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
}
Fix input events random delay on X11 The new system based on a thread gathering events from the X11 server was causing delays in some scenarios where some events have just been missed at the time of processing and we're waiting for a whole frame to check them again. Solved by flushing again and checking for pending events at the beginning of the process loop, in addition to events already gathered on the event thread.
2021-10-26 22:44:00 +00:00
// Handle selection request events directly in the event thread, because
// communication through the x server takes several events sent back and forth
// and we don't want to block other programs while processing only one each frame.
if (ev.type == SelectionRequest) {
_handle_selection_request_event(&(ev.xselectionrequest));
continue;
}
r_events.push_back(ev);
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
void OS_X11::process_xevents() {
//printf("checking events %i\n", XPending(x11_display));
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
do_mouse_warp = false;
Added focus tracking in X11 and Windows classes, added new confined mouse mode (#7162)
2017-01-25 18:21:41 +00:00
// Is the current mouse mode one where it needs to be grabbed.
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
bool mouse_mode_grab = mouse_mode == MOUSE_MODE_CAPTURED || mouse_mode == MOUSE_MODE_CONFINED;
Added focus tracking in X11 and Windows classes, added new confined mouse mode (#7162)
2017-01-25 18:21:41 +00:00
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
xi.pressure = 0;
xi.tilt = Vector2();
[Linux/Windows] Set pressure to 1.0f when primary button is pressed and device is not pressure sensitive. (cherry picked from commit 012894789443dbb4f1882c11fd08b4c2f1618a0f)
2020-05-03 12:38:58 +00:00
xi.pressure_supported = false;
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
LocalVector<XEvent> events;
{
// Block events polling while flushing events.
MutexLock mutex_lock(events_mutex);
events = polled_events;
polled_events.clear();
Fix input events random delay on X11 The new system based on a thread gathering events from the X11 server was causing delays in some scenarios where some events have just been missed at the time of processing and we're waiting for a whole frame to check them again. Solved by flushing again and checking for pending events at the beginning of the process loop, in addition to events already gathered on the event thread.
2021-10-26 22:44:00 +00:00
// Check for more pending events to avoid an extra frame delay.
_check_pending_events(events);
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
for (uint32_t event_index = 0; event_index < events.size(); ++event_index) {
XEvent &event = events[event_index];
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
if (XGetEventData(x11_display, &event.xcookie)) {
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
if (event.xcookie.type == GenericEvent && event.xcookie.extension == xi.opcode) {
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
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) {
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
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.
Fix missed captured mouse events on x11
2018-12-19 17:19:05 +00:00
if (raw_event->valuators.mask_len <= 0) {
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
break;
}
Fix missed captured mouse events on x11
2018-12-19 17:19:05 +00:00
const double *values = raw_event->raw_values;
double rel_x = 0.0;
double rel_y = 0.0;
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
if (XIMaskIsSet(raw_event->valuators.mask, VALUATOR_ABSX)) {
Fix missed captured mouse events on x11
2018-12-19 17:19:05 +00:00
rel_x = *values;
values++;
}
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
if (XIMaskIsSet(raw_event->valuators.mask, VALUATOR_ABSY)) {
Fix missed captured mouse events on x11
2018-12-19 17:19:05 +00:00
rel_y = *values;
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
values++;
}
if (XIMaskIsSet(raw_event->valuators.mask, VALUATOR_PRESSURE)) {
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
Map<int, Vector2>::Element *pen_pressure = xi.pen_pressure_range.find(device_id);
if (pen_pressure) {
Vector2 pen_pressure_range = pen_pressure->value();
[Linux/Windows] Set pressure to 1.0f when primary button is pressed and device is not pressure sensitive. (cherry picked from commit 012894789443dbb4f1882c11fd08b4c2f1618a0f)
2020-05-03 12:38:58 +00:00
if (pen_pressure_range != Vector2()) {
xi.pressure_supported = true;
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
xi.pressure = (*values - pen_pressure_range[0]) /
clang-format: Disable alignment of operands, too unreliable Sets `AlignOperands` to `DontAlign`. `clang-format` developers seem to mostly care about space-based indentation and every other version of clang-format breaks the bad mismatch of tabs and spaces that it seems to use for operand alignment. So it's better without, so that it respects our two-tabs `ContinuationIndentWidth`.
2021-10-28 11:23:24 +00:00
(pen_pressure_range[1] - pen_pressure_range[0]);
[Linux/Windows] Set pressure to 1.0f when primary button is pressed and device is not pressure sensitive. (cherry picked from commit 012894789443dbb4f1882c11fd08b4c2f1618a0f)
2020-05-03 12:38:58 +00:00
}
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
}
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
values++;
}
if (XIMaskIsSet(raw_event->valuators.mask, VALUATOR_TILTX)) {
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
Map<int, Vector2>::Element *pen_tilt_x = xi.pen_tilt_x_range.find(device_id);
if (pen_tilt_x) {
Vector2 pen_tilt_x_range = pen_tilt_x->value();
if (pen_tilt_x_range != Vector2()) {
xi.tilt.x = ((*values - pen_tilt_x_range[0]) / (pen_tilt_x_range[1] - pen_tilt_x_range[0])) * 2 - 1;
}
}
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
values++;
}
if (XIMaskIsSet(raw_event->valuators.mask, VALUATOR_TILTY)) {
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
Map<int, Vector2>::Element *pen_tilt_y = xi.pen_tilt_y_range.find(device_id);
if (pen_tilt_y) {
Vector2 pen_tilt_y_range = pen_tilt_y->value();
if (pen_tilt_y_range != Vector2()) {
xi.tilt.y = ((*values - pen_tilt_y_range[0]) / (pen_tilt_y_range[1] - pen_tilt_y_range[0])) * 2 - 1;
}
}
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
Fix X11 pressure and tilt values. (cherry picked from commit a2ad0878edcae0aad72c792fa93de40b8c92f5a0)
2020-04-10 10:41:41 +00:00
values++;
Fix missed captured mouse events on x11
2018-12-19 17:19:05 +00:00
}
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
// 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;
}
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
xi.last_relative_time = raw_event->time;
} break;
#ifdef TOUCH_ENABLED
clang-format: Various fixes to comments alignment from `clang-format` 13 All reviewed manually and occasionally rewritten to avoid bad auto formatting.
2021-10-28 12:15:02 +00:00
case XI_TouchBegin:
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
case XI_TouchEnd: {
bool is_begin = event_data->evtype == XI_TouchBegin;
Ref<InputEventScreenTouch> st;
st.instance();
st->set_index(index);
st->set_position(pos);
st->set_pressed(is_begin);
if (is_begin) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (xi.state.has(index)) { // Defensive
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
break;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
xi.state[index] = pos;
if (xi.state.size() == 1) {
Implement universal translation of touch to mouse Now generating mouse events from touch is optional (on by default) and it's performed by `InputDefault` instead of having each OS abstraction doing it. (*) The translation algorithm waits for a touch index to be pressed and tracks it translating its events to mouse events until it is raised, while ignoring other pointers. Furthermore, to avoid an stuck "touch mouse", since not all platforms may report touches raised when the window is unfocused, it checks if touches are still down by the time it's focused again and if so it resets the state of the emulated mouse. *: In the case of Windows, since it already provides touch-to-mouse translation by itself, "echo" mouse events are filtered out to have it working like the rest. On X11 a little hack has been needed to avoid a case of a spurious mouse motion event that is generated during touch interaction. Plus: Improve/fix tracking of current mouse position. ** Summary of changes to settings: ** - `display/window/handheld/emulate_touchscreen` becomes `input/pointing_devices/emulate_touch_from_mouse` - New setting: `input/pointing_devices/emulate_mouse_from_touch`
2018-02-24 02:04:30 +00:00
// 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
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
xi.mouse_pos_to_filter = pos;
Implement universal translation of touch to mouse Now generating mouse events from touch is optional (on by default) and it's performed by `InputDefault` instead of having each OS abstraction doing it. (*) The translation algorithm waits for a touch index to be pressed and tracks it translating its events to mouse events until it is raised, while ignoring other pointers. Furthermore, to avoid an stuck "touch mouse", since not all platforms may report touches raised when the window is unfocused, it checks if touches are still down by the time it's focused again and if so it resets the state of the emulated mouse. *: In the case of Windows, since it already provides touch-to-mouse translation by itself, "echo" mouse events are filtered out to have it working like the rest. On X11 a little hack has been needed to avoid a case of a spurious mouse motion event that is generated during touch interaction. Plus: Improve/fix tracking of current mouse position. ** Summary of changes to settings: ** - `display/window/handheld/emulate_touchscreen` becomes `input/pointing_devices/emulate_touch_from_mouse` - New setting: `input/pointing_devices/emulate_mouse_from_touch`
2018-02-24 02:04:30 +00:00
}
Improve input event accumulation - API has been simplified: all events now go through `parse_input_event()`. Whether they are accumulated or not depends on the `use_accumulated_input` flag. - Event accumulation is now thread-safe (it was not needed so far, but it prepares the ground for the following changes). - Touch drag events now support accumulation.
2020-09-20 19:30:34 +00:00
input->parse_input_event(st);
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
} else {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (!xi.state.has(index)) { // Defensive
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
break;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
xi.state.erase(index);
Improve input event accumulation - API has been simplified: all events now go through `parse_input_event()`. Whether they are accumulated or not depends on the `use_accumulated_input` flag. - Event accumulation is now thread-safe (it was not needed so far, but it prepares the ground for the following changes). - Touch drag events now support accumulation.
2020-09-20 19:30:34 +00:00
input->parse_input_event(st);
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
}
} break;
case XI_TouchUpdate: {
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
Map<int, Vector2>::Element *curr_pos_elem = xi.state.find(index);
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
if (!curr_pos_elem) { // Defensive
break;
}
if (curr_pos_elem->value() != pos) {
Ref<InputEventScreenDrag> sd;
sd.instance();
sd->set_index(index);
sd->set_position(pos);
sd->set_relative(pos - curr_pos_elem->value());
Improve input event accumulation - API has been simplified: all events now go through `parse_input_event()`. Whether they are accumulated or not depends on the `use_accumulated_input` flag. - Event accumulation is now thread-safe (it was not needed so far, but it prepares the ground for the following changes). - Touch drag events now support accumulation.
2020-09-20 19:30:34 +00:00
input->parse_input_event(sd);
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
curr_pos_elem->value() = pos;
}
} break;
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
#endif
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
}
}
}
Fix no mouse if touch device present in X11 Plus several improvements in this area. Sadly, grabbing has been disabled until a better solution is found. Fixes #14427.
2017-12-10 06:05:17 +00:00
XFreeEventData(x11_display, &event.xcookie);
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
switch (event.type) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
case Expose:
Main::force_redraw();
break;
Added ability to set custom mouse cursors. Not hardware accelerated yet.
2015-09-24 21:06:15 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
case NoExpose:
minimized = true;
break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
case VisibilityNotify: {
XVisibilityEvent *visibility = (XVisibilityEvent *)&event;
minimized = (visibility->state == VisibilityFullyObscured);
} break;
case LeaveNotify: {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (main_loop && !mouse_mode_grab) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
main_loop->notification(MainLoop::NOTIFICATION_WM_MOUSE_EXIT);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} break;
case EnterNotify: {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (main_loop && !mouse_mode_grab) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
main_loop->notification(MainLoop::NOTIFICATION_WM_MOUSE_ENTER);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} break;
case FocusIn:
minimized = false;
window_has_focus = true;
main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_IN);
Add an `OS.is_window_focused()` getter This makes it possible to know whether the window is focused at a given time, without having to track the focus state manually using `NOTIFICATION_WM_FOCUS_IN` and `NOTIFICATION_WM_FOCUS_OUT`. This partially addresses #33928.
2019-11-28 12:41:07 +00:00
window_focused = true;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (mouse_mode_grab) {
// Show and update the cursor if confined and the window regained focus.
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (mouse_mode == MOUSE_MODE_CONFINED) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XUndefineCursor(x11_display, x11_window);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
} else if (mouse_mode == MOUSE_MODE_CAPTURED) { // or re-hide it in captured mode
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XDefineCursor(x11_display, x11_window, null_cursor);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XGrabPointer(
x11_display, x11_window, True,
ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
GrabModeAsync, GrabModeAsync, x11_window, None, CurrentTime);
Added focus tracking in X11 and Windows classes, added new confined mouse mode (#7162)
2017-01-25 18:21:41 +00:00
}
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
#ifdef TOUCH_ENABLED
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 01:11:03 +00:00
// Grab touch devices to avoid OS gesture interference
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
/*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);
Fix no mouse if touch device present in X11 Plus several improvements in this area. Sadly, grabbing has been disabled until a better solution is found. Fixes #14427.
2017-12-10 06:05:17 +00:00
}*/
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
#endif
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
if (xic) {
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
// Block events polling while changing input focus
// because it triggers some event polling internally.
MutexLock mutex_lock(events_mutex);
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
XSetICFocus(xic);
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
break;
remove trailing whitespace
2016-03-08 23:00:52 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
case FocusOut:
window_has_focus = false;
[Input] Release keys/actions pressed if window loses focus Co-authored-by: bruvzg <7645683+bruvzg@users.noreply.github.com> Co-authored-by: Marcelo Fernandez <marcelofg55@gmail.com>
2019-04-15 17:41:44 +00:00
input->release_pressed_events();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_OUT);
Add an `OS.is_window_focused()` getter This makes it possible to know whether the window is focused at a given time, without having to track the focus state manually using `NOTIFICATION_WM_FOCUS_IN` and `NOTIFICATION_WM_FOCUS_OUT`. This partially addresses #33928.
2019-11-28 12:41:07 +00:00
window_focused = false;
[Input] Release keys/actions pressed if window loses focus Co-authored-by: bruvzg <7645683+bruvzg@users.noreply.github.com> Co-authored-by: Marcelo Fernandez <marcelofg55@gmail.com>
2019-04-15 17:41:44 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (mouse_mode_grab) {
//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, x11_window);
}
XUngrabPointer(x11_display, CurrentTime);
}
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
#ifdef TOUCH_ENABLED
// Ungrab touch devices so input works as usual while we are unfocused
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
/*for (int i = 0; i < xi.touch_devices.size(); ++i) {
XIUngrabDevice(x11_display, xi.touch_devices[i], CurrentTime);
Fix no mouse if touch device present in X11 Plus several improvements in this area. Sadly, grabbing has been disabled until a better solution is found. Fixes #14427.
2017-12-10 06:05:17 +00:00
}*/
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
// Release every pointer to avoid sticky points
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
for (Map<int, Vector2>::Element *E = xi.state.front(); E; E = E->next()) {
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
Ref<InputEventScreenTouch> st;
st.instance();
st->set_index(E->key());
st->set_position(E->get());
Improve input event accumulation - API has been simplified: all events now go through `parse_input_event()`. Whether they are accumulated or not depends on the `use_accumulated_input` flag. - Event accumulation is now thread-safe (it was not needed so far, but it prepares the ground for the following changes). - Touch drag events now support accumulation.
2020-09-20 19:30:34 +00:00
input->parse_input_event(st);
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
}
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
xi.state.clear();
Implement multitouch on X11
2017-11-29 20:01:26 +00:00
#endif
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
if (xic) {
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
// Block events polling while changing input focus
// because it triggers some event polling internally.
MutexLock mutex_lock(events_mutex);
Workaround for IME and echo events on Linux: Request detectable auto-repeat (Require XKB extension) to support echo events and IME at the same time. Fixes #29, #7106 and #9381.
2017-06-27 09:26:43 +00:00
XUnsetICFocus(xic);
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
break;
remove trailing whitespace
2016-03-08 23:00:52 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
case ConfigureNotify:
Fix x11 boot logo position in fullscreen and in maximized
2017-10-24 19:35:28 +00:00
_window_changed(&event);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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;
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Ref<InputEventMouseButton> mb;
mb.instance();
get_key_modifier_state(event.xbutton.state, mb);
switch middle and secondary mouse buttons order
2018-12-15 13:10:06 +00:00
mb->set_button_index(event.xbutton.button);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (mb->get_button_index() == 2) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
mb->set_button_index(3);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
} else if (mb->get_button_index() == 3) {
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
mb->set_button_index(2);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
switch middle and secondary mouse buttons order
2018-12-15 13:10:06 +00:00
mb->set_button_mask(get_mouse_button_state(mb->get_button_index(), event.xbutton.type));
Fixed button mask behavior
2018-07-08 13:12:13 +00:00
mb->set_position(Vector2(event.xbutton.x, event.xbutton.y));
mb->set_global_position(mb->get_position());
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
mb->set_pressed((event.type == ButtonPress));
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Added double clicking to all buttons
2018-07-20 16:16:09 +00:00
if (event.type == ButtonPress) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
uint64_t diff = get_ticks_usec() / 1000 - last_click_ms;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Added double clicking to all buttons
2018-07-20 16:16:09 +00:00
if (mb->get_button_index() == last_click_button_index) {
if (diff < 400 && Point2(last_click_pos).distance_to(Point2(event.xbutton.x, event.xbutton.y)) < 5) {
last_click_ms = 0;
last_click_pos = Point2(-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()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
last_click_ms += diff;
last_click_pos = Point2(event.xbutton.x, event.xbutton.y);
}
-fixes to capture mode -ability to drag spinboxes and tree ranges to change values, like in Unity or Unreal
2015-08-29 04:43:21 +00:00
}
Improve input event accumulation - API has been simplified: all events now go through `parse_input_event()`. Whether they are accumulated or not depends on the `use_accumulated_input` flag. - Event accumulation is now thread-safe (it was not needed so far, but it prepares the ground for the following changes). - Touch drag events now support accumulation.
2020-09-20 19:30:34 +00:00
input->parse_input_event(mb);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} break;
case MotionNotify: {
Changed the comment where reduz yells at the X11 API to a less explicitive one
2018-10-01 22:30:11 +00:00
// 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.
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
while (true) {
if (mouse_mode == MOUSE_MODE_CAPTURED && event.xmotion.x == current_videomode.width / 2 && event.xmotion.y == current_videomode.height / 2) {
//this is likely the warp event since it was warped here
center = Vector2(event.xmotion.x, event.xmotion.y);
break;
}
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
if (event_index + 1 < events.size()) {
const XEvent &next_event = events[event_index + 1];
if (next_event.type == MotionNotify) {
++event_index;
event = next_event;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else {
break;
}
-fixes to capture mode -ability to drag spinboxes and tree ranges to change values, like in Unity or Unreal
2015-08-29 04:43:21 +00:00
} else {
break;
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
last_timestamp = event.xmotion.time;
remove trailing whitespace
2016-03-08 23:00:52 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
// Motion is also simple.
// A little hack is in order
// to be able to send relative motion events.
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
Point2 pos(event.xmotion.x, event.xmotion.y);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Implement universal translation of touch to mouse Now generating mouse events from touch is optional (on by default) and it's performed by `InputDefault` instead of having each OS abstraction doing it. (*) The translation algorithm waits for a touch index to be pressed and tracks it translating its events to mouse events until it is raised, while ignoring other pointers. Furthermore, to avoid an stuck "touch mouse", since not all platforms may report touches raised when the window is unfocused, it checks if touches are still down by the time it's focused again and if so it resets the state of the emulated mouse. *: In the case of Windows, since it already provides touch-to-mouse translation by itself, "echo" mouse events are filtered out to have it working like the rest. On X11 a little hack has been needed to avoid a case of a spurious mouse motion event that is generated during touch interaction. Plus: Improve/fix tracking of current mouse position. ** Summary of changes to settings: ** - `display/window/handheld/emulate_touchscreen` becomes `input/pointing_devices/emulate_touch_from_mouse` - New setting: `input/pointing_devices/emulate_mouse_from_touch`
2018-02-24 02:04:30 +00:00
// Avoidance of spurious mouse motion (see handling of touch)
bool filter = false;
// Adding some tolerance to match better Point2i to Vector2
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
if (xi.state.size() && Vector2(pos).distance_squared_to(xi.mouse_pos_to_filter) < 2) {
Implement universal translation of touch to mouse Now generating mouse events from touch is optional (on by default) and it's performed by `InputDefault` instead of having each OS abstraction doing it. (*) The translation algorithm waits for a touch index to be pressed and tracks it translating its events to mouse events until it is raised, while ignoring other pointers. Furthermore, to avoid an stuck "touch mouse", since not all platforms may report touches raised when the window is unfocused, it checks if touches are still down by the time it's focused again and if so it resets the state of the emulated mouse. *: In the case of Windows, since it already provides touch-to-mouse translation by itself, "echo" mouse events are filtered out to have it working like the rest. On X11 a little hack has been needed to avoid a case of a spurious mouse motion event that is generated during touch interaction. Plus: Improve/fix tracking of current mouse position. ** Summary of changes to settings: ** - `display/window/handheld/emulate_touchscreen` becomes `input/pointing_devices/emulate_touch_from_mouse` - New setting: `input/pointing_devices/emulate_mouse_from_touch`
2018-02-24 02:04:30 +00:00
filter = true;
}
// Invalidate to avoid filtering a possible legitimate similar event coming later
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
xi.mouse_pos_to_filter = Vector2(1e10, 1e10);
Implement universal translation of touch to mouse Now generating mouse events from touch is optional (on by default) and it's performed by `InputDefault` instead of having each OS abstraction doing it. (*) The translation algorithm waits for a touch index to be pressed and tracks it translating its events to mouse events until it is raised, while ignoring other pointers. Furthermore, to avoid an stuck "touch mouse", since not all platforms may report touches raised when the window is unfocused, it checks if touches are still down by the time it's focused again and if so it resets the state of the emulated mouse. *: In the case of Windows, since it already provides touch-to-mouse translation by itself, "echo" mouse events are filtered out to have it working like the rest. On X11 a little hack has been needed to avoid a case of a spurious mouse motion event that is generated during touch interaction. Plus: Improve/fix tracking of current mouse position. ** Summary of changes to settings: ** - `display/window/handheld/emulate_touchscreen` becomes `input/pointing_devices/emulate_touch_from_mouse` - New setting: `input/pointing_devices/emulate_mouse_from_touch`
2018-02-24 02:04:30 +00:00
if (filter) {
break;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (mouse_mode == MOUSE_MODE_CAPTURED) {
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
if (xi.relative_motion.x == 0 && xi.relative_motion.y == 0) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
break;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Point2i new_center = pos;
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
pos = last_mouse_pos + xi.relative_motion;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
center = new_center;
do_mouse_warp = window_has_focus; // warp the cursor if we're focused in
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (!last_mouse_pos_valid) {
last_mouse_pos = pos;
last_mouse_pos_valid = true;
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
// 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...
Point2 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;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Fixes to mouse mode confined and captured These modes will work on Linux in the same way as Windows.
2018-09-04 13:11:37 +00:00
if (mouse_mode == MOUSE_MODE_CAPTURED) {
pos = Point2i(current_videomode.width / 2, current_videomode.height / 2);
}
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
Ref<InputEventMouseMotion> mm;
mm.instance();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
[Linux/Windows] Set pressure to 1.0f when primary button is pressed and device is not pressure sensitive. (cherry picked from commit 012894789443dbb4f1882c11fd08b4c2f1618a0f)
2020-05-03 12:38:58 +00:00
if (xi.pressure_supported) {
mm->set_pressure(xi.pressure);
} else {
mm->set_pressure((get_mouse_button_state() & (1 << (BUTTON_LEFT - 1))) ? 1.0f : 0.0f);
}
[macOS, Windows, X11] Add graphic tablet pen pressure and tilt support to InputEventMouseMotion event.
2018-12-13 20:32:11 +00:00
mm->set_tilt(xi.tilt);
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
// Make the absolute position integral so it doesn't look _too_ weird :)
Point2i posi(pos);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
get_key_modifier_state(event.xmotion.state, mm);
Fixed button mask behavior
2018-07-08 13:12:13 +00:00
mm->set_button_mask(get_mouse_button_state());
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
mm->set_position(posi);
mm->set_global_position(posi);
input->set_mouse_position(posi);
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
mm->set_speed(input->get_last_mouse_speed());
Use XInput2 RawMotion to generate MouseMotion events The current system for capturing the mouse and generating motion events on X11 has issues with inaccurate and lopsided input. This is because both XQueryPointer and XWarpPointer work in terms of integer coordinates when the underlying X11 input driver may be tracking the mouse using subpixel coordinates. When warping the pointer, the fractional part of the pointer position is discarded. To work around this issue, the fix uses raw motion events from XInput 2. These events report relative motion and are not affected by pointer warping. Additionally, this means Godot is able to detect motion at a higher resolution under X11. Because this is raw mouse input, it is not affected by the user's pointer speed and acceleration settings. This is the same system as SDL2 uses for its relative motion. Multitouch input on X requires XInput 2.2. Raw motion events require XInput 2.0. Since 2.0 is old enough, this is now the minimum requirement to use Godot on X.
2018-08-17 22:59:26 +00:00
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
mm->set_relative(rel);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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.
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (window_has_focus || !mouse_mode_grab) {
Improve input event accumulation - API has been simplified: all events now go through `parse_input_event()`. Whether they are accumulated or not depends on the `use_accumulated_input` flag. - Event accumulation is now thread-safe (it was not needed so far, but it prepares the ground for the following changes). - Touch drag events now support accumulation.
2020-09-20 19:30:34 +00:00
input->parse_input_event(mm);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} break;
case KeyPress:
case KeyRelease: {
last_timestamp = event.xkey.time;
// key event is a little complex, so
Repaired mistyped of 'its' on several files.
2018-10-25 00:19:21 +00:00
// it will be handled in its own function.
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
_handle_key_event((XKeyEvent *)&event, events, event_index);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} break;
remove trailing whitespace
2016-03-08 23:00:52 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
case SelectionNotify:
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (event.xselection.target == requested) {
Property p = read_property(x11_display, x11_window, XInternAtom(x11_display, "PRIMARY", 0));
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Vector<String> files = String((char *)p.data).split("\n", false);
for (int i = 0; i < files.size(); i++) {
Fix and expose String::strip_escapes(), use it in LineEdit paste Supersedes #27736.
2019-05-31 13:27:53 +00:00
files.write[i] = files[i].replace("file://", "").http_unescape().strip_edges();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
main_loop->drop_files(files);
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
//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] = x11_window;
m.data.l[1] = 1;
m.data.l[2] = xdnd_action_copy; //We only ever copy.
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XSendEvent(x11_display, xdnd_source_window, False, NoEventMask, (XEvent *)&m);
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
case ClientMessage:
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if ((unsigned int)event.xclient.data.l[0] == (unsigned int)wm_delete) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
main_loop->notification(MainLoop::NOTIFICATION_WM_QUIT_REQUEST);
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
} else if ((unsigned int)event.xclient.message_type == (unsigned int)xdnd_enter) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
//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);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
requested = pick_target_from_atoms(x11_display, event.xclient.data.l[2], event.xclient.data.l[3], event.xclient.data.l[4]);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} 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
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
XClientMessageEvent m;
fix memset calls Order is "mem, val, count", not "mem, count, val"
2016-06-19 00:06:25 +00:00
memset(&m, 0, sizeof(m));
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
m.type = ClientMessage;
m.display = event.xclient.display;
m.window = event.xclient.data.l[0];
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
m.message_type = xdnd_status;
m.format = 32;
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
m.data.l[0] = x11_window;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
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];
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (xdnd_version >= 1) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XConvertSelection(x11_display, xdnd_selection, requested, XInternAtom(x11_display, "PRIMARY", 0), x11_window, event.xclient.data.l[2]);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XConvertSelection(x11_display, xdnd_selection, requested, XInternAtom(x11_display, "PRIMARY", 0), x11_window, CurrentTime);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} 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] = 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);
}
x11: Add support for filesystem drag & drop using xdnd
2016-05-28 19:35:42 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
break;
default:
break;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
XFlush(x11_display);
if (do_mouse_warp) {
XWarpPointer(x11_display, None, x11_window,
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
0, 0, 0, 0, (int)current_videomode.width / 2, (int)current_videomode.height / 2);
cleanup + MouseGrab
2015-02-12 14:58:00 +00:00
remove trailing whitespace
2016-03-08 23:00:52 +00:00
/*
cleanup + MouseGrab
2015-02-12 14:58:00 +00:00
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);
*/
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Add support for event accumlation (off by default, on for editor), fixes #26536
2019-03-03 22:52:18 +00:00
Add input buffering framework Input buffering is implicitly used by event accumulation, but this commit makes it more generic so it can be enabled for other uses. For desktop OSs it's currently not feasible given main and UI threads are the same).
2021-08-03 16:59:20 +00:00
input->flush_buffered_events();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
MainLoop *OS_X11::get_main_loop() const {
return main_loop;
}
void OS_X11::delete_main_loop() {
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
// Send owned clipboard data to clipboard manager before exit.
// This has to be done here because the clipboard data is cleared before finalize().
_clipboard_transfer_ownership(XA_PRIMARY, x11_window);
_clipboard_transfer_ownership(XInternAtom(x11_display, "CLIPBOARD", 0), x11_window);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (main_loop) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
memdelete(main_loop);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
main_loop = nullptr;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
void OS_X11::set_main_loop(MainLoop *p_main_loop) {
main_loop = p_main_loop;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
input->set_main_loop(p_main_loop);
}
bool OS_X11::can_draw() const {
return !minimized;
};
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
void OS_X11::set_clipboard(const String &p_text) {
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
{
// The clipboard content can be accessed while polling for events.
MutexLock mutex_lock(events_mutex);
OS::set_clipboard(p_text);
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
XSetSelectionOwner(x11_display, XA_PRIMARY, x11_window, CurrentTime);
XSetSelectionOwner(x11_display, XInternAtom(x11_display, "CLIPBOARD", 0), x11_window, CurrentTime);
};
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
Bool OS_X11::_predicate_clipboard_selection(Display *display, XEvent *event, XPointer arg) {
if (event->type == SelectionNotify && event->xselection.requestor == *(Window *)arg) {
return True;
} else {
return False;
}
}
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
Bool OS_X11::_predicate_clipboard_incr(Display *display, XEvent *event, XPointer arg) {
if (event->type == PropertyNotify && event->xproperty.state == PropertyNewValue) {
return True;
} else {
return False;
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
String OS_X11::_get_clipboard_impl(Atom p_source, Window x11_window, Atom target) const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
String ret;
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
Window selection_owner = XGetSelectionOwner(x11_display, p_source);
if (selection_owner == x11_window) {
return OS::get_clipboard();
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
if (selection_owner != None) {
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
// Block events polling while processing selection events.
MutexLock mutex_lock(events_mutex);
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
Atom selection = XA_PRIMARY;
XConvertSelection(x11_display, p_source, target, selection,
x11_window, CurrentTime);
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
XFlush(x11_display);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
// Blocking wait for predicate to be True and remove the event from the queue.
XEvent event;
XIfEvent(x11_display, &event, _predicate_clipboard_selection, (XPointer)&x11_window);
// Do not get any data, see how much data is there.
Atom type;
int format, result;
unsigned long len, bytes_left, dummy;
unsigned char *data;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XGetWindowProperty(x11_display, x11_window,
selection, // Tricky..
0, 0, // offset - len
0, // Delete 0==FALSE
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
AnyPropertyType, // flag
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
&type, // return type
&format, // return format
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
&len, &bytes_left, // data length
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
&data);
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
if (data) {
XFree(data);
}
if (type == XInternAtom(x11_display, "INCR", 0)) {
// Data is going to be received incrementally.
LocalVector<uint8_t> incr_data;
uint32_t data_size = 0;
bool success = false;
// Delete INCR property to notify the owner.
XDeleteProperty(x11_display, x11_window, type);
// Process events from the queue.
bool done = false;
while (!done) {
if (!_wait_for_events()) {
// Error or timeout, abort.
break;
}
// Non-blocking wait for next event and remove it from the queue.
XEvent ev;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
while (XCheckIfEvent(x11_display, &ev, _predicate_clipboard_incr, nullptr)) {
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
result = XGetWindowProperty(x11_display, x11_window,
selection, // selection type
0, LONG_MAX, // offset - len
True, // delete property to notify the owner
AnyPropertyType, // flag
&type, // return type
&format, // return format
&len, &bytes_left, // data length
&data);
if (result == Success) {
if (data && (len > 0)) {
uint32_t prev_size = incr_data.size();
if (prev_size == 0) {
// First property contains initial data size.
unsigned long initial_size = *(unsigned long *)data;
incr_data.resize(initial_size);
} else {
// New chunk, resize to be safe and append data.
incr_data.resize(MAX(data_size + len, prev_size));
memcpy(incr_data.ptr() + data_size, data, len);
data_size += len;
}
} else {
// Last chunk, process finished.
done = true;
success = true;
}
} else {
printf("Failed to get selection data chunk.\n");
done = true;
}
if (data) {
XFree(data);
}
if (done) {
break;
}
}
}
if (success && (data_size > 0)) {
ret.parse_utf8((const char *)incr_data.ptr(), data_size);
}
} else if (bytes_left > 0) {
// Data is ready and can be processed all at once.
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
result = XGetWindowProperty(x11_display, x11_window,
selection, 0, bytes_left, 0,
AnyPropertyType, &type, &format,
&len, &dummy, &data);
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
if (result == Success) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ret.parse_utf8((const char *)data);
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
} else {
printf("Failed to get selection data.\n");
}
if (data) {
XFree(data);
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
}
return ret;
Code cleanup in platform/x11
2016-07-21 19:11:34 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
String OS_X11::_get_clipboard(Atom p_source, Window x11_window) const {
Workaround to allow pasting unicode characters from X selection. Fixes #2491. Fixes #9787.
2017-07-24 22:36:19 +00:00
String ret;
Atom utf8_atom = XInternAtom(x11_display, "UTF8_STRING", True);
if (utf8_atom != None) {
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
ret = _get_clipboard_impl(p_source, x11_window, utf8_atom);
Workaround to allow pasting unicode characters from X selection. Fixes #2491. Fixes #9787.
2017-07-24 22:36:19 +00:00
}
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
if (ret.empty()) {
ret = _get_clipboard_impl(p_source, x11_window, XA_STRING);
Workaround to allow pasting unicode characters from X selection. Fixes #2491. Fixes #9787.
2017-07-24 22:36:19 +00:00
}
return ret;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
String OS_X11::get_clipboard() const {
String ret;
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
ret = _get_clipboard(XInternAtom(x11_display, "CLIPBOARD", 0), x11_window);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fix issues related to delay when processing events on Linux 3.2 backport of PR #41910: Fix general keyboard input lag on X11 display server Fix delay to process clipboard content from Godot in other programs
2020-09-25 16:16:39 +00:00
if (ret.empty()) {
ret = _get_clipboard(XA_PRIMARY, x11_window);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
};
return ret;
Code cleanup in platform/x11
2016-07-21 19:11:34 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
Bool OS_X11::_predicate_clipboard_save_targets(Display *display, XEvent *event, XPointer arg) {
if (event->xany.window == *(Window *)arg) {
return (event->type == SelectionRequest) ||
clang-format: Disable alignment of operands, too unreliable Sets `AlignOperands` to `DontAlign`. `clang-format` developers seem to mostly care about space-based indentation and every other version of clang-format breaks the bad mismatch of tabs and spaces that it seems to use for operand alignment. So it's better without, so that it respects our two-tabs `ContinuationIndentWidth`.
2021-10-28 11:23:24 +00:00
(event->type == SelectionNotify);
Fix issues with Linux clipboard Backport for X11 Display Server fixes on 3.2 branch. 1. Implement SAVE_TARGETS mechanism Allows sending the clipboard content to the clipboard manager on exit to keep the content when using a clipboard manager that doesn't automatically makes a backup when copying. MULTIPLE selection mechanism also had to be implemented, because in this case, the clipboard manager might request multiple selection targets at once. Known use case: Ubuntu with XFCE4 2. Implement INCR mechanism Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 19:19:51 +00:00
} else {
return False;
}
}
void OS_X11::_clipboard_transfer_ownership(Atom p_source, Window x11_window) const {
Window selection_owner = XGetSelectionOwner(x11_display, p_source);
if (selection_owner != x11_window) {
return;
}
// Block events polling while processing selection events.
MutexLock mutex_lock(events_mutex);
Atom clipboard_manager = XInternAtom(x11_display, "CLIPBOARD_MANAGER", False);
Atom save_targets = XInternAtom(x11_display, "SAVE_TARGETS", False);
XConvertSelection(x11_display, clipboard_manager, save_targets, None,
x11_window, CurrentTime);
// Process events from the queue.
while (true) {
if (!_wait_for_events()) {
// Error or timeout, abort.
break;
}
// Non-blocking wait for next event and remove it from the queue.
XEvent ev;
while (XCheckIfEvent(x11_display, &ev, _predicate_clipboard_save_targets, (XPointer)&x11_window)) {
switch (ev.type) {
case SelectionRequest:
_handle_selection_request_event(&(ev.xselectionrequest));
break;
case SelectionNotify: {
if (ev.xselection.target == save_targets) {
// Once SelectionNotify is received, we're done whether it succeeded or not.
return;
}
break;
}
}
}
}
}
added a const keyword for a methods that return constant literal...
2019-05-20 17:36:24 +00:00
String OS_X11::get_name() const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return "X11";
}
-Fixed viewport stretch bugs -Fixed input in viewport stretch bugs -Fixed tilemap pixel overlap (really?)
2014-04-18 14:43:54 +00:00
Error OS_X11::shell_open(String p_uri) {
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
Error ok;
Changed shell_open behaviour (cherry picked from commit 9e57a395cf2a093f273c4f10e16f224d2c7f2ddd)
2020-10-24 15:54:24 +00:00
int err_code;
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
List<String> args;
args.push_back(p_uri);
Changed shell_open behaviour (cherry picked from commit 9e57a395cf2a093f273c4f10e16f224d2c7f2ddd)
2020-10-24 15:54:24 +00:00
// Agnostic
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
ok = execute("xdg-open", args, true, nullptr, nullptr, &err_code);
Changed shell_open behaviour (cherry picked from commit 9e57a395cf2a093f273c4f10e16f224d2c7f2ddd)
2020-10-24 15:54:24 +00:00
if (ok == OK && !err_code) {
return OK;
} else if (err_code == 2) {
return ERR_FILE_NOT_FOUND;
}
// GNOME
args.push_front("open"); // The command is `gio open`, so we need to add it to args
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
ok = execute("gio", args, true, nullptr, nullptr, &err_code);
Changed shell_open behaviour (cherry picked from commit 9e57a395cf2a093f273c4f10e16f224d2c7f2ddd)
2020-10-24 15:54:24 +00:00
if (ok == OK && !err_code) {
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
return OK;
Changed shell_open behaviour (cherry picked from commit 9e57a395cf2a093f273c4f10e16f224d2c7f2ddd)
2020-10-24 15:54:24 +00:00
} else if (err_code == 2) {
return ERR_FILE_NOT_FOUND;
}
args.pop_front();
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
ok = execute("gvfs-open", args, true, nullptr, nullptr, &err_code);
Changed shell_open behaviour (cherry picked from commit 9e57a395cf2a093f273c4f10e16f224d2c7f2ddd)
2020-10-24 15:54:24 +00:00
if (ok == OK && !err_code) {
return OK;
} else if (err_code == 2) {
return ERR_FILE_NOT_FOUND;
}
// KDE
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
ok = execute("kde-open5", args, true, nullptr, nullptr, &err_code);
Changed shell_open behaviour (cherry picked from commit 9e57a395cf2a093f273c4f10e16f224d2c7f2ddd)
2020-10-24 15:54:24 +00:00
if (ok == OK && !err_code) {
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
return OK;
Changed shell_open behaviour (cherry picked from commit 9e57a395cf2a093f273c4f10e16f224d2c7f2ddd)
2020-10-24 15:54:24 +00:00
}
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
ok = execute("kde-open", args, true, nullptr, nullptr, &err_code);
Changed shell_open behaviour (cherry picked from commit 9e57a395cf2a093f273c4f10e16f224d2c7f2ddd)
2020-10-24 15:54:24 +00:00
return !err_code ? ok : FAILED;
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
}
-Renamed GlobalConfig to ProjectSettings, makes more sense. -Added system for feature overrides, it's pretty cool :)
2017-07-19 20:00:46 +00:00
bool OS_X11::_check_internal_feature_support(const String &p_feature) {
-Remove harcoded opengl extension testing from OS, ask rasterizer instead. -Fixed a bug where etc textures were imported broken
2019-02-26 14:58:47 +00:00
return p_feature == "pc";
-Renamed GlobalConfig to ProjectSettings, makes more sense. -Added system for feature overrides, it's pretty cool :)
2017-07-19 20:00:46 +00:00
}
Add initial support for the XDG Base Directory spec Spec version 0.7 from https://standards.freedesktop.org/basedir-spec/basedir-spec-0.7.html (latest as of this commit). Three virtual methods are added to OS for the various XDG paths we will use: - OS::get_data_path gives XDG_DATA_HOME, or if missing: ~/.local/share on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows - OS::get_config_path gives XDG_CONFIG_HOME, or if missing: ~/.config on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows - OS::get_cache_path gives XDG_CACHE_HOME, or if missing: ~/.cache on X11, ~/Library/Caches on macOS and %APPDATA% on Windows So for Windows there are no changes, for Linux we follow the full split spec and for macOS stuff will move from ~/.godot to ~/Library/Application Support/Godot. Support for system-wide installation of templates on Unix was removed for now, as it's a bit hackish and I don't think anyone uses it. user:// will still be OS::get_data_path() + "/godot/app_userdata/$name" by default, but when using the application/config/use_shared_user_dir option it will now use XDG_DATA_HOME/$name, e.g. ~/.local/share/MyGame. For now everything still goes in EditorSettings::get_settings_dir(), but this will be changed in a later commit to make use of the new splitting where relevant. Part of #3513.
2017-11-17 16:11:41 +00:00
String OS_X11::get_config_path() const {
if (has_environment("XDG_CONFIG_HOME")) {
Only allow absolute paths in XDG environment variables The XDG Base Directory specification does not allow using relative paths (which broke things in Godot anyway). If a relative path is detected, it should be ignored. (cherry picked from commits 011a99316ab8c0e96971aebd9ba995313867fe17 and 0e1d45b210d0e5924b279419d9bba188f557e329)
2021-05-07 17:02:35 +00:00
if (get_environment("XDG_CONFIG_HOME").is_abs_path()) {
return get_environment("XDG_CONFIG_HOME");
} else {
WARN_PRINT_ONCE("`XDG_CONFIG_HOME` is a relative path. Ignoring its value and falling back to `$HOME/.config` or `.` per the XDG Base Directory specification.");
}
}
if (has_environment("HOME")) {
Add initial support for the XDG Base Directory spec Spec version 0.7 from https://standards.freedesktop.org/basedir-spec/basedir-spec-0.7.html (latest as of this commit). Three virtual methods are added to OS for the various XDG paths we will use: - OS::get_data_path gives XDG_DATA_HOME, or if missing: ~/.local/share on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows - OS::get_config_path gives XDG_CONFIG_HOME, or if missing: ~/.config on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows - OS::get_cache_path gives XDG_CACHE_HOME, or if missing: ~/.cache on X11, ~/Library/Caches on macOS and %APPDATA% on Windows So for Windows there are no changes, for Linux we follow the full split spec and for macOS stuff will move from ~/.godot to ~/Library/Application Support/Godot. Support for system-wide installation of templates on Unix was removed for now, as it's a bit hackish and I don't think anyone uses it. user:// will still be OS::get_data_path() + "/godot/app_userdata/$name" by default, but when using the application/config/use_shared_user_dir option it will now use XDG_DATA_HOME/$name, e.g. ~/.local/share/MyGame. For now everything still goes in EditorSettings::get_settings_dir(), but this will be changed in a later commit to make use of the new splitting where relevant. Part of #3513.
2017-11-17 16:11:41 +00:00
return get_environment("HOME").plus_file(".config");
}
Only allow absolute paths in XDG environment variables The XDG Base Directory specification does not allow using relative paths (which broke things in Godot anyway). If a relative path is detected, it should be ignored. (cherry picked from commits 011a99316ab8c0e96971aebd9ba995313867fe17 and 0e1d45b210d0e5924b279419d9bba188f557e329)
2021-05-07 17:02:35 +00:00
return ".";
Add initial support for the XDG Base Directory spec Spec version 0.7 from https://standards.freedesktop.org/basedir-spec/basedir-spec-0.7.html (latest as of this commit). Three virtual methods are added to OS for the various XDG paths we will use: - OS::get_data_path gives XDG_DATA_HOME, or if missing: ~/.local/share on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows - OS::get_config_path gives XDG_CONFIG_HOME, or if missing: ~/.config on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows - OS::get_cache_path gives XDG_CACHE_HOME, or if missing: ~/.cache on X11, ~/Library/Caches on macOS and %APPDATA% on Windows So for Windows there are no changes, for Linux we follow the full split spec and for macOS stuff will move from ~/.godot to ~/Library/Application Support/Godot. Support for system-wide installation of templates on Unix was removed for now, as it's a bit hackish and I don't think anyone uses it. user:// will still be OS::get_data_path() + "/godot/app_userdata/$name" by default, but when using the application/config/use_shared_user_dir option it will now use XDG_DATA_HOME/$name, e.g. ~/.local/share/MyGame. For now everything still goes in EditorSettings::get_settings_dir(), but this will be changed in a later commit to make use of the new splitting where relevant. Part of #3513.
2017-11-17 16:11:41 +00:00
}
String OS_X11::get_data_path() const {
if (has_environment("XDG_DATA_HOME")) {
Only allow absolute paths in XDG environment variables The XDG Base Directory specification does not allow using relative paths (which broke things in Godot anyway). If a relative path is detected, it should be ignored. (cherry picked from commits 011a99316ab8c0e96971aebd9ba995313867fe17 and 0e1d45b210d0e5924b279419d9bba188f557e329)
2021-05-07 17:02:35 +00:00
if (get_environment("XDG_DATA_HOME").is_abs_path()) {
return get_environment("XDG_DATA_HOME");
} else {
WARN_PRINT_ONCE("`XDG_DATA_HOME` is a relative path. Ignoring its value and falling back to `$HOME/.local/share` or `get_config_path()` per the XDG Base Directory specification.");
}
}
if (has_environment("HOME")) {
Add initial support for the XDG Base Directory spec Spec version 0.7 from https://standards.freedesktop.org/basedir-spec/basedir-spec-0.7.html (latest as of this commit). Three virtual methods are added to OS for the various XDG paths we will use: - OS::get_data_path gives XDG_DATA_HOME, or if missing: ~/.local/share on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows - OS::get_config_path gives XDG_CONFIG_HOME, or if missing: ~/.config on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows - OS::get_cache_path gives XDG_CACHE_HOME, or if missing: ~/.cache on X11, ~/Library/Caches on macOS and %APPDATA% on Windows So for Windows there are no changes, for Linux we follow the full split spec and for macOS stuff will move from ~/.godot to ~/Library/Application Support/Godot. Support for system-wide installation of templates on Unix was removed for now, as it's a bit hackish and I don't think anyone uses it. user:// will still be OS::get_data_path() + "/godot/app_userdata/$name" by default, but when using the application/config/use_shared_user_dir option it will now use XDG_DATA_HOME/$name, e.g. ~/.local/share/MyGame. For now everything still goes in EditorSettings::get_settings_dir(), but this will be changed in a later commit to make use of the new splitting where relevant. Part of #3513.
2017-11-17 16:11:41 +00:00
return get_environment("HOME").plus_file(".local/share");
}
Only allow absolute paths in XDG environment variables The XDG Base Directory specification does not allow using relative paths (which broke things in Godot anyway). If a relative path is detected, it should be ignored. (cherry picked from commits 011a99316ab8c0e96971aebd9ba995313867fe17 and 0e1d45b210d0e5924b279419d9bba188f557e329)
2021-05-07 17:02:35 +00:00
return get_config_path();
Add initial support for the XDG Base Directory spec Spec version 0.7 from https://standards.freedesktop.org/basedir-spec/basedir-spec-0.7.html (latest as of this commit). Three virtual methods are added to OS for the various XDG paths we will use: - OS::get_data_path gives XDG_DATA_HOME, or if missing: ~/.local/share on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows - OS::get_config_path gives XDG_CONFIG_HOME, or if missing: ~/.config on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows - OS::get_cache_path gives XDG_CACHE_HOME, or if missing: ~/.cache on X11, ~/Library/Caches on macOS and %APPDATA% on Windows So for Windows there are no changes, for Linux we follow the full split spec and for macOS stuff will move from ~/.godot to ~/Library/Application Support/Godot. Support for system-wide installation of templates on Unix was removed for now, as it's a bit hackish and I don't think anyone uses it. user:// will still be OS::get_data_path() + "/godot/app_userdata/$name" by default, but when using the application/config/use_shared_user_dir option it will now use XDG_DATA_HOME/$name, e.g. ~/.local/share/MyGame. For now everything still goes in EditorSettings::get_settings_dir(), but this will be changed in a later commit to make use of the new splitting where relevant. Part of #3513.
2017-11-17 16:11:41 +00:00
}
String OS_X11::get_cache_path() const {
if (has_environment("XDG_CACHE_HOME")) {
Only allow absolute paths in XDG environment variables The XDG Base Directory specification does not allow using relative paths (which broke things in Godot anyway). If a relative path is detected, it should be ignored. (cherry picked from commits 011a99316ab8c0e96971aebd9ba995313867fe17 and 0e1d45b210d0e5924b279419d9bba188f557e329)
2021-05-07 17:02:35 +00:00
if (get_environment("XDG_CACHE_HOME").is_abs_path()) {
return get_environment("XDG_CACHE_HOME");
} else {
WARN_PRINT_ONCE("`XDG_CACHE_HOME` is a relative path. Ignoring its value and falling back to `$HOME/.cache` or `get_config_path()` per the XDG Base Directory specification.");
}
}
if (has_environment("HOME")) {
Add initial support for the XDG Base Directory spec Spec version 0.7 from https://standards.freedesktop.org/basedir-spec/basedir-spec-0.7.html (latest as of this commit). Three virtual methods are added to OS for the various XDG paths we will use: - OS::get_data_path gives XDG_DATA_HOME, or if missing: ~/.local/share on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows - OS::get_config_path gives XDG_CONFIG_HOME, or if missing: ~/.config on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows - OS::get_cache_path gives XDG_CACHE_HOME, or if missing: ~/.cache on X11, ~/Library/Caches on macOS and %APPDATA% on Windows So for Windows there are no changes, for Linux we follow the full split spec and for macOS stuff will move from ~/.godot to ~/Library/Application Support/Godot. Support for system-wide installation of templates on Unix was removed for now, as it's a bit hackish and I don't think anyone uses it. user:// will still be OS::get_data_path() + "/godot/app_userdata/$name" by default, but when using the application/config/use_shared_user_dir option it will now use XDG_DATA_HOME/$name, e.g. ~/.local/share/MyGame. For now everything still goes in EditorSettings::get_settings_dir(), but this will be changed in a later commit to make use of the new splitting where relevant. Part of #3513.
2017-11-17 16:11:41 +00:00
return get_environment("HOME").plus_file(".cache");
}
Only allow absolute paths in XDG environment variables The XDG Base Directory specification does not allow using relative paths (which broke things in Godot anyway). If a relative path is detected, it should be ignored. (cherry picked from commits 011a99316ab8c0e96971aebd9ba995313867fe17 and 0e1d45b210d0e5924b279419d9bba188f557e329)
2021-05-07 17:02:35 +00:00
return get_config_path();
Add initial support for the XDG Base Directory spec Spec version 0.7 from https://standards.freedesktop.org/basedir-spec/basedir-spec-0.7.html (latest as of this commit). Three virtual methods are added to OS for the various XDG paths we will use: - OS::get_data_path gives XDG_DATA_HOME, or if missing: ~/.local/share on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows - OS::get_config_path gives XDG_CONFIG_HOME, or if missing: ~/.config on X11, ~/Library/Application Support/ on macOS and %APPDATA% on Windows - OS::get_cache_path gives XDG_CACHE_HOME, or if missing: ~/.cache on X11, ~/Library/Caches on macOS and %APPDATA% on Windows So for Windows there are no changes, for Linux we follow the full split spec and for macOS stuff will move from ~/.godot to ~/Library/Application Support/Godot. Support for system-wide installation of templates on Unix was removed for now, as it's a bit hackish and I don't think anyone uses it. user:// will still be OS::get_data_path() + "/godot/app_userdata/$name" by default, but when using the application/config/use_shared_user_dir option it will now use XDG_DATA_HOME/$name, e.g. ~/.local/share/MyGame. For now everything still goes in EditorSettings::get_settings_dir(), but this will be changed in a later commit to make use of the new splitting where relevant. Part of #3513.
2017-11-17 16:11:41 +00:00
}
Add partial support for Android scoped storage. This is done by providing API access to app specific directories which don't have any limitations and allows us to bump the target sdk version to 30. In addition, we're also bumping the min sdk version to 19 as version 18 is no longer supported by Google Play Services and only account of 0.3% of Android devices.
2021-07-11 01:39:31 +00:00
String OS_X11::get_system_dir(SystemDir p_dir, bool p_shared_storage) const {
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
String xdgparam;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
switch (p_dir) {
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
case SYSTEM_DIR_DESKTOP: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
xdgparam = "DESKTOP";
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
} break;
case SYSTEM_DIR_DCIM: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
xdgparam = "PICTURES";
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
} break;
case SYSTEM_DIR_DOCUMENTS: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
xdgparam = "DOCUMENTS";
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
} break;
case SYSTEM_DIR_DOWNLOADS: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
xdgparam = "DOWNLOAD";
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
} break;
case SYSTEM_DIR_MOVIES: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
xdgparam = "VIDEOS";
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
} break;
case SYSTEM_DIR_MUSIC: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
xdgparam = "MUSIC";
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
} break;
case SYSTEM_DIR_PICTURES: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
xdgparam = "PICTURES";
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
} break;
case SYSTEM_DIR_RINGTONES: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
xdgparam = "MUSIC";
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
} break;
}
String pipe;
List<String> arg;
arg.push_back(xdgparam);
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
Error err = const_cast<OS_X11 *>(this)->execute("xdg-user-dir", arg, true, nullptr, &pipe);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (err != OK) {
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
return ".";
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
-Ability to ask for documents/pictures/etc system dirs. -Fixes to animationplayer -fixes to collada importer
2014-12-02 17:02:41 +00:00
return pipe.strip_edges();
-Fixed viewport stretch bugs -Fixed input in viewport stretch bugs -Fixed tilemap pixel overlap (really?)
2014-04-18 14:43:54 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
void OS_X11::move_window_to_foreground() {
Replace XRaiseWindow with a _NET_ACTIVE_WINDOW ClientRequest This fixes the editor on X11 not getting put on the foreground when a debugged project hits an error or breakpoint.
2018-08-16 19:36:37 +00:00
XEvent xev;
Atom net_active_window = XInternAtom(x11_display, "_NET_ACTIVE_WINDOW", False);
memset(&xev, 0, sizeof(xev));
xev.type = ClientMessage;
xev.xclient.window = 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);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
void OS_X11::set_cursor_shape(CursorShape p_shape) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ERR_FAIL_INDEX(p_shape, CURSOR_MAX);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fix set_default_cursor_shape interaction with Control nodes Do not call `set_cursor_shape` when the cursor is inside the `Control` node. Make it work for x11 in MOUSE_MODE_CONFINED.
2018-09-15 18:54:22 +00:00
if (p_shape == current_cursor) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
Fix set_default_cursor_shape interaction with Control nodes Do not call `set_cursor_shape` when the cursor is inside the `Control` node. Make it work for x11 in MOUSE_MODE_CONFINED.
2018-09-15 18:54:22 +00:00
}
if (mouse_mode == MOUSE_MODE_VISIBLE || mouse_mode == MOUSE_MODE_CONFINED) {
if (cursors[p_shape] != None) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XDefineCursor(x11_display, x11_window, cursors[p_shape]);
Fix set_default_cursor_shape interaction with Control nodes Do not call `set_cursor_shape` when the cursor is inside the `Control` node. Make it work for x11 in MOUSE_MODE_CONFINED.
2018-09-15 18:54:22 +00:00
} else if (cursors[CURSOR_ARROW] != None) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XDefineCursor(x11_display, x11_window, cursors[CURSOR_ARROW]);
Fix set_default_cursor_shape interaction with Control nodes Do not call `set_cursor_shape` when the cursor is inside the `Control` node. Make it work for x11 in MOUSE_MODE_CONFINED.
2018-09-15 18:54:22 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
current_cursor = p_shape;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Add Input::get_current_cursor_shape [Clean up] Removed unused/unnecessary methods.
2019-04-15 15:30:20 +00:00
OS::CursorShape OS_X11::get_cursor_shape() const {
return current_cursor;
}
Add implementation for custom hardware cursor
2017-11-10 10:50:11 +00:00
void OS_X11::set_custom_mouse_cursor(const RES &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
if (p_cursor.is_valid()) {
Style: Set clang-format Standard to c++14
2021-05-04 12:20:36 +00:00
Map<CursorShape, Vector<Variant>>::Element *cursor_c = cursors_cache.find(p_shape);
Fix cursor blinking in integrated GPUs Optimization for Input::set_custom_mouse_cursor when used inside _process function. (Avoids cursor blinking in low end devices)
2019-07-08 20:37:18 +00:00
if (cursor_c) {
if (cursor_c->get()[0] == p_cursor && cursor_c->get()[1] == p_hotspot) {
set_cursor_shape(p_shape);
return;
}
cursors_cache.erase(p_shape);
}
Add implementation for custom hardware cursor
2017-11-10 10:50:11 +00:00
Ref<Texture> texture = p_cursor;
Add support for atlas texture on set_custom_mouse_cursor
2018-05-08 14:07:43 +00:00
Ref<AtlasTexture> atlas_texture = p_cursor;
Ref<Image> image;
Size2 texture_size;
Rect2 atlas_rect;
Add implementation for custom hardware cursor
2017-11-10 10:50:11 +00:00
Add support for atlas texture on set_custom_mouse_cursor
2018-05-08 14:07:43 +00:00
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());
Really fix the custom cursor hotspot Add check for negative values. Fixes #21721
2018-09-04 02:42:23 +00:00
ERR_FAIL_COND(p_hotspot.x < 0 || p_hotspot.y < 0);
Add support for atlas texture on set_custom_mouse_cursor
2018-05-08 14:07:43 +00:00
ERR_FAIL_COND(texture_size.width > 256 || texture_size.height > 256);
Fix custom cursor hotspot Cursor hotspot must be inside image on Linux. Adding validation for all platforms for consistency.
2018-09-03 12:21:13 +00:00
ERR_FAIL_COND(p_hotspot.x > texture_size.width || p_hotspot.y > texture_size.height);
Add support for atlas texture on set_custom_mouse_cursor
2018-05-08 14:07:43 +00:00
image = texture->get_data();
Add implementation for custom hardware cursor
2017-11-10 10:50:11 +00:00
Change position of validation in set_custom_mouse_cursor
2018-05-28 12:36:30 +00:00
ERR_FAIL_COND(!image.is_valid());
Add implementation for custom hardware cursor
2017-11-10 10:50:11 +00:00
// Create the cursor structure
Add support for atlas texture on set_custom_mouse_cursor
2018-05-08 14:07:43 +00:00
XcursorImage *cursor_image = XcursorImageCreate(texture_size.width, texture_size.height);
XcursorUInt image_size = texture_size.width * texture_size.height;
Add implementation for custom hardware cursor
2017-11-10 10:50:11 +00:00
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
Fix memory leak in set_custom_mouse_cursor
2018-05-26 18:58:12 +00:00
cursor_image->pixels = (XcursorPixel *)memalloc(size);
Add implementation for custom hardware cursor
2017-11-10 10:50:11 +00:00
image->lock();
for (XcursorPixel index = 0; index < image_size; index++) {
Add support for atlas texture on set_custom_mouse_cursor
2018-05-08 14:07:43 +00:00
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);
}
Add implementation for custom hardware cursor
2017-11-10 10:50:11 +00:00
Remove size restriction for mouse cursor
2018-04-05 16:07:44 +00:00
*(cursor_image->pixels + index) = image->get_pixel(column_index, row_index).to_argb32();
Add implementation for custom hardware cursor
2017-11-10 10:50:11 +00:00
}
image->unlock();
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
ERR_FAIL_COND(cursor_image->pixels == nullptr);
Add implementation for custom hardware cursor
2017-11-10 10:50:11 +00:00
// Save it for a further usage
cursors[p_shape] = XcursorImageLoadCursor(x11_display, cursor_image);
Fix cursor blinking in integrated GPUs Optimization for Input::set_custom_mouse_cursor when used inside _process function. (Avoids cursor blinking in low end devices)
2019-07-08 20:37:18 +00:00
Vector<Variant> params;
params.push_back(p_cursor);
params.push_back(p_hotspot);
cursors_cache.insert(p_shape, params);
Fix set_custom_mouse_cursor changing to incorrect cursor shape [Docs] Add class ref for Input::set_default_cursor_shape
2018-09-13 17:53:20 +00:00
if (p_shape == current_cursor) {
Fix Input::set_custom_mouse_cursor showing cursor when it's invisible
2018-09-17 14:37:54 +00:00
if (mouse_mode == MOUSE_MODE_VISIBLE || mouse_mode == MOUSE_MODE_CONFINED) {
XDefineCursor(x11_display, x11_window, cursors[p_shape]);
}
Add implementation for custom hardware cursor
2017-11-10 10:50:11 +00:00
}
Fix memory leak in set_custom_mouse_cursor
2018-05-26 18:58:12 +00:00
memfree(cursor_image->pixels);
XcursorImageDestroy(cursor_image);
Reset the cursor with Input.set_custom_mouse_cursor(null)
2018-05-10 22:17:00 +00:00
} else {
// Reset to default system cursor
if (img[p_shape]) {
cursors[p_shape] = XcursorImageLoadCursor(x11_display, img[p_shape]);
}
Fix set_custom_mouse_cursor changing to incorrect cursor shape [Docs] Add class ref for Input::set_default_cursor_shape
2018-09-13 17:53:20 +00:00
CursorShape c = current_cursor;
Reset the cursor with Input.set_custom_mouse_cursor(null)
2018-05-10 22:17:00 +00:00
current_cursor = CURSOR_MAX;
Fix set_custom_mouse_cursor changing to incorrect cursor shape [Docs] Add class ref for Input::set_default_cursor_shape
2018-09-13 17:53:20 +00:00
set_cursor_shape(c);
Properly revert cursor when using set_custom_mouse_cursor with null Fixes #32486
2019-10-03 11:02:11 +00:00
cursors_cache.erase(p_shape);
Add implementation for custom hardware cursor
2017-11-10 10:50:11 +00:00
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
void OS_X11::release_rendering_thread() {
bugfix: correct #ifdef for TOUCH_ENABLED and OPENGL_ENABLED
2018-06-22 14:42:28 +00:00
#if defined(OPENGL_ENABLED)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
context_gl->release_current();
bugfix: correct #ifdef for TOUCH_ENABLED and OPENGL_ENABLED
2018-06-22 14:42:28 +00:00
#endif
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
void OS_X11::make_rendering_thread() {
bugfix: correct #ifdef for TOUCH_ENABLED and OPENGL_ENABLED
2018-06-22 14:42:28 +00:00
#if defined(OPENGL_ENABLED)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
context_gl->make_current();
bugfix: correct #ifdef for TOUCH_ENABLED and OPENGL_ENABLED
2018-06-22 14:42:28 +00:00
#endif
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
void OS_X11::swap_buffers() {
bugfix: correct #ifdef for TOUCH_ENABLED and OPENGL_ENABLED
2018-06-22 14:42:28 +00:00
#if defined(OPENGL_ENABLED)
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
context_gl->swap_buffers();
bugfix: correct #ifdef for TOUCH_ENABLED and OPENGL_ENABLED
2018-06-22 14:42:28 +00:00
#endif
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
void OS_X11::alert(const String &p_alert, const String &p_title) {
Implement no-window mode for X11 and MacOS Bonus: Homogeinize and improve OS::alert() for no-window mode
2020-09-23 11:43:51 +00:00
if (is_no_window_mode_enabled()) {
print_line("ALERT: " + p_title + ": " + p_alert);
return;
}
Support more X11 dialogs for X11::alert() Modern distributions such as Fedora do not ship 'xdialog' with their default deployment. This commit adds support for Gnome's Zenity as well as KDE's kdialog.
2018-08-24 20:41:29 +00:00
const char *message_programs[] = { "zenity", "kdialog", "Xdialog", "xmessage" };
String path = get_environment("PATH");
Vector<String> path_elems = path.split(":", false);
String program;
for (int i = 0; i < path_elems.size(); i++) {
Changed some code found by Clang Tidy and Coverity
2019-09-22 16:45:08 +00:00
for (uint64_t k = 0; k < sizeof(message_programs) / sizeof(char *); k++) {
Replace ` + "/" + ` with `String::file_add()`
2019-06-16 12:31:57 +00:00
String tested_path = path_elems[i].plus_file(message_programs[k]);
Support more X11 dialogs for X11::alert() Modern distributions such as Fedora do not ship 'xdialog' with their default deployment. This commit adds support for Gnome's Zenity as well as KDE's kdialog.
2018-08-24 20:41:29 +00:00
if (FileAccess::exists(tested_path)) {
program = tested_path;
break;
}
}
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (program.length()) {
Support more X11 dialogs for X11::alert() Modern distributions such as Fedora do not ship 'xdialog' with their default deployment. This commit adds support for Gnome's Zenity as well as KDE's kdialog.
2018-08-24 20:41:29 +00:00
break;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
Support more X11 dialogs for X11::alert() Modern distributions such as Fedora do not ship 'xdialog' with their default deployment. This commit adds support for Gnome's Zenity as well as KDE's kdialog.
2018-08-24 20:41:29 +00:00
}
Properly implement OS.alert() from script, and use xmessage on X11
2015-09-21 12:39:46 +00:00
List<String> args;
Support more X11 dialogs for X11::alert() Modern distributions such as Fedora do not ship 'xdialog' with their default deployment. This commit adds support for Gnome's Zenity as well as KDE's kdialog.
2018-08-24 20:41:29 +00:00
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()) {
execute(program, args, true);
} else {
print_line(p_alert);
}
Properly implement OS.alert() from script, and use xmessage on X11
2015-09-21 12:39:46 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
When setting an X11 icon fails, try halving the size When setting an icon that is too large previously Godot would die with a X Error of failed request: BadLength error. To avoid this we install an error handler right before we set an icon. If the error handler triggers we halve the icon size until it works or until we've reached a 0 size on either width or height. We print a warning when this happens to alert developers. This fixes #19716
2018-08-26 21:07:15 +00:00
bool g_set_icon_error = false;
int set_icon_errorhandler(Display *dpy, XErrorEvent *ev) {
g_set_icon_error = true;
return 0;
}
Removal of Image from Variant, converted to a Resource.
2017-05-17 10:36:47 +00:00
void OS_X11::set_icon(const Ref<Image> &p_icon) {
When setting an X11 icon fails, try halving the size When setting an icon that is too large previously Godot would die with a X Error of failed request: BadLength error. To avoid this we install an error handler right before we set an icon. If the error handler triggers we halve the icon size until it works or until we've reached a 0 size on either width or height. We print a warning when this happens to alert developers. This fixes #19716
2018-08-26 21:07:15 +00:00
int (*oldHandler)(Display *, XErrorEvent *) = XSetErrorHandler(&set_icon_errorhandler);
Made the Atom net_wm_icon local
2015-10-25 17:36:27 +00:00
Atom net_wm_icon = XInternAtom(x11_display, "_NET_WM_ICON", False);
Fixing memory leaks
2015-10-25 14:15:56 +00:00
Removal of Image from Variant, converted to a Resource.
2017-05-17 10:36:47 +00:00
if (p_icon.is_valid()) {
Ref<Image> img = p_icon->duplicate();
img->convert(Image::FORMAT_RGBA8);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
When setting an X11 icon fails, try halving the size When setting an icon that is too large previously Godot would die with a X Error of failed request: BadLength error. To avoid this we install an error handler right before we set an icon. If the error handler triggers we halve the icon size until it works or until we've reached a 0 size on either width or height. We print a warning when this happens to alert developers. This fixes #19716
2018-08-26 21:07:15 +00:00
while (true) {
int w = img->get_width();
int h = img->get_height();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
When setting an X11 icon fails, try halving the size When setting an icon that is too large previously Godot would die with a X Error of failed request: BadLength error. To avoid this we install an error handler right before we set an icon. If the error handler triggers we halve the icon size until it works or until we've reached a 0 size on either width or height. We print a warning when this happens to alert developers. This fixes #19716
2018-08-26 21:07:15 +00:00
if (g_set_icon_error) {
g_set_icon_error = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
When setting an X11 icon fails, try halving the size When setting an icon that is too large previously Godot would die with a X Error of failed request: BadLength error. To avoid this we install an error handler right before we set an icon. If the error handler triggers we halve the icon size until it works or until we've reached a 0 size on either width or height. We print a warning when this happens to alert developers. This fixes #19716
2018-08-26 21:07:15 +00:00
WARN_PRINT("Icon too large, attempting to resize icon.");
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
When setting an X11 icon fails, try halving the size When setting an icon that is too large previously Godot would die with a X Error of failed request: BadLength error. To avoid this we install an error handler right before we set an icon. If the error handler triggers we halve the icon size until it works or until we've reached a 0 size on either width or height. We print a warning when this happens to alert developers. This fixes #19716
2018-08-26 21:07:15 +00:00
int new_width, new_height;
if (w > h) {
new_width = w / 2;
new_height = h * new_width / w;
} else {
new_height = h / 2;
new_width = w * new_height / h;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
When setting an X11 icon fails, try halving the size When setting an icon that is too large previously Godot would die with a X Error of failed request: BadLength error. To avoid this we install an error handler right before we set an icon. If the error handler triggers we halve the icon size until it works or until we've reached a 0 size on either width or height. We print a warning when this happens to alert developers. This fixes #19716
2018-08-26 21:07:15 +00:00
w = new_width;
h = new_height;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
When setting an X11 icon fails, try halving the size When setting an icon that is too large previously Godot would die with a X Error of failed request: BadLength error. To avoid this we install an error handler right before we set an icon. If the error handler triggers we halve the icon size until it works or until we've reached a 0 size on either width or height. We print a warning when this happens to alert developers. This fixes #19716
2018-08-26 21:07:15 +00:00
if (!w || !h) {
WARN_PRINT("Unable to set icon.");
break;
}
img->resize(w, h, Image::INTERPOLATE_CUBIC);
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
When setting an X11 icon fails, try halving the size When setting an icon that is too large previously Godot would die with a X Error of failed request: BadLength error. To avoid this we install an error handler right before we set an icon. If the error handler triggers we halve the icon size until it works or until we've reached a 0 size on either width or height. We print a warning when this happens to alert developers. This fixes #19716
2018-08-26 21:07:15 +00:00
// We're using long to have wordsize (32Bit build -> 32 Bits, 64 Bit build -> 64 Bits
Vector<long> pd;
pd.resize(2 + w * h);
pd.write[0] = w;
pd.write[1] = h;
PoolVector<uint8_t>::Read r = img->get_data().read();
long *wr = &pd.write[2];
uint8_t const *pr = r.ptr();
for (int i = 0; i < w * h; i++) {
long v = 0;
// A R G B
v |= pr[3] << 24 | pr[0] << 16 | pr[1] << 8 | pr[2];
*wr++ = v;
pr += 4;
}
Added atom checks to x11 XChangeProperty and XGetWindowProperty
2021-02-03 15:08:37 +00:00
if (net_wm_icon != None) {
XChangeProperty(x11_display, x11_window, net_wm_icon, XA_CARDINAL, 32, PropModeReplace, (unsigned char *)pd.ptr(), pd.size());
}
When setting an X11 icon fails, try halving the size When setting an icon that is too large previously Godot would die with a X Error of failed request: BadLength error. To avoid this we install an error handler right before we set an icon. If the error handler triggers we halve the icon size until it works or until we've reached a 0 size on either width or height. We print a warning when this happens to alert developers. This fixes #19716
2018-08-26 21:07:15 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (!g_set_icon_error) {
When setting an X11 icon fails, try halving the size When setting an icon that is too large previously Godot would die with a X Error of failed request: BadLength error. To avoid this we install an error handler right before we set an icon. If the error handler triggers we halve the icon size until it works or until we've reached a 0 size on either width or height. We print a warning when this happens to alert developers. This fixes #19716
2018-08-26 21:07:15 +00:00
break;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
XDeleteProperty(x11_display, x11_window, net_wm_icon);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
When setting an X11 icon fails, try halving the size When setting an icon that is too large previously Godot would die with a X Error of failed request: BadLength error. To avoid this we install an error handler right before we set an icon. If the error handler triggers we halve the icon size until it works or until we've reached a 0 size on either width or height. We print a warning when this happens to alert developers. This fixes #19716
2018-08-26 21:07:15 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
XFlush(x11_display);
When setting an X11 icon fails, try halving the size When setting an icon that is too large previously Godot would die with a X Error of failed request: BadLength error. To avoid this we install an error handler right before we set an icon. If the error handler triggers we halve the icon size until it works or until we've reached a 0 size on either width or height. We print a warning when this happens to alert developers. This fixes #19716
2018-08-26 21:07:15 +00:00
XSetErrorHandler(oldHandler);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
-Add lightmapper -Fixes to unwrapper (remove degenerates), makes Thekla not crash -Added optional cancel button in EditorProgress -Added function to force processing of events (needed for cancel button)
2017-12-14 11:59:46 +00:00
void OS_X11::force_process_input() {
process_xevents(); // get rid of pending events
#ifdef JOYDEV_ENABLED
joypad->process_joypads();
#endif
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
void OS_X11::run() {
force_quit = false;
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (!main_loop) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
main_loop->init();
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Style: Fix whole-line commented code They do not play well with clang-format which aligns the `//` part with the rest of the code block, thus producing badly indented commented code.
2017-01-14 11:26:56 +00:00
//uint64_t last_ticks=get_ticks_usec();
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Style: Fix whole-line commented code They do not play well with clang-format which aligns the `//` part with the rest of the code block, thus producing badly indented commented code.
2017-01-14 11:26:56 +00:00
//int frames=0;
//uint64_t frame=0;
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
while (!force_quit) {
process_xevents(); // get rid of pending events
Check pkg-config for libudev and enable gamepad code only if found. Linux only for now
2015-12-21 21:39:03 +00:00
#ifdef JOYDEV_ENABLED
Input: Remove usage of platform dependent event IDs. The ID property for InputEvents is set by `SceneTree` when sending the event down the tree. So there's no need for the platform specific code to set this value when it will later be overriden anyway...
2017-03-26 13:59:13 +00:00
joypad->process_joypads();
Better gamepad support
2015-12-18 05:12:53 +00:00
#endif
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (Main::iteration()) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
break;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
};
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
main_loop->finish();
}
Add some joystick functions to input. Enables manipulation of mappings at runtime
2016-01-07 23:40:41 +00:00
bool OS_X11::is_joy_known(int p_device) {
return input->is_joy_mapped(p_device);
}
String OS_X11::get_joy_guid(int p_device) const {
return input->get_joy_guid_remapped(p_device);
}
Add epic hack so vsync can be toggled in run-time from script. Fixes #14458. Call needs to be routed via visual server to reach the proper thread.
2017-12-16 20:09:25 +00:00
void OS_X11::_set_use_vsync(bool p_enable) {
bugfix: correct #ifdef for TOUCH_ENABLED and OPENGL_ENABLED
2018-06-22 14:42:28 +00:00
#if defined(OPENGL_ENABLED)
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
if (context_gl) {
bugfix: correct #ifdef for TOUCH_ENABLED and OPENGL_ENABLED
2018-06-22 14:42:28 +00:00
context_gl->set_use_vsync(p_enable);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2021-05-05 10:44:11 +00:00
}
bugfix: correct #ifdef for TOUCH_ENABLED and OPENGL_ENABLED
2018-06-22 14:42:28 +00:00
#endif
vsync support -works on windows -may not work on X11, if so please fix -OSX does not seem to support disabling vsync
2016-06-05 22:14:33 +00:00
}
Add epic hack so vsync can be toggled in run-time from script. Fixes #14458. Call needs to be routed via visual server to reach the proper thread.
2017-12-16 20:09:25 +00:00
/*
vsnc --> vsync
2016-11-08 14:06:57 +00:00
bool OS_X11::is_vsync_enabled() const {
vsync support -works on windows -may not work on X11, if so please fix -OSX does not seem to support disabling vsync
2016-06-05 22:14:33 +00:00
if (context_gl)
return context_gl->is_using_vsync();
return true;
}
Add epic hack so vsync can be toggled in run-time from script. Fixes #14458. Call needs to be routed via visual server to reach the proper thread.
2017-12-16 20:09:25 +00:00
*/
x11: use different strings for WM_CLASS depending on context
2016-01-27 20:53:37 +00:00
void OS_X11::set_context(int p_context) {
Removed unnecessary assignments
2017-08-21 19:15:36 +00:00
XClassHint *classHint = XAllocClassHint();
Fix many asan and ubsan reported issues This allows most demos to run without any ubsan or asan errors. There are still some things in thirdpart/ and some things in AudioServer that needs a look but this fixes a lot of issues. This should help debug less obvious issues, hopefully. This fixes #25217 and fixes #25218
2019-01-30 01:12:41 +00:00
x11: use different strings for WM_CLASS depending on context
2016-01-27 20:53:37 +00:00
if (classHint) {
fixed an access after free in OS_X11::set_context. Added constructor and assignment operator for CharString from const char* to simplify memory management when working with utf8/ascii strings for APIs taking char*. Reworked OS_X11::set_context to use CharString and avoid some manual memory management.
2019-03-12 12:57:22 +00:00
CharString name_str;
switch (p_context) {
case CONTEXT_EDITOR:
name_str = "Godot_Editor";
break;
case CONTEXT_PROJECTMAN:
name_str = "Godot_ProjectList";
break;
case CONTEXT_ENGINE:
name_str = "Godot_Engine";
break;
}
[x11] Use "application/config/name" for WM_CLASS
2018-10-05 20:18:10 +00:00
fixed an access after free in OS_X11::set_context. Added constructor and assignment operator for CharString from const char* to simplify memory management when working with utf8/ascii strings for APIs taking char*. Reworked OS_X11::set_context to use CharString and avoid some manual memory management.
2019-03-12 12:57:22 +00:00
CharString class_str;
[x11] Use "application/config/name" for WM_CLASS
2018-10-05 20:18:10 +00:00
if (p_context == CONTEXT_ENGINE) {
fixed an access after free in OS_X11::set_context. Added constructor and assignment operator for CharString from const char* to simplify memory management when working with utf8/ascii strings for APIs taking char*. Reworked OS_X11::set_context to use CharString and avoid some manual memory management.
2019-03-12 12:57:22 +00:00
String config_name = GLOBAL_GET("application/config/name");
if (config_name.length() == 0) {
class_str = "Godot_Engine";
fix for access after free in OS_X11::set_context.
2019-03-12 13:41:02 +00:00
} else {
fixed an access after free in OS_X11::set_context. Added constructor and assignment operator for CharString from const char* to simplify memory management when working with utf8/ascii strings for APIs taking char*. Reworked OS_X11::set_context to use CharString and avoid some manual memory management.
2019-03-12 12:57:22 +00:00
class_str = config_name.utf8();
fix for access after free in OS_X11::set_context.
2019-03-12 13:41:02 +00:00
}
fixed an access after free in OS_X11::set_context. Added constructor and assignment operator for CharString from const char* to simplify memory management when working with utf8/ascii strings for APIs taking char*. Reworked OS_X11::set_context to use CharString and avoid some manual memory management.
2019-03-12 12:57:22 +00:00
} else {
class_str = "Godot";
[x11] Use "application/config/name" for WM_CLASS
2018-10-05 20:18:10 +00:00
}
fixed an access after free in OS_X11::set_context. Added constructor and assignment operator for CharString from const char* to simplify memory management when working with utf8/ascii strings for APIs taking char*. Reworked OS_X11::set_context to use CharString and avoid some manual memory management.
2019-03-12 12:57:22 +00:00
classHint->res_class = class_str.ptrw();
classHint->res_name = name_str.ptrw();
[x11] Use "application/config/name" for WM_CLASS
2018-10-05 20:18:10 +00:00
x11: use different strings for WM_CLASS depending on context
2016-01-27 20:53:37 +00:00
XSetClassHint(x11_display, x11_window, classHint);
XFree(classHint);
}
}
Fix enums bindings Add missed bindings for enums Move some enums to class to have correct output of api.json
2017-09-12 19:09:06 +00:00
OS::PowerState OS_X11::get_power_state() {
Add API to access battery power state Done: - X11, server (tested) - Windows (developed, would be nice to retest) - OSX (not tested) Prepared (not developed): - Android (code is here, but may not compile) - iphone - winrt - bb10 - haiku - javascript
2016-07-23 11:15:55 +00:00
return power_manager->get_power_state();
}
int OS_X11::get_power_seconds_left() {
return power_manager->get_power_seconds_left();
}
int OS_X11::get_power_percent_left() {
return power_manager->get_power_percent_left();
}
Added a crash handler to dump the backtrace on Windows, Linux and OS X
2017-09-08 01:01:49 +00:00
void OS_X11::disable_crash_handler() {
crash_handler.disable();
}
bool OS_X11::is_disable_crash_handler() const {
return crash_handler.is_disabled();
}
FileSystemDock will now remove files/dirs to trashcan using OS::move_to_trash
2017-09-25 13:15:11 +00:00
static String get_mountpoint(const String &p_path) {
struct stat s;
if (stat(p_path.utf8().get_data(), &s)) {
return "";
}
Fix BSD compile issues
2017-10-17 16:50:41 +00:00
#ifdef HAVE_MNTENT
FileSystemDock will now remove files/dirs to trashcan using OS::move_to_trash
2017-09-25 13:15:11 +00:00
dev_t dev = s.st_dev;
FILE *fd = setmntent("/proc/mounts", "r");
if (!fd) {
return "";
}
struct mntent mnt;
char buf[1024];
size_t buflen = 1024;
while (getmntent_r(fd, &mnt, buf, buflen)) {
if (!stat(mnt.mnt_dir, &s) && s.st_dev == dev) {
endmntent(fd);
return String(mnt.mnt_dir);
}
}
endmntent(fd);
Fix BSD compile issues
2017-10-17 16:50:41 +00:00
#endif
FileSystemDock will now remove files/dirs to trashcan using OS::move_to_trash
2017-09-25 13:15:11 +00:00
return "";
}
Error OS_X11::move_to_trash(const String &p_path) {
Fixes move_to_trash() on Linux Fixes #42840 OS move_to_trash() on Linux is not compliant with the Freedesktop specification (cherry picked from commit 8b68c6808d19f2f39a45f73d724e611049fffac4)
2020-11-30 20:19:52 +00:00
int err_code;
List<String> args;
args.push_back(p_path);
args.push_front("trash"); // The command is `gio trash <file_name>` so we need to add it to args.
Error result = execute("gio", args, true, nullptr, nullptr, &err_code); // For GNOME based machines.
if (result == OK && !err_code) {
return OK;
} else if (err_code == 2) {
return ERR_FILE_NOT_FOUND;
}
args.pop_front();
args.push_front("move");
args.push_back("trash:/"); // The command is `kioclient5 move <file_name> trash:/`.
result = execute("kioclient5", args, true, nullptr, nullptr, &err_code); // For KDE based machines.
if (result == OK && !err_code) {
return OK;
} else if (err_code == 2) {
return ERR_FILE_NOT_FOUND;
}
args.pop_front();
args.pop_back();
result = execute("gvfs-trash", args, true, nullptr, nullptr, &err_code); // For older Linux machines.
if (result == OK && !err_code) {
return OK;
} else if (err_code == 2) {
return ERR_FILE_NOT_FOUND;
}
// If the commands `kioclient5`, `gio` or `gvfs-trash` don't exist on the system we do it manually.
String trash_path = "";
FileSystemDock will now remove files/dirs to trashcan using OS::move_to_trash
2017-09-25 13:15:11 +00:00
String mnt = get_mountpoint(p_path);
Fixes move_to_trash() on Linux Fixes #42840 OS move_to_trash() on Linux is not compliant with the Freedesktop specification (cherry picked from commit 8b68c6808d19f2f39a45f73d724e611049fffac4)
2020-11-30 20:19:52 +00:00
// If there is a directory "[Mountpoint]/.Trash-[UID], use it as the trash can.
FileSystemDock will now remove files/dirs to trashcan using OS::move_to_trash
2017-09-25 13:15:11 +00:00
if (mnt != "") {
Fixes move_to_trash() on Linux Fixes #42840 OS move_to_trash() on Linux is not compliant with the Freedesktop specification (cherry picked from commit 8b68c6808d19f2f39a45f73d724e611049fffac4)
2020-11-30 20:19:52 +00:00
String path(mnt + "/.Trash-" + itos(getuid()));
FileSystemDock will now remove files/dirs to trashcan using OS::move_to_trash
2017-09-25 13:15:11 +00:00
struct stat s;
if (!stat(path.utf8().get_data(), &s)) {
Fixes move_to_trash() on Linux Fixes #42840 OS move_to_trash() on Linux is not compliant with the Freedesktop specification (cherry picked from commit 8b68c6808d19f2f39a45f73d724e611049fffac4)
2020-11-30 20:19:52 +00:00
trash_path = path;
FileSystemDock will now remove files/dirs to trashcan using OS::move_to_trash
2017-09-25 13:15:11 +00:00
}
}
Fixes move_to_trash() on Linux Fixes #42840 OS move_to_trash() on Linux is not compliant with the Freedesktop specification (cherry picked from commit 8b68c6808d19f2f39a45f73d724e611049fffac4)
2020-11-30 20:19:52 +00:00
// Otherwise, if ${XDG_DATA_HOME} is defined, use "${XDG_DATA_HOME}/Trash" as the trash can.
if (trash_path == "") {
FileSystemDock will now remove files/dirs to trashcan using OS::move_to_trash
2017-09-25 13:15:11 +00:00
char *dhome = getenv("XDG_DATA_HOME");
if (dhome) {
Fixes move_to_trash() on Linux Fixes #42840 OS move_to_trash() on Linux is not compliant with the Freedesktop specification (cherry picked from commit 8b68c6808d19f2f39a45f73d724e611049fffac4)
2020-11-30 20:19:52 +00:00
trash_path = String(dhome) + "/Trash";
FileSystemDock will now remove files/dirs to trashcan using OS::move_to_trash
2017-09-25 13:15:11 +00:00
}
}
Fixes move_to_trash() on Linux Fixes #42840 OS move_to_trash() on Linux is not compliant with the Freedesktop specification (cherry picked from commit 8b68c6808d19f2f39a45f73d724e611049fffac4)
2020-11-30 20:19:52 +00:00
// Otherwise, if ${HOME} is defined, use "${HOME}/.local/share/Trash" as the trash can.
if (trash_path == "") {
FileSystemDock will now remove files/dirs to trashcan using OS::move_to_trash
2017-09-25 13:15:11 +00:00
char *home = getenv("HOME");
if (home) {
Fixes move_to_trash() on Linux Fixes #42840 OS move_to_trash() on Linux is not compliant with the Freedesktop specification (cherry picked from commit 8b68c6808d19f2f39a45f73d724e611049fffac4)
2020-11-30 20:19:52 +00:00
trash_path = String(home) + "/.local/share/Trash";
FileSystemDock will now remove files/dirs to trashcan using OS::move_to_trash
2017-09-25 13:15:11 +00:00
}
}
[X11] Improving error detection in move_to_trash
2018-02-13 23:04:11 +00:00
// Issue an error if none of the previous locations is appropriate for the trash can.
Fixes move_to_trash() on Linux Fixes #42840 OS move_to_trash() on Linux is not compliant with the Freedesktop specification (cherry picked from commit 8b68c6808d19f2f39a45f73d724e611049fffac4)
2020-11-30 20:19:52 +00:00
ERR_FAIL_COND_V_MSG(trash_path == "", FAILED, "Could not determine the trash can location");
FileSystemDock will now remove files/dirs to trashcan using OS::move_to_trash
2017-09-25 13:15:11 +00:00
[X11] Improving error detection in move_to_trash
2018-02-13 23:04:11 +00:00
// Create needed directories for decided trash can location.
Fixes move_to_trash() on Linux Fixes #42840 OS move_to_trash() on Linux is not compliant with the Freedesktop specification (cherry picked from commit 8b68c6808d19f2f39a45f73d724e611049fffac4)
2020-11-30 20:19:52 +00:00
{
DirAccess *dir_access = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
Error err = dir_access->make_dir_recursive(trash_path);
// Issue an error if trash can is not created proprely.
ERR_FAIL_COND_V_MSG(err != OK, err, "Could not create the trash path \"" + trash_path + "\"");
err = dir_access->make_dir_recursive(trash_path + "/files");
ERR_FAIL_COND_V_MSG(err != OK, err, "Could not create the trash path \"" + trash_path + "\"/files");
err = dir_access->make_dir_recursive(trash_path + "/info");
ERR_FAIL_COND_V_MSG(err != OK, err, "Could not create the trash path \"" + trash_path + "\"/info");
memdelete(dir_access);
}
// The trash can is successfully created, now we check that we don't exceed our file name length limit.
// If the file name is too long trim it so we can add the identifying number and ".trashinfo".
// Assumes that the file name length limit is 255 characters.
use .get_file() instead of basename(3) On OpenBSD the compiler complains that calling basename(3) would lose const qualifier. basename(3) is defined as char *basename(char *); and can, accorgindly to the POSIX.1, modify the passed string. This uses the .get_file() method. The check is necessary because file_name could be a directory, in which case .get_file() would return an empty string. The .get_base_dir().get_file() idiom is already used. The usage of get_file() and the check were suggested by theraot, thanks! (cherry picked from commit a3384b7461005260d0dd5c8f05df28ee842442de)
2021-08-09 09:39:20 +00:00
String file_name = p_path.get_file();
if (file_name.length() == 0) {
file_name = p_path.get_base_dir().get_file();
}
Fixes move_to_trash() on Linux Fixes #42840 OS move_to_trash() on Linux is not compliant with the Freedesktop specification (cherry picked from commit 8b68c6808d19f2f39a45f73d724e611049fffac4)
2020-11-30 20:19:52 +00:00
if (file_name.length() > 240) {
file_name = file_name.substr(0, file_name.length() - 15);
}
String dest_path = trash_path + "/files/" + file_name;
struct stat buff;
int id_number = 0;
String fn = file_name;
// Checks if a resource with the same name already exist in the trash can,
// if there is, add an identifying number to our resource's name.
while (stat(dest_path.utf8().get_data(), &buff) == 0) {
id_number++;
// Added a limit to check for identically named files already on the trash can
// if there are too many it could make the editor unresponsive.
ERR_FAIL_COND_V_MSG(id_number > 99, FAILED, "Too many identically named resources already in the trash can.");
fn = file_name + "." + itos(id_number);
dest_path = trash_path + "/files/" + fn;
}
file_name = fn;
// Generates the .trashinfo file
OS::Date date = OS::get_singleton()->get_date(false);
OS::Time time = OS::get_singleton()->get_time(false);
String timestamp = vformat("%04d-%02d-%02dT%02d:%02d:", date.year, (int)date.month, date.day, time.hour, time.min);
timestamp = vformat("%s%02d", timestamp, time.sec); // vformat only supports up to 6 arguments.
String trash_info = "[Trash Info]\nPath=" + p_path.http_escape() + "\nDeletionDate=" + timestamp + "\n";
{
Error err;
FileAccess *file = FileAccess::open(trash_path + "/info/" + file_name + ".trashinfo", FileAccess::WRITE, &err);
ERR_FAIL_COND_V_MSG(err != OK, err, "Can't create trashinfo file:" + trash_path + "/info/" + file_name + ".trashinfo");
file->store_string(trash_info);
file->close();
[X11] Improving error detection in move_to_trash
2018-02-13 23:04:11 +00:00
Fixes move_to_trash() on Linux Fixes #42840 OS move_to_trash() on Linux is not compliant with the Freedesktop specification (cherry picked from commit 8b68c6808d19f2f39a45f73d724e611049fffac4)
2020-11-30 20:19:52 +00:00
// Rename our resource before moving it to the trash can.
DirAccess *dir_access = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
err = dir_access->rename(p_path, p_path.get_base_dir() + "/" + file_name);
ERR_FAIL_COND_V_MSG(err != OK, err, "Can't rename file \"" + p_path + "\"");
memdelete(dir_access);
FileSystemDock will now remove files/dirs to trashcan using OS::move_to_trash
2017-09-25 13:15:11 +00:00
}
Fixes move_to_trash() on Linux Fixes #42840 OS move_to_trash() on Linux is not compliant with the Freedesktop specification (cherry picked from commit 8b68c6808d19f2f39a45f73d724e611049fffac4)
2020-11-30 20:19:52 +00:00
// Move the given resource to the trash can.
[X11] Improving error detection in move_to_trash
2018-02-13 23:04:11 +00:00
// Do not use DirAccess:rename() because it can't move files across multiple mountpoints.
List<String> mv_args;
Fixes move_to_trash() on Linux Fixes #42840 OS move_to_trash() on Linux is not compliant with the Freedesktop specification (cherry picked from commit 8b68c6808d19f2f39a45f73d724e611049fffac4)
2020-11-30 20:19:52 +00:00
mv_args.push_back(p_path.get_base_dir() + "/" + file_name);
mv_args.push_back(trash_path + "/files");
{
int retval;
Error err = execute("mv", mv_args, true, nullptr, nullptr, &retval);
[X11] Improving error detection in move_to_trash
2018-02-13 23:04:11 +00:00
Fixes move_to_trash() on Linux Fixes #42840 OS move_to_trash() on Linux is not compliant with the Freedesktop specification (cherry picked from commit 8b68c6808d19f2f39a45f73d724e611049fffac4)
2020-11-30 20:19:52 +00:00
// Issue an error if "mv" failed to move the given resource to the trash can.
if (err != OK || retval != 0) {
ERR_PRINT("move_to_trash: Could not move the resource \"" + p_path + "\" to the trash can \"" + trash_path + "/files\"");
DirAccess *dir_access = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
err = dir_access->rename(p_path.get_base_dir() + "/" + file_name, p_path);
memdelete(dir_access);
ERR_FAIL_COND_V_MSG(err != OK, err, "Could not rename " + p_path.get_base_dir() + "/" + file_name + " back to its original name:" + p_path);
return FAILED;
}
[X11] Improving error detection in move_to_trash
2018-02-13 23:04:11 +00:00
}
return OK;
FileSystemDock will now remove files/dirs to trashcan using OS::move_to_trash
2017-09-25 13:15:11 +00:00
}
Implemented OS get_latin_keyboard_variant on x11
2017-10-30 14:40:42 +00:00
OS::LatinKeyboardVariant OS_X11::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);
Add Colemak keybindings to editor for osx
2017-10-24 17:32:40 +00:00
if (info[1].find("colemak") != -1) {
Implemented OS get_latin_keyboard_variant on x11
2017-10-30 14:40:42 +00:00
return LATIN_KEYBOARD_COLEMAK;
Add Colemak keybindings to editor for osx
2017-10-24 17:32:40 +00:00
} else if (info[1].find("qwertz") != -1) {
Implemented OS get_latin_keyboard_variant on x11
2017-10-30 14:40:42 +00:00
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;
}
[3.2] Add keyboard layout enumeration / set / get functions (macOS, Windows, Linux/X11).
2020-06-12 12:51:51 +00:00
int OS_X11::keyboard_get_layout_count() const {
int _group_count = 0;
XkbDescRec *kbd = XkbAllocKeyboard();
if (kbd) {
kbd->dpy = x11_display;
XkbGetControls(x11_display, XkbAllControlsMask, kbd);
XkbGetNames(x11_display, XkbSymbolsNameMask, kbd);
const Atom *groups = kbd->names->groups;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
if (kbd->ctrls != nullptr) {
[3.2] Add keyboard layout enumeration / set / get functions (macOS, Windows, Linux/X11).
2020-06-12 12:51:51 +00:00
_group_count = kbd->ctrls->num_groups;
} else {
while (_group_count < XkbNumKbdGroups && groups[_group_count] != None) {
_group_count++;
}
}
XkbFreeKeyboard(kbd, 0, true);
}
return _group_count;
}
int OS_X11::keyboard_get_current_layout() const {
XkbStateRec state;
XkbGetState(x11_display, XkbUseCoreKbd, &state);
return state.group;
}
void OS_X11::keyboard_set_current_layout(int p_index) {
ERR_FAIL_INDEX(p_index, keyboard_get_layout_count());
XkbLockGroup(x11_display, XkbUseCoreKbd, p_index);
}
String OS_X11::keyboard_get_layout_language(int p_index) const {
String ret;
XkbDescRec *kbd = XkbAllocKeyboard();
if (kbd) {
kbd->dpy = x11_display;
XkbGetControls(x11_display, XkbAllControlsMask, kbd);
XkbGetNames(x11_display, XkbSymbolsNameMask, kbd);
XkbGetNames(x11_display, XkbGroupNamesMask, kbd);
int _group_count = 0;
const Atom *groups = kbd->names->groups;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
if (kbd->ctrls != nullptr) {
[3.2] Add keyboard layout enumeration / set / get functions (macOS, Windows, Linux/X11).
2020-06-12 12:51:51 +00:00
_group_count = kbd->ctrls->num_groups;
} else {
while (_group_count < XkbNumKbdGroups && groups[_group_count] != None) {
_group_count++;
}
}
Atom names = kbd->names->symbols;
if (names != None) {
char *name = XGetAtomName(x11_display, names);
Vector<String> info = String(name).split("+");
if (p_index >= 0 && p_index < _group_count) {
if (p_index + 1 < info.size()) {
ret = info[p_index + 1]; // Skip "pc" at the start and "inet"/"group" at the end of symbols.
} else {
ret = "en"; // No symbol for layout fallback to "en".
}
} else {
ERR_PRINT("Index " + itos(p_index) + "is out of bounds (" + itos(_group_count) + ").");
}
XFree(name);
}
XkbFreeKeyboard(kbd, 0, true);
}
return ret.substr(0, 2);
}
String OS_X11::keyboard_get_layout_name(int p_index) const {
String ret;
XkbDescRec *kbd = XkbAllocKeyboard();
if (kbd) {
kbd->dpy = x11_display;
XkbGetControls(x11_display, XkbAllControlsMask, kbd);
XkbGetNames(x11_display, XkbSymbolsNameMask, kbd);
XkbGetNames(x11_display, XkbGroupNamesMask, kbd);
int _group_count = 0;
const Atom *groups = kbd->names->groups;
Style: Replaces uses of 0/NULL by nullptr (C++11) Using clang-tidy's `modernize-use-nullptr`. https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
2021-05-04 14:00:45 +00:00
if (kbd->ctrls != nullptr) {
[3.2] Add keyboard layout enumeration / set / get functions (macOS, Windows, Linux/X11).
2020-06-12 12:51:51 +00:00
_group_count = kbd->ctrls->num_groups;
} else {
while (_group_count < XkbNumKbdGroups && groups[_group_count] != None) {
_group_count++;
}
}
if (p_index >= 0 && p_index < _group_count) {
char *full_name = XGetAtomName(x11_display, groups[p_index]);
ret.parse_utf8(full_name);
XFree(full_name);
} else {
ERR_PRINT("Index " + itos(p_index) + "is out of bounds (" + itos(_group_count) + ").");
}
XkbFreeKeyboard(kbd, 0, true);
}
return ret;
}
Update X11 global mouse position at startup When we start the engine we haven't yet gotten any X11 motion events so we don't yet know where our mouse cursor is located. Instead we now query the X server for this information when we start and update the appropriate values. In addition when we move the window we also update the mouse position based off of X server knowledge as we will also not have received any mouse motion events. this fixes #8145 (for X11 only)
2018-09-09 20:13:50 +00:00
void OS_X11::update_real_mouse_position() {
Window root_return, child_return;
int root_x, root_y, win_x, win_y;
unsigned int mask_return;
Bool xquerypointer_result = XQueryPointer(x11_display, 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 <= current_videomode.width && win_y <= current_videomode.height) {
last_mouse_pos.x = win_x;
last_mouse_pos.y = win_y;
last_mouse_pos_valid = true;
input->set_mouse_position(last_mouse_pos);
}
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
OS_X11::OS_X11() {
Implemented PulseAudio backend and fixed audio driver selection on X11
2014-12-19 12:44:34 +00:00
#ifdef PULSEAUDIO_ENABLED
Oops! Audio engine has vanished :D
2017-01-15 19:06:14 +00:00
AudioDriverManager::add_driver(&driver_pulseaudio);
Implemented PulseAudio backend and fixed audio driver selection on X11
2014-12-19 12:44:34 +00:00
#endif
-ability to set default textures in shader (needed for visual shader editing) -work in progress new graph system (will replace current one) -crash fix in s3m loader (out of bounds acess) -fixed vbox overriding of separation (fixes empty line between section tabs)
2014-12-21 14:42:44 +00:00
#ifdef ALSA_ENABLED
Oops! Audio engine has vanished :D
2017-01-15 19:06:14 +00:00
AudioDriverManager::add_driver(&driver_alsa);
-ability to set default textures in shader (needed for visual shader editing) -work in progress new graph system (will replace current one) -crash fix in s3m loader (out of bounds acess) -fixed vbox overriding of separation (fixes empty line between section tabs)
2014-12-21 14:42:44 +00:00
#endif
Fix jump over uninitialized value in OS Unix/X11
2019-04-08 14:06:57 +00:00
xi.opcode = 0;
xi.last_relative_time = 0;
Experimental support for windows with per-pixel transparency (macOS, X11 and Windows).
2017-12-10 18:38:26 +00:00
layered_window = false;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
minimized = false;
Add an `OS.is_window_focused()` getter This makes it possible to know whether the window is focused at a given time, without having to track the focus state manually using `NOTIFICATION_WM_FOCUS_IN` and `NOTIFICATION_WM_FOCUS_OUT`. This partially addresses #33928.
2019-11-28 12:41:07 +00:00
window_focused = true;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
xim_style = 0L;
mouse_mode = MOUSE_MODE_VISIBLE;
Restores correct window position after fullscreen toggling off on Linux (cherry picked from commit 90f00c0813b8335605c81b5d5063922efe5519e3)
2020-02-03 15:14:41 +00:00
last_position_before_fs = Vector2();
Code cleanup in platform/x11
2016-07-21 19:11:34 +00:00
}