Stowage/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-10-31 13:41:03 +00:00
Code Issues Projects Releases Packages Wiki Activity
godot/platform/linuxbsd/x11/display_server_x11.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

540 lines
21 KiB
C++
Raw Normal View History

Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
/**************************************************************************/
/* display_server_x11.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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. */
/**************************************************************************/
#ifndef DISPLAY_SERVER_X11_H
#define DISPLAY_SERVER_X11_H
#ifdef X11_ENABLED
Style: Harmonize header includes in platform ports This applies our existing style guide, and adds a new rule to that style guide for modular components such as platform ports and modules: Includes from the platform port or module should be included with relative paths (relative to the root folder of the modular component, e.g. `platform/linuxbsd/`), in their own section before Godot's "core" includes. The `api` and `export` subfolders also need to be handled as self-contained (and thus use relative paths for their "local" includes) as they are all compiled for each editor platform, without necessarily having the api/export matching platform folder in the include path. E.g. the Linux editor build will compile `platform/android/{api,export}/*.cpp` and those need to use relative includes for it to work.
2023-06-08 14:51:32 +02:00
#include "joypad_linux.h"
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Rename InputFilter back to Input It changed name as part of the DisplayServer and input refactoring in #37317, with the rationale that input no longer goes through the main loop, so the previous Input singleton now only does filtering. But the gains in consistency are quite limited in the renaming, and it breaks compatibility for all scripts and tutorials that access the Input singleton via the scripting language. A temporary option was suggested to keep the scripting singleton named `Input` even if its type is `InputFilter`, but that adds inconsistency and breaks C#. Fixes godotengine/godot-proposals#639. Fixes #37319. Fixes #37690.
2020-04-28 15:19:37 +02:00
#include "core/input/input.h"
[Linux] Make SO wrapper usage optional.
2023-02-15 14:13:56 +02:00
#include "core/os/mutex.h"
#include "core/os/thread.h"
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 19:33:38 -03:00
#include "core/templates/local_vector.h"
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
#include "drivers/alsa/audio_driver_alsa.h"
#include "drivers/alsamidi/midi_driver_alsamidi.h"
#include "drivers/pulseaudio/audio_driver_pulseaudio.h"
#include "drivers/unix/os_unix.h"
#include "servers/audio_server.h"
Style: Harmonize header includes in platform ports This applies our existing style guide, and adds a new rule to that style guide for modular components such as platform ports and modules: Includes from the platform port or module should be included with relative paths (relative to the root folder of the modular component, e.g. `platform/linuxbsd/`), in their own section before Godot's "core" includes. The `api` and `export` subfolders also need to be handled as self-contained (and thus use relative paths for their "local" includes) as they are all compiled for each editor platform, without necessarily having the api/export matching platform folder in the include path. E.g. the Linux editor build will compile `platform/android/{api,export}/*.cpp` and those need to use relative includes for it to work.
2023-06-08 14:51:32 +02:00
#include "servers/display_server.h"
RenderingServer reorganization
2020-12-04 15:26:24 -03:00
#include "servers/rendering/renderer_compositor.h"
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
#include "servers/rendering_server.h"
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Implement text-to-speech support on Android, iOS, HTML5, Linux, macOS and Windows. Implement TextServer word break method.
2021-11-04 14:33:37 +02:00
#if defined(SPEECHD_ENABLED)
Style: Harmonize header includes in platform ports This applies our existing style guide, and adds a new rule to that style guide for modular components such as platform ports and modules: Includes from the platform port or module should be included with relative paths (relative to the root folder of the modular component, e.g. `platform/linuxbsd/`), in their own section before Godot's "core" includes. The `api` and `export` subfolders also need to be handled as self-contained (and thus use relative paths for their "local" includes) as they are all compiled for each editor platform, without necessarily having the api/export matching platform folder in the include path. E.g. the Linux editor build will compile `platform/android/{api,export}/*.cpp` and those need to use relative includes for it to work.
2023-06-08 14:51:32 +02:00
#include "tts_linux.h"
Implement text-to-speech support on Android, iOS, HTML5, Linux, macOS and Windows. Implement TextServer word break method.
2021-11-04 14:33:37 +02:00
#endif
Use OpenGL 3.3 core profile instead of compatibility profile - Rename OpenGL to GLES3 in the source code per community feedback. - The renderer is still exposed as "OpenGL 3" to the user. - Hide renderer selection dropdown until OpenGL support is more mature. - The renderer can still be changed in the Project Settings or using the `--rendering-driver opengl` command line argument. - Remove commented out exporter code. - Remove some OpenGL/DisplayServer-related debugging prints.
2021-10-26 08:18:39 -07:00
#if defined(GLES3_ENABLED)
Style: Harmonize header includes in platform ports This applies our existing style guide, and adds a new rule to that style guide for modular components such as platform ports and modules: Includes from the platform port or module should be included with relative paths (relative to the root folder of the modular component, e.g. `platform/linuxbsd/`), in their own section before Godot's "core" includes. The `api` and `export` subfolders also need to be handled as self-contained (and thus use relative paths for their "local" includes) as they are all compiled for each editor platform, without necessarily having the api/export matching platform folder in the include path. E.g. the Linux editor build will compile `platform/android/{api,export}/*.cpp` and those need to use relative includes for it to work.
2023-06-08 14:51:32 +02:00
#include "x11/gl_manager_x11.h"
[X11] Add support for using EGL/GLES instead of GLX.
2023-09-22 10:55:55 +03:00
#include "x11/gl_manager_x11_egl.h"
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
#endif
#if defined(VULKAN_ENABLED)
Style: Harmonize header includes in platform ports This applies our existing style guide, and adds a new rule to that style guide for modular components such as platform ports and modules: Includes from the platform port or module should be included with relative paths (relative to the root folder of the modular component, e.g. `platform/linuxbsd/`), in their own section before Godot's "core" includes. The `api` and `export` subfolders also need to be handled as self-contained (and thus use relative paths for their "local" includes) as they are all compiled for each editor platform, without necessarily having the api/export matching platform folder in the include path. E.g. the Linux editor build will compile `platform/android/{api,export}/*.cpp` and those need to use relative includes for it to work.
2023-06-08 14:51:32 +02:00
#include "x11/vulkan_context_x11.h"
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
#include "drivers/vulkan/rendering_device_vulkan.h"
#endif
Add "Keep screen on" feature to `DisplayServerX11`
2020-04-02 23:46:34 +02:00
#if defined(DBUS_ENABLED)
Style: Harmonize header includes in platform ports This applies our existing style guide, and adds a new rule to that style guide for modular components such as platform ports and modules: Includes from the platform port or module should be included with relative paths (relative to the root folder of the modular component, e.g. `platform/linuxbsd/`), in their own section before Godot's "core" includes. The `api` and `export` subfolders also need to be handled as self-contained (and thus use relative paths for their "local" includes) as they are all compiled for each editor platform, without necessarily having the api/export matching platform folder in the include path. E.g. the Linux editor build will compile `platform/android/{api,export}/*.cpp` and those need to use relative includes for it to work.
2023-06-08 14:51:32 +02:00
#include "freedesktop_portal_desktop.h"
#include "freedesktop_screensaver.h"
Add "Keep screen on" feature to `DisplayServerX11`
2020-04-02 23:46:34 +02:00
#endif
Load X11 dynamically The loaders have been generated through hpvb's dynload-wrapper, although they had to be heavily handpatched to workaround some already reported issues with it. I added a note to each generated file to account for that. As GLAD uses X11 stuff directly, I had to define the GLAD_GLX_NO_X11 macro to not let do it that, and handle myself the display loading and screen handling part myself, which wasn't that hard but it's still something worth saying. I plan to improve greatly the X11 backend (including this aspect) but, as the release isn't that far and I'm also working on the Wayland backend, this will do for now, I hope.
2022-11-29 12:03:06 +01:00
#include <X11/Xatom.h>
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
#include <X11/Xlib.h>
Load X11 dynamically The loaders have been generated through hpvb's dynload-wrapper, although they had to be heavily handpatched to workaround some already reported issues with it. I added a note to each generated file to account for that. As GLAD uses X11 stuff directly, I had to define the GLAD_GLX_NO_X11 macro to not let do it that, and handle myself the display loading and screen handling part myself, which wasn't that hard but it's still something worth saying. I plan to improve greatly the X11 backend (including this aspect) but, as the release isn't that far and I'm also working on the Wayland backend, this will do for now, I hope.
2022-11-29 12:03:06 +01:00
#include <X11/Xutil.h>
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
#include <X11/keysym.h>
[Linux] Make SO wrapper usage optional.
2023-02-15 14:13:56 +02:00
#ifdef SOWRAP_ENABLED
Style: Harmonize header includes in platform ports This applies our existing style guide, and adds a new rule to that style guide for modular components such as platform ports and modules: Includes from the platform port or module should be included with relative paths (relative to the root folder of the modular component, e.g. `platform/linuxbsd/`), in their own section before Godot's "core" includes. The `api` and `export` subfolders also need to be handled as self-contained (and thus use relative paths for their "local" includes) as they are all compiled for each editor platform, without necessarily having the api/export matching platform folder in the include path. E.g. the Linux editor build will compile `platform/android/{api,export}/*.cpp` and those need to use relative includes for it to work.
2023-06-08 14:51:32 +02:00
#include "x11/dynwrappers/xlib-so_wrap.h"
Load X11 dynamically The loaders have been generated through hpvb's dynload-wrapper, although they had to be heavily handpatched to workaround some already reported issues with it. I added a note to each generated file to account for that. As GLAD uses X11 stuff directly, I had to define the GLAD_GLX_NO_X11 macro to not let do it that, and handle myself the display loading and screen handling part myself, which wasn't that hard but it's still something worth saying. I plan to improve greatly the X11 backend (including this aspect) but, as the release isn't that far and I'm also working on the Wayland backend, this will do for now, I hope.
2022-11-29 12:03:06 +01:00
Style: Harmonize header includes in platform ports This applies our existing style guide, and adds a new rule to that style guide for modular components such as platform ports and modules: Includes from the platform port or module should be included with relative paths (relative to the root folder of the modular component, e.g. `platform/linuxbsd/`), in their own section before Godot's "core" includes. The `api` and `export` subfolders also need to be handled as self-contained (and thus use relative paths for their "local" includes) as they are all compiled for each editor platform, without necessarily having the api/export matching platform folder in the include path. E.g. the Linux editor build will compile `platform/android/{api,export}/*.cpp` and those need to use relative includes for it to work.
2023-06-08 14:51:32 +02:00
#include "x11/dynwrappers/xcursor-so_wrap.h"
#include "x11/dynwrappers/xext-so_wrap.h"
#include "x11/dynwrappers/xinerama-so_wrap.h"
#include "x11/dynwrappers/xinput2-so_wrap.h"
#include "x11/dynwrappers/xrandr-so_wrap.h"
#include "x11/dynwrappers/xrender-so_wrap.h"
Load X11 dynamically The loaders have been generated through hpvb's dynload-wrapper, although they had to be heavily handpatched to workaround some already reported issues with it. I added a note to each generated file to account for that. As GLAD uses X11 stuff directly, I had to define the GLAD_GLX_NO_X11 macro to not let do it that, and handle myself the display loading and screen handling part myself, which wasn't that hard but it's still something worth saying. I plan to improve greatly the X11 backend (including this aspect) but, as the release isn't that far and I'm also working on the Wayland backend, this will do for now, I hope.
2022-11-29 12:03:06 +01:00
Style: Harmonize header includes in platform ports This applies our existing style guide, and adds a new rule to that style guide for modular components such as platform ports and modules: Includes from the platform port or module should be included with relative paths (relative to the root folder of the modular component, e.g. `platform/linuxbsd/`), in their own section before Godot's "core" includes. The `api` and `export` subfolders also need to be handled as self-contained (and thus use relative paths for their "local" includes) as they are all compiled for each editor platform, without necessarily having the api/export matching platform folder in the include path. E.g. the Linux editor build will compile `platform/android/{api,export}/*.cpp` and those need to use relative includes for it to work.
2023-06-08 14:51:32 +02:00
#include "xkbcommon-so_wrap.h"
[Linux] Make SO wrapper usage optional.
2023-02-15 14:13:56 +02:00
#else
#include <X11/XKBlib.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xcursor/Xcursor.h>
#include <X11/extensions/XInput2.h>
#include <X11/extensions/Xext.h>
#include <X11/extensions/Xinerama.h>
#include <X11/extensions/Xrandr.h>
#include <X11/extensions/Xrender.h>
#include <X11/extensions/shape.h>
#ifdef XKB_ENABLED
#include <xkbcommon/xkbcommon-compose.h>
#include <xkbcommon/xkbcommon-keysyms.h>
#include <xkbcommon/xkbcommon.h>
#endif
#endif
Move xkbcommon dynamic loading code into generic linuxbsd folder Since Wayland uses it too, it only makes sense to have it in the parent directory of both.
2023-01-23 20:37:19 +01:00
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
typedef struct _xrr_monitor_info {
Atom name;
Initialize class/struct variables with default values in platform/ and editor/
2020-11-24 10:12:55 +01:00
Bool primary = false;
Bool automatic = false;
int noutput = 0;
int x = 0;
int y = 0;
int width = 0;
int height = 0;
int mwidth = 0;
int mheight = 0;
RROutput *outputs = nullptr;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
} xrr_monitor_info;
#undef CursorShape
class DisplayServerX11 : public DisplayServer {
Don't expose mac specific display server.
2023-05-08 20:32:56 +02:00
// No need to register with GDCLASS, it's platform-specific and nothing is added.
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Make DisplayServerX11 thread safe
2020-03-07 12:46:50 -03:00
_THREAD_SAFE_CLASS_
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Atom wm_delete;
Atom xdnd_enter;
Atom xdnd_position;
Atom xdnd_status;
Atom xdnd_action_copy;
Atom xdnd_drop;
Atom xdnd_finished;
Atom xdnd_selection;
Atom xdnd_aware;
Style: Partially apply clang-tidy's `cppcoreguidelines-pro-type-member-init` Didn't commit all the changes where it wants to initialize a struct with `{}`. Should be reviewed in a separate PR. Option `IgnoreArrays` enabled for now to be conservative, can be disabled to see if it proposes more useful changes. Also fixed manually a handful of other missing initializations / moved some from constructors.
2022-05-02 16:28:25 +02:00
Atom requested = None;
int xdnd_version = 5;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Use OpenGL 3.3 core profile instead of compatibility profile - Rename OpenGL to GLES3 in the source code per community feedback. - The renderer is still exposed as "OpenGL 3" to the user. - Hide renderer selection dropdown until OpenGL support is more mature. - The renderer can still be changed in the Project Settings or using the `--rendering-driver opengl` command line argument. - Remove commented out exporter code. - Remove some OpenGL/DisplayServer-related debugging prints.
2021-10-26 08:18:39 -07:00
#if defined(GLES3_ENABLED)
Add GLES2 2D renderer + Linux display manager First implementation with Linux display manager. - Add single-threaded mode for EditorResourcePreview (needed for OpenGL). Co-authored-by: clayjohn <claynjohn@gmail.com> Co-authored-by: Fabio Alessandrelli <fabio.alessandrelli@gmail.com>
2020-11-18 18:11:30 +00:00
GLManager_X11 *gl_manager = nullptr;
[X11] Add support for using EGL/GLES instead of GLX.
2023-09-22 10:55:55 +03:00
GLManagerEGL_X11 *gl_manager_egl = nullptr;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
#endif
#if defined(VULKAN_ENABLED)
Add GLES2 2D renderer + Linux display manager First implementation with Linux display manager. - Add single-threaded mode for EditorResourcePreview (needed for OpenGL). Co-authored-by: clayjohn <claynjohn@gmail.com> Co-authored-by: Fabio Alessandrelli <fabio.alessandrelli@gmail.com>
2020-11-18 18:11:30 +00:00
VulkanContextX11 *context_vulkan = nullptr;
RenderingDeviceVulkan *rendering_device_vulkan = nullptr;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
#endif
Add "Keep screen on" feature to `DisplayServerX11`
2020-04-02 23:46:34 +02:00
#if defined(DBUS_ENABLED)
Zero initialize all pointer class and struct members This prevents the pitfall of UB when checking if they have been assigned something valid by comparing to nullptr.
2022-04-04 15:06:57 +02:00
FreeDesktopScreenSaver *screensaver = nullptr;
Add "Keep screen on" feature to `DisplayServerX11`
2020-04-02 23:46:34 +02:00
bool keep_screen_on = false;
#endif
Implement text-to-speech support on Android, iOS, HTML5, Linux, macOS and Windows. Implement TextServer word break method.
2021-11-04 14:33:37 +02:00
#ifdef SPEECHD_ENABLED
TTS_Linux *tts = nullptr;
#endif
Add support for system dark mode (Linux) - Use `org.freedesktop.appearance color-scheme` to support system dark mode.
2022-08-30 17:04:17 +02:00
#if defined(DBUS_ENABLED)
FreeDesktopPortalDesktop *portal_desktop = nullptr;
#endif
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
struct WindowData {
Window x11_window;
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-11 01:21:22 +02:00
Window x11_xim_window;
Fix the sliding window problem in linux occur due to reparenting of the window during the decoration via tracking the parent of the window
2023-04-13 23:36:43 +05:30
Window parent;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
::XIC xic;
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-11 01:21:22 +02:00
bool ime_active = false;
bool ime_in_progress = false;
bool ime_suppress_next_keyup = false;
[Linux] Make SO wrapper usage optional.
2023-02-15 14:13:56 +02:00
#ifdef XKB_ENABLED
[X11] Add support for dead keys without active IME. Fix IME focus and cleanup.
2023-01-30 10:59:49 +02:00
xkb_compose_state *xkb_state = nullptr;
[Linux] Make SO wrapper usage optional.
2023-02-15 14:13:56 +02:00
#endif
Added a Window node, and made it the scene root. Still a lot of work to do.
2020-03-03 22:51:12 -03:00
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Size2i min_size;
Size2i max_size;
Fixes to X11, still pretty broken
2020-03-25 11:16:19 -03:00
Point2i position;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Size2i size;
Open sub-windows as embedded if the OS does not support them
2020-03-14 13:06:39 -03:00
Callable rect_changed_callback;
Refactored input, goes all via windows now. Also renamed Input to InputFilter because all it does is filter events.
2020-03-04 13:36:09 -03:00
Callable event_callback;
Callable input_event_callback;
Callable input_text_callback;
Callable drop_files_callback;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Add `WINDOW_FLAG_MOUSE_PASSTHROUGH` flag and enabled it for tooltips. Expose `window_set_mouse_passthrough` to `Window`.
2023-01-15 12:05:25 +02:00
Vector<Vector2> mpath;
Support for transient windows
2020-03-04 16:03:30 -03:00
WindowID transient_parent = INVALID_WINDOW_ID;
Add a new HashSet template * Intended to replace RBSet in most cases. * Optimized for iteration speed
2022-05-19 17:00:06 +02:00
HashSet<WindowID> transient_children;
Support for transient windows
2020-03-04 16:03:30 -03:00
Implemented drag and drop across windows, both OS and embedded.
2020-03-24 20:15:35 -03:00
ObjectID instance_id;
Fix menu popups delay and focus in X11 display server Now using override_redirect for menu & tooltip popups to prevent the WM from interfering with them, so we have more control over focus management and avoid a delay before they show up.
2020-08-22 13:01:49 +02:00
bool no_focus = false;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
//better to guess on the fly, given WM can change it
//WindowMode mode;
bool fullscreen = false; //OS can't exit from this mode
[Linux/X11] Split fullscreen mode into `WINDOW_MODE_EXCLUSIVE_FULLSCREEN` and `WINDOW_MODE_FULLSCREEN` to improve multi-window handling.
2022-12-07 09:54:02 +02:00
bool exclusive_fullscreen = false;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
bool on_top = false;
bool borderless = false;
bool resize_disabled = false;
Vector2i last_position_before_fs;
Set window to focused when created
2022-01-06 08:04:59 +00:00
bool focused = true;
Ensure embedded mode works again Also implemented application in/out notifications in X11.
2020-07-01 09:27:43 -03:00
bool minimized = false;
Fix minimize/maximize not taking effect in X11. Attempts to construct an X11 window in an initial state of minimized/maximized would fail due to the window being unmapped. We simply check for failed mode changes during an unmap and reapply them if necessary.
2022-08-30 12:52:24 -06:00
bool maximized = false;
Improve popup window handling. Add window FLAG_POPUP and a platform specific routines to control popup auto-hiding and event forwarding.
2022-02-24 11:21:23 +02:00
bool is_popup = false;
Re-enable per-pixel transparency support on Linux, macOS, and Windows (for Vulkan and OpenGL rendering drivers).
2022-09-03 13:40:53 +03:00
bool layered_window = false;
Add `WINDOW_FLAG_MOUSE_PASSTHROUGH` flag and enabled it for tooltips. Expose `window_set_mouse_passthrough` to `Window`.
2023-01-15 12:05:25 +02:00
bool mpass = false;
Improve popup window handling. Add window FLAG_POPUP and a platform specific routines to control popup auto-hiding and event forwarding.
2022-02-24 11:21:23 +02:00
Rect2i parent_safe_rect;
Fix drag and drop between windows in X11 display server Proper implementation for get_window_at_screen_position: Now getting the topmost last active window when overlapping. Mouse drag & release events: They are now propagated through the current focused window, in order to make it consistent with the engine expectations and the Windows display server implementation.
2020-08-29 12:00:44 +02:00
unsigned int focus_order = 0;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
};
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-11 01:21:22 +02:00
Point2i im_selection;
String im_text;
[Linux] Make SO wrapper usage optional.
2023-02-15 14:13:56 +02:00
#ifdef XKB_ENABLED
[Linux/BSD] Add dynamically loaded library version checks.
2023-03-16 10:44:47 +02:00
bool xkb_loaded_v05p = false;
bool xkb_loaded_v08p = false;
[X11] Add support for dead keys without active IME. Fix IME focus and cleanup.
2023-01-30 10:59:49 +02:00
xkb_context *xkb_ctx = nullptr;
xkb_compose_table *dead_tbl = nullptr;
[Linux] Make SO wrapper usage optional.
2023-02-15 14:13:56 +02:00
#endif
[X11] Add support for dead keys without active IME. Fix IME focus and cleanup.
2023-01-30 10:59:49 +02:00
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<WindowID, WindowData> windows;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Improve popup window handling. Add window FLAG_POPUP and a platform specific routines to control popup auto-hiding and event forwarding.
2022-02-24 11:21:23 +02:00
unsigned int last_mouse_monitor_mask = 0;
uint64_t time_since_popup = 0;
List<WindowID> popup_list;
Track hovered `Window` in `DisplayServerX11` Send mouse-entered/exited window-events only when necessary
2023-08-05 01:52:59 +02:00
WindowID window_mouseover_id = INVALID_WINDOW_ID;
Fix captured mouse mode
2022-02-01 03:49:51 +01:00
WindowID last_focused_window = INVALID_WINDOW_ID;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
WindowID window_id_counter = MAIN_WINDOW_ID;
Add support for the custom initial screen for the main window, fix primary screen detection.
2023-01-05 00:00:02 +02:00
WindowID _create_window(WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Rect2i &p_rect);
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
String internal_clipboard;
Added primary clipboard for Linux
2021-10-12 09:43:50 +02:00
String internal_clipboard_primary;
Style: Partially apply clang-tidy's `cppcoreguidelines-pro-type-member-init` Didn't commit all the changes where it wants to initialize a struct with `{}`. Should be reviewed in a separate PR. Option `IgnoreArrays` enabled for now to be conservative, can be disabled to see if it proposes more useful changes. Also fixed manually a handful of other missing initializations / moved some from constructors.
2022-05-02 16:28:25 +02:00
Window xdnd_source_window = 0;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
::Display *x11_display;
Zero initialize all pointer class and struct members This prevents the pitfall of UB when checking if they have been assigned something valid by comparing to nullptr.
2022-04-04 15:06:57 +02:00
char *xmbstring = nullptr;
Style: Partially apply clang-tidy's `cppcoreguidelines-pro-type-member-init` Didn't commit all the changes where it wants to initialize a struct with `{}`. Should be reviewed in a separate PR. Option `IgnoreArrays` enabled for now to be conservative, can be disabled to see if it proposes more useful changes. Also fixed manually a handful of other missing initializations / moved some from constructors.
2022-05-02 16:28:25 +02:00
int xmblen = 0;
unsigned long last_timestamp = 0;
::Time last_keyrelease_time = 0;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
::XIM xim;
::XIMStyle xim_style;
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-11 01:21:22 +02:00
static int _xim_preedit_start_callback(::XIM xim, ::XPointer client_data,
::XPointer call_data);
static void _xim_preedit_done_callback(::XIM xim, ::XPointer client_data,
::XPointer call_data);
static void _xim_preedit_draw_callback(::XIM xim, ::XPointer client_data,
::XIMPreeditDrawCallbackStruct *call_data);
static void _xim_preedit_caret_callback(::XIM xim, ::XPointer client_data,
::XIMPreeditCaretCallbackStruct *call_data);
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
static void _xim_destroy_callback(::XIM im, ::XPointer client_data,
::XPointer call_data);
Point2i last_mouse_pos;
Style: Partially apply clang-tidy's `cppcoreguidelines-pro-type-member-init` Didn't commit all the changes where it wants to initialize a struct with `{}`. Should be reviewed in a separate PR. Option `IgnoreArrays` enabled for now to be conservative, can be disabled to see if it proposes more useful changes. Also fixed manually a handful of other missing initializations / moved some from constructors.
2022-05-02 16:28:25 +02:00
bool last_mouse_pos_valid = false;
Point2i last_click_pos = Point2i(-100, -100);
uint64_t last_click_ms = 0;
Use "enum class" for input enums
2021-08-13 16:31:57 -05:00
MouseButton last_click_button_index = MouseButton::NONE;
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-08 00:55:54 +01:00
BitField<MouseButtonMask> last_button_state;
Ensure embedded mode works again Also implemented application in/out notifications in X11.
2020-07-01 09:27:43 -03:00
bool app_focused = false;
Add a focus out timeout for X11 to less events of this type are received
2020-07-01 16:14:46 -03:00
uint64_t time_since_no_focus = 0;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
struct {
int opcode;
Vector<int> touch_devices;
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<int, Vector2> absolute_devices;
HashMap<int, Vector2> pen_pressure_range;
HashMap<int, Vector2> pen_tilt_x_range;
HashMap<int, Vector2> pen_tilt_y_range;
[macOS, Windows, X11] Add stylus inverted/eraser support to InputEventMouseMotion event
2022-06-19 02:58:24 -07:00
HashMap<int, bool> pen_inverted_devices;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
XIEventMask all_event_mask;
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<int, Vector2> state;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
double pressure;
[Linux/Windows] Set pressure to 1.0f when primary button is pressed and device is not pressure sensitive.
2020-05-03 15:38:58 +03:00
bool pressure_supported;
[macOS, Windows, X11] Add stylus inverted/eraser support to InputEventMouseMotion event
2022-06-19 02:58:24 -07:00
bool pen_inverted;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Vector2 tilt;
Vector2 mouse_pos_to_filter;
Vector2 relative_motion;
Vector2 raw_pos;
Vector2 old_raw_pos;
::Time last_relative_time;
} xi;
bool _refresh_device_info();
Fix window_get_current_screen for X11 display server This method used to check which screen contains the top-left corner of the window (and default to the first screen in case none is found), which is not accurate in some cases. Now the area of overlap with each screen is calculated, so we can get the best candidate based on the window's position. This makes window_get_current_screen consistent with Windows platform, and fixes an issue where popups appear on the main screen when the main window is slightly moved outside of the desktop on the top or left.
2020-09-16 16:33:33 +02:00
Rect2i _screen_get_rect(int p_screen) const;
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-08 00:55:54 +01:00
BitField<MouseButtonMask> _get_mouse_button_state(MouseButton p_x11_button, int p_x11_type);
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
void _get_key_modifier_state(unsigned int p_x11_state, Ref<InputEventWithModifiers> state);
void _flush_mouse_motion();
Style: Partially apply clang-tidy's `cppcoreguidelines-pro-type-member-init` Didn't commit all the changes where it wants to initialize a struct with `{}`. Should be reviewed in a separate PR. Option `IgnoreArrays` enabled for now to be conservative, can be disabled to see if it proposes more useful changes. Also fixed manually a handful of other missing initializations / moved some from constructors.
2022-05-02 16:28:25 +02:00
MouseMode mouse_mode = MOUSE_MODE_VISIBLE;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Point2i center;
Fix general keyboard input lag on X11 display server This change makes keyboard inputs more responsive on Linux, especially when the FPS is lower on slower configurations. Polling events from the x server is done on a separate thread to avoid a frame delay with inputs, due to first sending the event to the input manager with XFilterEvent then processing the new event only on the next frame. Calls to Input Manager functions like XSetICFocus, XUnsetICFocus and XSetICValues use a mutex, because they are polling events internally and would otherwise interfere with our own thread process for polling events which can cause a deadlock in some cases. XUnsetICFocus is called instead of XSetICFocus on FocusOut events, so the input manager can be properly notified of focus changes. clipboard_get now uses a blocking call to poll for a specific event type when waiting for a SelectionNotify event, instead of polling all events and filtering them afterwards.
2020-09-09 12:43:20 +02:00
void _handle_key_event(WindowID p_window, XKeyEvent *p_event, LocalVector<XEvent> &p_events, uint32_t &p_event_index, bool p_echo = false);
Implement SAVE_TARGETS mechanism for Linux clipboard 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
2020-10-08 17:57:54 +02:00
Added primary clipboard for Linux
2021-10-12 09:43:50 +02:00
Atom _process_selection_request_target(Atom p_target, Window p_requestor, Atom p_property, Atom p_selection) const;
Implement SAVE_TARGETS mechanism for Linux clipboard 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
2020-10-08 17:57:54 +02:00
void _handle_selection_request_event(XSelectionRequestEvent *p_event) const;
Add `WINDOW_FLAG_MOUSE_PASSTHROUGH` flag and enabled it for tooltips. Expose `window_set_mouse_passthrough` to `Window`.
2023-01-15 12:05:25 +02:00
void _update_window_mouse_passthrough(WindowID p_window);
Fix general keyboard input lag on X11 display server This change makes keyboard inputs more responsive on Linux, especially when the FPS is lower on slower configurations. Polling events from the x server is done on a separate thread to avoid a frame delay with inputs, due to first sending the event to the input manager with XFilterEvent then processing the new event only on the next frame. Calls to Input Manager functions like XSetICFocus, XUnsetICFocus and XSetICValues use a mutex, because they are polling events internally and would otherwise interfere with our own thread process for polling events which can cause a deadlock in some cases. XUnsetICFocus is called instead of XSetICFocus on FocusOut events, so the input manager can be properly notified of focus changes. clipboard_get now uses a blocking call to poll for a specific event type when waiting for a SelectionNotify event, instead of polling all events and filtering them afterwards.
2020-09-09 12:43:20 +02:00
String _clipboard_get_impl(Atom p_source, Window x11_window, Atom target) const;
String _clipboard_get(Atom p_source, Window x11_window) const;
Implement clipboard_get/has_image for X11
2023-09-14 19:58:13 -05:00
Atom _clipboard_get_image_target(Atom p_source, Window x11_window) const;
Implement SAVE_TARGETS mechanism for Linux clipboard 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
2020-10-08 17:57:54 +02:00
void _clipboard_transfer_ownership(Atom p_source, Window x11_window) const;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Style: Partially apply clang-tidy's `cppcoreguidelines-pro-type-member-init` Didn't commit all the changes where it wants to initialize a struct with `{}`. Should be reviewed in a separate PR. Option `IgnoreArrays` enabled for now to be conservative, can be disabled to see if it proposes more useful changes. Also fixed manually a handful of other missing initializations / moved some from constructors.
2022-05-02 16:28:25 +02:00
bool do_mouse_warp = false;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Style: Partially apply clang-tidy's `cppcoreguidelines-pro-type-member-init` Didn't commit all the changes where it wants to initialize a struct with `{}`. Should be reviewed in a separate PR. Option `IgnoreArrays` enabled for now to be conservative, can be disabled to see if it proposes more useful changes. Also fixed manually a handful of other missing initializations / moved some from constructors.
2022-05-02 16:28:25 +02:00
const char *cursor_theme = nullptr;
int cursor_size = 0;
Enable shadow warnings and fix raised errors
2023-05-11 12:32:23 +02:00
XcursorImage *cursor_img[CURSOR_MAX];
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Cursor cursors[CURSOR_MAX];
Cursor null_cursor;
Style: Partially apply clang-tidy's `cppcoreguidelines-pro-type-member-init` Didn't commit all the changes where it wants to initialize a struct with `{}`. Should be reviewed in a separate PR. Option `IgnoreArrays` enabled for now to be conservative, can be disabled to see if it proposes more useful changes. Also fixed manually a handful of other missing initializations / moved some from constructors.
2022-05-02 16:28:25 +02:00
CursorShape current_cursor = CURSOR_ARROW;
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<CursorShape, Vector<Variant>> cursors_cache;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Effective DisplayServer separation, rename X11 -> LinuxBSD
2020-03-03 10:36:29 -03:00
String rendering_driver;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
void set_wm_fullscreen(bool p_enabled);
void set_wm_above(bool p_enabled);
typedef xrr_monitor_info *(*xrr_get_monitors_t)(Display *dpy, Window window, Bool get_active, int *nmonitors);
typedef void (*xrr_free_monitors_t)(xrr_monitor_info *monitors);
Style: Partially apply clang-tidy's `cppcoreguidelines-pro-type-member-init` Didn't commit all the changes where it wants to initialize a struct with `{}`. Should be reviewed in a separate PR. Option `IgnoreArrays` enabled for now to be conservative, can be disabled to see if it proposes more useful changes. Also fixed manually a handful of other missing initializations / moved some from constructors.
2022-05-02 16:28:25 +02:00
xrr_get_monitors_t xrr_get_monitors = nullptr;
xrr_free_monitors_t xrr_free_monitors = nullptr;
Zero initialize all pointer class and struct members This prevents the pitfall of UB when checking if they have been assigned something valid by comparing to nullptr.
2022-04-04 15:06:57 +02:00
void *xrandr_handle = nullptr;
[X11] Do not fail DisplayServer init if non-essential extensions are missing.
2023-08-04 10:58:14 +03:00
bool xrandr_ext_ok = true;
bool xinerama_ext_ok = true;
bool xshaped_ext_ok = true;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
struct Property {
unsigned char *data;
int format, nitems;
Atom type;
};
static Property _read_property(Display *p_display, Window p_window, Atom p_property);
void _update_real_mouse_position(const WindowData &wd);
X11: Ensure XGetWindowProperty data gets freed And cleanup includes a bit.
2020-06-29 13:29:31 +02:00
bool _window_maximize_check(WindowID p_window, const char *p_atom_name) const;
Properly check for fullscreen toggle made through the Window Manager Fixes #40007. Co-authored-by: Rémi Verschelde <rverschelde@gmail.com>
2022-06-29 21:55:40 -04:00
bool _window_fullscreen_check(WindowID p_window) const;
Fix minimize/maximize not taking effect in X11. Attempts to construct an X11 window in an initial state of minimized/maximized would fail due to the window being unmapped. We simply check for failed mode changes during an unmap and reapply them if necessary.
2022-08-30 12:52:24 -06:00
bool _window_minimize_check(WindowID p_window) const;
void _validate_mode_on_map(WindowID p_window);
Fix losing X11 window normal size hint properties This was caused by `XSetWMNormalHints` being called multiple times, each time with different values. Calling the method replaces the old data completely, resulting in some of the settings being lost. Since the method was called 3 times before the window was mapped, this resulted in the position hint being lost and the window always getting opened at a position determined by the WM.
2020-07-31 17:27:16 +02:00
void _update_size_hints(WindowID p_window);
[Linux/X11] Split fullscreen mode into `WINDOW_MODE_EXCLUSIVE_FULLSCREEN` and `WINDOW_MODE_FULLSCREEN` to improve multi-window handling.
2022-12-07 09:54:02 +02:00
void _set_wm_fullscreen(WindowID p_window, bool p_enabled, bool p_exclusive);
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
void _set_wm_maximized(WindowID p_window, bool p_enabled);
Fix minimize/maximize not taking effect in X11. Attempts to construct an X11 window in an initial state of minimized/maximized would fail due to the window being unmapped. We simply check for failed mode changes during an unmap and reapply them if necessary.
2022-08-30 12:52:24 -06:00
void _set_wm_minimized(WindowID p_window, bool p_enabled);
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Effective DisplayServer separation, rename X11 -> LinuxBSD
2020-03-03 10:36:29 -03:00
void _update_context(WindowData &wd);
Context context = CONTEXT_ENGINE;
Fix MOUSE_MODE_CAPTURED not working correctly with popups
2022-09-07 19:31:57 +02:00
WindowID _get_focused_window_or_popup() const;
Refactored input, goes all via windows now. Also renamed Input to InputFilter because all it does is filter events.
2020-03-04 13:36:09 -03:00
void _send_window_event(const WindowData &wd, WindowEvent p_event);
static void _dispatch_input_events(const Ref<InputEvent> &p_event);
void _dispatch_input_event(const Ref<InputEvent> &p_event);
Fix general keyboard input lag on X11 display server This change makes keyboard inputs more responsive on Linux, especially when the FPS is lower on slower configurations. Polling events from the x server is done on a separate thread to avoid a frame delay with inputs, due to first sending the event to the input manager with XFilterEvent then processing the new event only on the next frame. Calls to Input Manager functions like XSetICFocus, XUnsetICFocus and XSetICValues use a mutex, because they are polling events internally and would otherwise interfere with our own thread process for polling events which can cause a deadlock in some cases. XUnsetICFocus is called instead of XSetICFocus on FocusOut events, so the input manager can be properly notified of focus changes. clipboard_get now uses a blocking call to poll for a specific event type when waiting for a SelectionNotify event, instead of polling all events and filtering them afterwards.
2020-09-09 12:43:20 +02:00
mutable Mutex events_mutex;
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-19 13:29:41 +01:00
Thread events_thread;
Modernize atomics - Based on C++11's `atomic` - Reworked `SafeRefCount` (based on the rewrite by @hpvb) - Replaced free atomic functions by the new `SafeNumeric<T>` - Replaced wrong cases of `volatile bool` by the new `SafeFlag` - Platform-specific implementations no longer needed Co-authored-by: Hein-Pieter van Braam-Stewart <hp@tmm.cx>
2021-02-10 19:22:13 +01:00
SafeFlag events_thread_done;
Fix general keyboard input lag on X11 display server This change makes keyboard inputs more responsive on Linux, especially when the FPS is lower on slower configurations. Polling events from the x server is done on a separate thread to avoid a frame delay with inputs, due to first sending the event to the input manager with XFilterEvent then processing the new event only on the next frame. Calls to Input Manager functions like XSetICFocus, XUnsetICFocus and XSetICValues use a mutex, because they are polling events internally and would otherwise interfere with our own thread process for polling events which can cause a deadlock in some cases. XUnsetICFocus is called instead of XSetICFocus on FocusOut events, so the input manager can be properly notified of focus changes. clipboard_get now uses a blocking call to poll for a specific event type when waiting for a SelectionNotify event, instead of polling all events and filtering them afterwards.
2020-09-09 12:43:20 +02:00
LocalVector<XEvent> polled_events;
static void _poll_events_thread(void *ud);
Implement SAVE_TARGETS mechanism for Linux clipboard 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
2020-10-08 17:57:54 +02:00
bool _wait_for_events() const;
Fix general keyboard input lag on X11 display server This change makes keyboard inputs more responsive on Linux, especially when the FPS is lower on slower configurations. Polling events from the x server is done on a separate thread to avoid a frame delay with inputs, due to first sending the event to the input manager with XFilterEvent then processing the new event only on the next frame. Calls to Input Manager functions like XSetICFocus, XUnsetICFocus and XSetICValues use a mutex, because they are polling events internally and would otherwise interfere with our own thread process for polling events which can cause a deadlock in some cases. XUnsetICFocus is called instead of XSetICFocus on FocusOut events, so the input manager can be properly notified of focus changes. clipboard_get now uses a blocking call to poll for a specific event type when waiting for a SelectionNotify event, instead of polling all events and filtering them afterwards.
2020-09-09 12:43:20 +02:00
void _poll_events();
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-27 15:23:40 -07:00
void _check_pending_events(LocalVector<XEvent> &r_events);
Fix general keyboard input lag on X11 display server This change makes keyboard inputs more responsive on Linux, especially when the FPS is lower on slower configurations. Polling events from the x server is done on a separate thread to avoid a frame delay with inputs, due to first sending the event to the input manager with XFilterEvent then processing the new event only on the next frame. Calls to Input Manager functions like XSetICFocus, XUnsetICFocus and XSetICValues use a mutex, because they are polling events internally and would otherwise interfere with our own thread process for polling events which can cause a deadlock in some cases. XUnsetICFocus is called instead of XSetICFocus on FocusOut events, so the input manager can be properly notified of focus changes. clipboard_get now uses a blocking call to poll for a specific event type when waiting for a SelectionNotify event, instead of polling all events and filtering them afterwards.
2020-09-09 12:43:20 +02:00
static Bool _predicate_all_events(Display *display, XEvent *event, XPointer arg);
static Bool _predicate_clipboard_selection(Display *display, XEvent *event, XPointer arg);
Implement INCR mechanism for Linux clipboard Allows pasting from x11 clipboard to receive data incrementally, which is required when handling data size > 256KB.
2020-10-09 16:54:36 +02:00
static Bool _predicate_clipboard_incr(Display *display, XEvent *event, XPointer arg);
Implement SAVE_TARGETS mechanism for Linux clipboard 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
2020-10-08 17:57:54 +02:00
static Bool _predicate_clipboard_save_targets(Display *display, XEvent *event, XPointer arg);
Fix general keyboard input lag on X11 display server This change makes keyboard inputs more responsive on Linux, especially when the FPS is lower on slower configurations. Polling events from the x server is done on a separate thread to avoid a frame delay with inputs, due to first sending the event to the input manager with XFilterEvent then processing the new event only on the next frame. Calls to Input Manager functions like XSetICFocus, XUnsetICFocus and XSetICValues use a mutex, because they are polling events internally and would otherwise interfere with our own thread process for polling events which can cause a deadlock in some cases. XUnsetICFocus is called instead of XSetICFocus on FocusOut events, so the input manager can be properly notified of focus changes. clipboard_get now uses a blocking call to poll for a specific event type when waiting for a SelectionNotify event, instead of polling all events and filtering them afterwards.
2020-09-09 12:43:20 +02:00
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
protected:
void _window_changed(XEvent *event);
public:
Remove mouse events that closed the popup from queue, to fix pop-up reopening.
2022-05-30 11:06:08 +03:00
bool mouse_process_popups();
Improve popup window handling. Add window FLAG_POPUP and a platform specific routines to control popup auto-hiding and event forwarding.
2022-02-24 11:21:23 +02:00
void popup_open(WindowID p_window);
void popup_close(WindowID p_window);
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual bool has_feature(Feature p_feature) const override;
virtual String get_name() const override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Implement text-to-speech support on Android, iOS, HTML5, Linux, macOS and Windows. Implement TextServer word break method.
2021-11-04 14:33:37 +02:00
#ifdef SPEECHD_ENABLED
virtual bool tts_is_speaking() const override;
virtual bool tts_is_paused() const override;
Replace Array return types with TypedArray
2022-08-05 03:41:48 +02:00
virtual TypedArray<Dictionary> tts_get_voices() const override;
Implement text-to-speech support on Android, iOS, HTML5, Linux, macOS and Windows. Implement TextServer word break method.
2021-11-04 14:33:37 +02:00
virtual void tts_speak(const String &p_text, const String &p_voice, int p_volume = 50, float p_pitch = 1.f, float p_rate = 1.f, int p_utterance_id = 0, bool p_interrupt = false) override;
virtual void tts_pause() override;
virtual void tts_resume() override;
virtual void tts_stop() override;
#endif
Add support for system dark mode (Linux) - Use `org.freedesktop.appearance color-scheme` to support system dark mode.
2022-08-30 17:04:17 +02:00
#if defined(DBUS_ENABLED)
virtual bool is_dark_mode_supported() const override;
virtual bool is_dark_mode() const override;
[Linux/Freedesktop] Implement native file selection dialog support.
2023-08-01 10:18:41 +03:00
virtual Error file_dialog_show(const String &p_title, const String &p_current_directory, const String &p_filename, bool p_show_hidden, FileDialogMode p_mode, const Vector<String> &p_filters, const Callable &p_callback) override;
Add support for system dark mode (Linux) - Use `org.freedesktop.appearance color-scheme` to support system dark mode.
2022-08-30 17:04:17 +02:00
#endif
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void mouse_set_mode(MouseMode p_mode) override;
virtual MouseMode mouse_get_mode() const override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Rename warp mouse functions to warp_mouse
2022-03-27 11:17:36 +02:00
virtual void warp_mouse(const Point2i &p_position) override;
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual Point2i mouse_get_position() const override;
Use BitField<> in core type masks * All core types masks are now correctly marked as bitfields. * The enum hacks in MouseButtonMask and many other types are gone. This ensures that binders to other languages non C++ can actually implement type safe bitmasks. * Most bitmask operations replaced by functions in BitField<> * Key is still a problem because its enum and mask at the same time. While it kind of works in C++, this most likely can't be implemented safely in other languages and will have to be changed at some point. Mostly left as-is. * Documentation and API dump updated to reflect bitfields in core types.
2023-01-08 00:55:54 +01:00
virtual BitField<MouseButtonMask> mouse_get_button_state() const override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void clipboard_set(const String &p_text) override;
virtual String clipboard_get() const override;
Implement clipboard_get/has_image for X11
2023-09-14 19:58:13 -05:00
virtual Ref<Image> clipboard_get_image() const override;
virtual bool clipboard_has_image() const override;
Added primary clipboard for Linux
2021-10-12 09:43:50 +02:00
virtual void clipboard_set_primary(const String &p_text) override;
virtual String clipboard_get_primary() const override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual int get_screen_count() const override;
Add support for the custom initial screen for the main window, fix primary screen detection.
2023-01-05 00:00:02 +02:00
virtual int get_primary_screen() const override;
Add project manager / editor initial screen settings, implement DisplayServer.get_keyboard_focus_screen method.
2023-03-21 13:08:46 +02:00
virtual int get_keyboard_focus_screen() const override;
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual Point2i screen_get_position(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual Size2i screen_get_size(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual Rect2i screen_get_usable_rect(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual int screen_get_dpi(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
Add screen_get_refresh_rate to DisplayServer
2022-01-27 13:46:57 -06:00
virtual float screen_get_refresh_rate(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
[DisplayServer] Implement screen_get_pixel method for LinuxBSD/X11, macOS and Windows.
2023-02-27 20:36:13 +02:00
virtual Color screen_get_pixel(const Point2i &p_position) const override;
[DisplayServer] Implement screen_get_image method for LinuxBSD/X11, macOS and Windows.
2023-03-16 23:26:09 +02:00
virtual Ref<Image> screen_get_image(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Add "Keep screen on" feature to `DisplayServerX11`
2020-04-02 23:46:34 +02:00
#if defined(DBUS_ENABLED)
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void screen_set_keep_on(bool p_enable) override;
virtual bool screen_is_kept_on() const override;
Add "Keep screen on" feature to `DisplayServerX11`
2020-04-02 23:46:34 +02:00
#endif
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual Vector<DisplayServer::WindowID> get_window_list() const override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Add support for the custom initial screen for the main window, fix primary screen detection.
2023-01-05 00:00:02 +02:00
virtual WindowID create_sub_window(WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Rect2i &p_rect = Rect2i()) override;
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void show_window(WindowID p_id) override;
virtual void delete_sub_window(WindowID p_id) override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Improve popup window handling. Add window FLAG_POPUP and a platform specific routines to control popup auto-hiding and event forwarding.
2022-02-24 11:21:23 +02:00
virtual WindowID window_get_active_popup() const override;
virtual void window_set_popup_safe_rect(WindowID p_window, const Rect2i &p_rect) override;
virtual Rect2i window_get_popup_safe_rect(WindowID p_window) const override;
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual WindowID get_window_at_screen_position(const Point2i &p_position) const override;
Implemented drag and drop across windows, both OS and embedded.
2020-03-24 20:15:35 -03:00
Add support for getting native display, window, and view handles.
2022-01-14 12:41:04 +02:00
virtual int64_t window_get_native_handle(HandleType p_handle_type, WindowID p_window = MAIN_WINDOW_ID) const override;
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void window_attach_instance_id(ObjectID p_instance, WindowID p_window = MAIN_WINDOW_ID) override;
virtual ObjectID window_get_attached_instance_id(WindowID p_window = MAIN_WINDOW_ID) const override;
Implemented drag and drop across windows, both OS and embedded.
2020-03-24 20:15:35 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void window_set_title(const String &p_title, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_mouse_passthrough(const Vector<Vector2> &p_region, WindowID p_window = MAIN_WINDOW_ID) override;
Add window click-through support.
2020-06-29 12:31:36 +03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void window_set_rect_changed_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_window_event_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_input_event_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_input_text_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_drop_files_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID) override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual int window_get_current_screen(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_current_screen(int p_screen, WindowID p_window = MAIN_WINDOW_ID) override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual Point2i window_get_position(WindowID p_window = MAIN_WINDOW_ID) const override;
Rename `window_get_real_size` to `window_get_size_with_decorations`, add `window_get_position_with_decorations`.
2022-11-30 10:28:16 +02:00
virtual Point2i window_get_position_with_decorations(WindowID p_window = MAIN_WINDOW_ID) const override;
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void window_set_position(const Point2i &p_position, WindowID p_window = MAIN_WINDOW_ID) override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void window_set_max_size(const Size2i p_size, WindowID p_window = MAIN_WINDOW_ID) override;
virtual Size2i window_get_max_size(WindowID p_window = MAIN_WINDOW_ID) const override;
Rename GLES2 driver to OpenGL to prepare for the upgrade to GLES3 - Use lowercase driver names for the `--rendering-driver` command line argument.
2021-09-27 01:07:10 +02:00
virtual void gl_window_make_current(DisplayServer::WindowID p_window_id) override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void window_set_transient(WindowID p_window, WindowID p_parent) override;
Support for transient windows
2020-03-04 16:03:30 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void window_set_min_size(const Size2i p_size, WindowID p_window = MAIN_WINDOW_ID) override;
virtual Size2i window_get_min_size(WindowID p_window = MAIN_WINDOW_ID) const override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void window_set_size(const Size2i p_size, WindowID p_window = MAIN_WINDOW_ID) override;
virtual Size2i window_get_size(WindowID p_window = MAIN_WINDOW_ID) const override;
Rename `window_get_real_size` to `window_get_size_with_decorations`, add `window_get_position_with_decorations`.
2022-11-30 10:28:16 +02:00
virtual Size2i window_get_size_with_decorations(WindowID p_window = MAIN_WINDOW_ID) const override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void window_set_mode(WindowMode p_mode, WindowID p_window = MAIN_WINDOW_ID) override;
virtual WindowMode window_get_mode(WindowID p_window = MAIN_WINDOW_ID) const override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual bool window_is_maximize_allowed(WindowID p_window = MAIN_WINDOW_ID) const override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void window_set_flag(WindowFlags p_flag, bool p_enabled, WindowID p_window = MAIN_WINDOW_ID) override;
virtual bool window_get_flag(WindowFlags p_flag, WindowID p_window = MAIN_WINDOW_ID) const override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void window_request_attention(WindowID p_window = MAIN_WINDOW_ID) override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void window_move_to_foreground(WindowID p_window = MAIN_WINDOW_ID) override;
[DisplayServer] Add method to check if native window is focused.
2023-06-15 10:53:31 +03:00
virtual bool window_is_focused(WindowID p_window = MAIN_WINDOW_ID) const override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual bool window_can_draw(WindowID p_window = MAIN_WINDOW_ID) const override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual bool can_any_window_draw() const override;
Effective DisplayServer separation, rename X11 -> LinuxBSD
2020-03-03 10:36:29 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void window_set_ime_active(const bool p_active, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_ime_position(const Point2i &p_pos, WindowID p_window = MAIN_WINDOW_ID) override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Cleanup and unify keyboard input. - Unify keycode values (secondary label printed on a key), remove unused hardcoded Latin-1 codes. - Unify IME behaviour, add inline composition string display on Windows and X11. - Add key_label (localized label printed on a key) value to the key events, and allow mapping actions to the unshifted Unicode events. - Add support for physical keyboard (Bluetooth or Sidecar) handling on iOS. - Add support for media key handling on macOS. Co-authored-by: Raul Santos <raulsntos@gmail.com>
2022-12-11 01:21:22 +02:00
virtual Point2i ime_get_selection() const override;
virtual String ime_get_text() const override;
Restructure and reimplement vsync options -Add a v-sync mode setting which allows to choose between DISABLED, ON, ADAPTIVE and MAILBOX -Removed the V-Sync via Compositor option
2021-06-19 17:44:59 +02:00
virtual void window_set_vsync_mode(DisplayServer::VSyncMode p_vsync_mode, WindowID p_window = MAIN_WINDOW_ID) override;
virtual DisplayServer::VSyncMode window_get_vsync_mode(WindowID p_vsync_mode) const override;
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void cursor_set_shape(CursorShape p_shape) override;
virtual CursorShape cursor_get_shape() const override;
Remove `RES` and `REF` typedefs in favor of spelled out `Ref<>` These typedefs don't save much typing compared to the full `Ref<Resource>` and `Ref<RefCounted>`, yet they sometimes introduce confusion among new contributors.
2022-05-03 01:43:50 +02:00
virtual void cursor_set_custom_image(const Ref<Resource> &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual int keyboard_get_layout_count() const override;
virtual int keyboard_get_current_layout() const override;
virtual void keyboard_set_current_layout(int p_index) override;
virtual String keyboard_get_layout_language(int p_index) const override;
virtual String keyboard_get_layout_name(int p_index) const override;
Allow for mapping keycodes to current layout
2021-09-17 03:07:59 +02:00
virtual Key keyboard_get_keycode_from_physical(Key p_keycode) const override;
Implement keyboard_get_label_from_physical method.
2023-06-08 09:26:48 +03:00
virtual Key keyboard_get_label_from_physical(Key p_keycode) const override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void process_events() override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void release_rendering_thread() override;
virtual void make_rendering_thread() override;
virtual void swap_buffers() override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void set_context(Context p_context) override;
Effective DisplayServer separation, rename X11 -> LinuxBSD
2020-03-03 10:36:29 -03:00
Modernize Display server to use override keyword
2021-07-16 21:39:13 +02:00
virtual void set_native_icon(const String &p_filename) override;
virtual void set_icon(const Ref<Image> &p_icon) override;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Add support for the custom initial screen for the main window, fix primary screen detection.
2023-01-05 00:00:02 +02:00
static DisplayServer *create_func(const String &p_rendering_driver, WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Error &r_error);
Effective DisplayServer separation, rename X11 -> LinuxBSD
2020-03-03 10:36:29 -03:00
static Vector<String> get_rendering_drivers_func();
static void register_x11_driver();
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
Add support for the custom initial screen for the main window, fix primary screen detection.
2023-01-05 00:00:02 +02:00
DisplayServerX11(const String &p_rendering_driver, WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Error &r_error);
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
~DisplayServerX11();
};
Style: Harmonize header includes in platform ports This applies our existing style guide, and adds a new rule to that style guide for modular components such as platform ports and modules: Includes from the platform port or module should be included with relative paths (relative to the root folder of the modular component, e.g. `platform/linuxbsd/`), in their own section before Godot's "core" includes. The `api` and `export` subfolders also need to be handled as self-contained (and thus use relative paths for their "local" includes) as they are all compiled for each editor platform, without necessarily having the api/export matching platform folder in the include path. E.g. the Linux editor build will compile `platform/android/{api,export}/*.cpp` and those need to use relative includes for it to work.
2023-06-08 14:51:32 +02:00
#endif // X11_ENABLED
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 19:14:37 -03:00
#endif // DISPLAY_SERVER_X11_H
Reference in a new issue Copy permalink