godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/platform/linuxbsd/display_server_x11.h

384 lines
14 KiB
C++
Raw Normal View History

Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
/*************************************************************************/
/* display_server_x11.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
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 🎆
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). */
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +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. */
/*************************************************************************/
#ifndef DISPLAY_SERVER_X11_H
#define DISPLAY_SERVER_X11_H
#ifdef X11_ENABLED
#include "servers/display_server.h"
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 13:19:37 +00:00
#include "core/input/input.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 22:33:38 +00:00
#include "core/templates/local_vector.h"
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00: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 "joypad_linux.h"
#include "servers/audio_server.h"
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 18:21:27 +00:00
#include "servers/rendering_server.h"
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
#if defined(OPENGL_ENABLED)
#include "context_gl_x11.h"
#endif
#if defined(VULKAN_ENABLED)
#include "drivers/vulkan/rendering_device_vulkan.h"
Effective DisplayServer separation, rename X11 -> LinuxBSD
2020-03-03 13:36:29 +00:00
#include "platform/linuxbsd/vulkan_context_x11.h"
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
#endif
#include <X11/Xcursor/Xcursor.h>
#include <X11/Xlib.h>
#include <X11/extensions/XInput2.h>
#include <X11/extensions/Xrandr.h>
#include <X11/keysym.h>
typedef struct _xrr_monitor_info {
Atom name;
Initialize class/struct variables with default values in platform/ and editor/
2020-11-24 09:12:55 +00: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 22:14:37 +00:00
} xrr_monitor_info;
#undef CursorShape
class DisplayServerX11 : public DisplayServer {
//No need to register, it's platform-specific and nothing is added
//GDCLASS(DisplayServerX11, DisplayServer)
Make DisplayServerX11 thread safe
2020-03-07 15:46:50 +00:00
_THREAD_SAFE_CLASS_
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00: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;
Atom requested;
int xdnd_version;
#if defined(OPENGL_ENABLED)
ContextGL_X11 *context_gles2;
#endif
#if defined(VULKAN_ENABLED)
VulkanContextX11 *context_vulkan;
RenderingDeviceVulkan *rendering_device_vulkan;
#endif
struct WindowData {
Window x11_window;
::XIC xic;
Added a Window node, and made it the scene root. Still a lot of work to do.
2020-03-04 01:51:12 +00:00
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
Size2i min_size;
Size2i max_size;
Fixes to X11, still pretty broken
2020-03-25 14:16:19 +00:00
Point2i position;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
Size2i size;
Multiple changes to DisplayServerX11 - Travis: Change x11 to linuxbsd - SCons: Change x11 plataform to linuxbsd - Plugins: Remove ; to avoid fallthrough warning - DisplayServerX11: Implement set_icon - DisplayServerX11: Fix X11 bug when a window was erased from windows map, all the changes from that erased windows are sending to the main window - DisplayServerX11: Reorder create_window commands - DisplayServerX11: Change every Size2 to Size2i and Rect2 to Rect2i where it belongs + More X11 fixes which have been integrated directly back into reduz's original commits while rebasing the branch.
2020-03-12 23:12:34 +00:00
Point2i im_position;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
bool im_active = false;
Open sub-windows as embedded if the OS does not support them
2020-03-14 16:06:39 +00: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 16:36:09 +00: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 22:14:37 +00:00
Support for transient windows
2020-03-04 19:03:30 +00:00
WindowID transient_parent = INVALID_WINDOW_ID;
Set<WindowID> transient_children;
Implemented drag and drop across windows, both OS and embedded.
2020-03-24 23:15:35 +00: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 11:01:49 +00:00
bool menu_type = false;
bool no_focus = false;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
//better to guess on the fly, given WM can change it
//WindowMode mode;
bool fullscreen = false; //OS can't exit from this mode
bool on_top = false;
bool borderless = false;
bool resize_disabled = false;
Vector2i last_position_before_fs;
Ensure embedded mode works again Also implemented application in/out notifications in X11.
2020-07-01 12:27:43 +00:00
bool focused = false;
bool minimized = false;
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 10:00:44 +00:00
unsigned int focus_order = 0;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
};
Map<WindowID, WindowData> windows;
WindowID window_id_counter = MAIN_WINDOW_ID;
Fixes to window style flags
2020-03-14 19:56:37 +00:00
WindowID _create_window(WindowMode p_mode, uint32_t p_flags, const Rect2i &p_rect);
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
String internal_clipboard;
Window xdnd_source_window;
::Display *x11_display;
char *xmbstring;
int xmblen;
unsigned long last_timestamp;
::Time last_keyrelease_time;
::XIM xim;
::XIMStyle xim_style;
static void _xim_destroy_callback(::XIM im, ::XPointer client_data,
::XPointer call_data);
Point2i last_mouse_pos;
bool last_mouse_pos_valid;
Point2i last_click_pos;
uint64_t last_click_ms;
int last_click_button_index;
uint32_t last_button_state;
Ensure embedded mode works again Also implemented application in/out notifications in X11.
2020-07-01 12:27:43 +00:00
bool app_focused = false;
Add a focus out timeout for X11 to less events of this type are received
2020-07-01 19:14:46 +00:00
uint64_t time_since_no_focus = 0;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
struct {
int opcode;
Vector<int> touch_devices;
Map<int, Vector2> absolute_devices;
Fix X11 pressure and tilt values.
2020-04-10 10:41:41 +00:00
Map<int, Vector2> pen_pressure_range;
Map<int, Vector2> pen_tilt_x_range;
Map<int, Vector2> pen_tilt_y_range;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
XIEventMask all_event_mask;
Map<int, Vector2> state;
double pressure;
[Linux/Windows] Set pressure to 1.0f when primary button is pressed and device is not pressure sensitive.
2020-05-03 12:38:58 +00:00
bool pressure_supported;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00: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();
unsigned int _get_mouse_button_state(unsigned int p_x11_button, int p_x11_type);
void _get_key_modifier_state(unsigned int p_x11_state, Ref<InputEventWithModifiers> state);
void _flush_mouse_motion();
MouseMode mouse_mode;
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 10:43:20 +00: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 15:57:54 +00:00
Atom _process_selection_request_target(Atom p_target, Window p_requestor, Atom p_property) const;
void _handle_selection_request_event(XSelectionRequestEvent *p_event) 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 10:43:20 +00: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 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 15:57:54 +00:00
void _clipboard_transfer_ownership(Atom p_source, Window x11_window) const;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
Ensure embedded mode works again Also implemented application in/out notifications in X11.
2020-07-01 12:27:43 +00:00
//bool minimized;
//bool window_has_focus;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
bool do_mouse_warp;
const char *cursor_theme;
int cursor_size;
XcursorImage *img[CURSOR_MAX];
Cursor cursors[CURSOR_MAX];
Cursor null_cursor;
CursorShape current_cursor;
Map<CursorShape, Vector<Variant>> cursors_cache;
bool layered_window;
Effective DisplayServer separation, rename X11 -> LinuxBSD
2020-03-03 13:36:29 +00:00
String rendering_driver;
Ensure embedded mode works again Also implemented application in/out notifications in X11.
2020-07-01 12:27:43 +00:00
//bool window_focused;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
//void set_wm_border(bool p_enabled);
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);
xrr_get_monitors_t xrr_get_monitors;
xrr_free_monitors_t xrr_free_monitors;
void *xrandr_handle;
Bool xrandr_ext_ok;
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 11:29:31 +00:00
bool _window_maximize_check(WindowID p_window, const char *p_atom_name) const;
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 15:27:16 +00:00
void _update_size_hints(WindowID p_window);
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
void _set_wm_fullscreen(WindowID p_window, bool p_enabled);
void _set_wm_maximized(WindowID p_window, bool p_enabled);
Effective DisplayServer separation, rename X11 -> LinuxBSD
2020-03-03 13:36:29 +00:00
void _update_context(WindowData &wd);
Context context = CONTEXT_ENGINE;
Refactored input, goes all via windows now. Also renamed Input to InputFilter because all it does is filter events.
2020-03-04 16:36:09 +00: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 10:43:20 +00: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 12:29:41 +00: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 18:22:13 +00: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 10:43:20 +00: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 15:57:54 +00: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 10:43:20 +00:00
void _poll_events();
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 14:54:36 +00: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 15:57:54 +00: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 10:43:20 +00:00
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
protected:
void _window_changed(XEvent *event);
public:
virtual bool has_feature(Feature p_feature) const;
virtual String get_name() const;
virtual void alert(const String &p_alert, const String &p_title = "ALERT!");
virtual void mouse_set_mode(MouseMode p_mode);
virtual MouseMode mouse_get_mode() const;
virtual void mouse_warp_to_position(const Point2i &p_to);
virtual Point2i mouse_get_position() const;
Add macOS DisplayServer implementation. Change global menu to use Callable, add support for check items and submenus.
2020-03-07 16:02:54 +00:00
virtual Point2i mouse_get_absolute_position() const;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
virtual int mouse_get_button_state() const;
virtual void clipboard_set(const String &p_text);
virtual String clipboard_get() const;
virtual int get_screen_count() const;
virtual Point2i screen_get_position(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
virtual Size2i screen_get_size(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
Popups have also been converted to windows Controls using the old modal API have been replaced to use popups.
2020-03-20 02:32:09 +00:00
virtual Rect2i screen_get_usable_rect(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
virtual int screen_get_dpi(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
virtual bool screen_is_touchscreen(int p_screen = SCREEN_OF_MAIN_WINDOW) const;
Implemented drag and drop across windows, both OS and embedded.
2020-03-24 23:15:35 +00:00
virtual Vector<DisplayServer::WindowID> get_window_list() const;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
virtual WindowID create_sub_window(WindowMode p_mode, uint32_t p_flags, const Rect2i &p_rect = Rect2i());
Re-apply "Fixes for windows in X11 tiling WMs" From PR #38727 which was reverted in #41373 because of regressions in Ubuntu with Gnome. Co-authored-by: Lorenzo Cerqua <lorenzocerqua@tutanota.com>
2020-08-21 07:39:30 +00:00
virtual void show_window(WindowID p_id);
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
virtual void delete_sub_window(WindowID p_id);
Implemented drag and drop across windows, both OS and embedded.
2020-03-24 23:15:35 +00:00
virtual WindowID get_window_at_screen_position(const Point2i &p_position) const;
virtual void window_attach_instance_id(ObjectID p_instance, WindowID p_window = MAIN_WINDOW_ID);
virtual ObjectID window_get_attached_instance_id(WindowID p_window = MAIN_WINDOW_ID) const;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
virtual void window_set_title(const String &p_title, WindowID p_window = MAIN_WINDOW_ID);
Add window click-through support.
2020-06-29 09:31:36 +00:00
virtual void window_set_mouse_passthrough(const Vector<Vector2> &p_region, WindowID p_window = MAIN_WINDOW_ID);
Open sub-windows as embedded if the OS does not support them
2020-03-14 16:06:39 +00:00
virtual void window_set_rect_changed_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID);
Refactored input, goes all via windows now. Also renamed Input to InputFilter because all it does is filter events.
2020-03-04 16:36:09 +00:00
virtual void window_set_window_event_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID);
virtual void window_set_input_event_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID);
virtual void window_set_input_text_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID);
virtual void window_set_drop_files_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID);
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
virtual int window_get_current_screen(WindowID p_window = MAIN_WINDOW_ID) const;
virtual void window_set_current_screen(int p_screen, WindowID p_window = MAIN_WINDOW_ID);
virtual Point2i window_get_position(WindowID p_window = MAIN_WINDOW_ID) const;
virtual void window_set_position(const Point2i &p_position, WindowID p_window = MAIN_WINDOW_ID);
virtual void window_set_max_size(const Size2i p_size, WindowID p_window = MAIN_WINDOW_ID);
virtual Size2i window_get_max_size(WindowID p_window = MAIN_WINDOW_ID) const;
Support for transient windows
2020-03-04 19:03:30 +00:00
virtual void window_set_transient(WindowID p_window, WindowID p_parent);
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
virtual void window_set_min_size(const Size2i p_size, WindowID p_window = MAIN_WINDOW_ID);
virtual Size2i window_get_min_size(WindowID p_window = MAIN_WINDOW_ID) const;
virtual void window_set_size(const Size2i p_size, WindowID p_window = MAIN_WINDOW_ID);
virtual Size2i window_get_size(WindowID p_window = MAIN_WINDOW_ID) const;
virtual Size2i window_get_real_size(WindowID p_window = MAIN_WINDOW_ID) const;
virtual void window_set_mode(WindowMode p_mode, WindowID p_window = MAIN_WINDOW_ID);
virtual WindowMode window_get_mode(WindowID p_window = MAIN_WINDOW_ID) const;
virtual bool window_is_maximize_allowed(WindowID p_window = MAIN_WINDOW_ID) const;
virtual void window_set_flag(WindowFlags p_flag, bool p_enabled, WindowID p_window = MAIN_WINDOW_ID);
virtual bool window_get_flag(WindowFlags p_flag, WindowID p_window = MAIN_WINDOW_ID) const;
virtual void window_request_attention(WindowID p_window = MAIN_WINDOW_ID);
virtual void window_move_to_foreground(WindowID p_window = MAIN_WINDOW_ID);
virtual bool window_can_draw(WindowID p_window = MAIN_WINDOW_ID) const;
Effective DisplayServer separation, rename X11 -> LinuxBSD
2020-03-03 13:36:29 +00:00
virtual bool can_any_window_draw() const;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
virtual void window_set_ime_active(const bool p_active, WindowID p_window = MAIN_WINDOW_ID);
virtual void window_set_ime_position(const Point2i &p_pos, WindowID p_window = MAIN_WINDOW_ID);
virtual void cursor_set_shape(CursorShape p_shape);
virtual CursorShape cursor_get_shape() const;
virtual void cursor_set_custom_image(const RES &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot);
Add keyboard layout enumeration / set / get functions (macOS, Windows, Linux/X11), remove latin variant function.
2020-06-11 09:27:07 +00:00
virtual int keyboard_get_layout_count() const;
virtual int keyboard_get_current_layout() const;
virtual void keyboard_set_current_layout(int p_index);
virtual String keyboard_get_layout_language(int p_index) const;
virtual String keyboard_get_layout_name(int p_index) const;
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
virtual void process_events();
virtual void release_rendering_thread();
virtual void make_rendering_thread();
virtual void swap_buffers();
Effective DisplayServer separation, rename X11 -> LinuxBSD
2020-03-03 13:36:29 +00:00
virtual void set_context(Context p_context);
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
virtual void set_native_icon(const String &p_filename);
virtual void set_icon(const Ref<Image> &p_icon);
Effective DisplayServer separation, rename X11 -> LinuxBSD
2020-03-03 13:36:29 +00:00
static DisplayServer *create_func(const String &p_rendering_driver, WindowMode p_mode, uint32_t p_flags, const Vector2i &p_resolution, Error &r_error);
static Vector<String> get_rendering_drivers_func();
static void register_x11_driver();
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
Effective DisplayServer separation, rename X11 -> LinuxBSD
2020-03-03 13:36:29 +00:00
DisplayServerX11(const String &p_rendering_driver, WindowMode p_mode, uint32_t p_flags, const Vector2i &p_resolution, Error &r_error);
Refactored Input, create DisplayServer and DisplayServerX11
2020-03-01 22:14:37 +00:00
~DisplayServerX11();
};
#endif // X11 enabled
#endif // DISPLAY_SERVER_X11_H