Sara/behaviour-tree-test
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Move DisplayServer enums and typedefs to DisplayServerEnums

Browse source 
This will allow decoupling `display_server.h` from a number of headers in the
codebase which only require those enums and not all the DisplayServer API.
This commit is contained in:
Rémi Verschelde 2026-02-26 12:36:47 +01:00
parent 778cf54dab
commit a447ac95ec
No known key found for this signature in database
GPG key ID: C3336907360768E1
160 changed files with 4584 additions and 4520 deletions
Download patch file Download diff file Expand all files Collapse all files

4
core/config/project_settings.cpp
View file

@ -1756,10 +1756,10 @@ ProjectSettings::ProjectSettings() {
_add_builtin_input_map();
// Keep the enum values in sync with the `DisplayServer::ScreenOrientation` enum.
// Keep the enum values in sync with the `DisplayServerEnums::ScreenOrientation` enum.
custom_prop_info["display/window/handheld/orientation"] = PropertyInfo(Variant::INT, "display/window/handheld/orientation", PROPERTY_HINT_ENUM, "Landscape,Portrait,Reverse Landscape,Reverse Portrait,Sensor Landscape,Sensor Portrait,Sensor");
GLOBAL_DEF("display/window/subwindows/embed_subwindows", true);
// Keep the enum values in sync with the `DisplayServer::VSyncMode` enum.
// Keep the enum values in sync with the `DisplayServerEnums::VSyncMode` enum.
custom_prop_info["display/window/vsync/vsync_mode"] = PropertyInfo(Variant::INT, "display/window/vsync/vsync_mode", PROPERTY_HINT_ENUM, "Disabled,Enabled,Adaptive,Mailbox");
GLOBAL_DEF("display/window/frame_pacing/android/enable_frame_pacing", true);

3
core/input/input.h
View file

@ -41,7 +41,7 @@
class GamepadMotion;
namespace InputClassEnums {
// Keep synced with "DisplayServer::MouseMode" enum.
// Keep synced with DisplayServerEnums::MouseMode enum.
enum MouseMode : int {
MOUSE_MODE_VISIBLE,
MOUSE_MODE_HIDDEN,
@ -51,6 +51,7 @@ enum MouseMode : int {
MOUSE_MODE_MAX,
};
// Keep synced with DisplayServerEnums and Control enums.
#undef CursorShape
enum CursorShape : int {
CURSOR_ARROW,

28
drivers/accesskit/accessibility_server_accesskit.cpp
View file

@ -52,7 +52,7 @@ _FORCE_INLINE_ accesskit_action AccessibilityServerAccessKit::_accessibility_act
return ACCESSKIT_ACTION_CLICK;
}
bool AccessibilityServerAccessKit::window_create(DisplayServer::WindowID p_window_id, void *p_handle) {
bool AccessibilityServerAccessKit::window_create(DisplayServerEnums::WindowID p_window_id, void *p_handle) {
ERR_FAIL_COND_V(windows.has(p_window_id), false);
WindowData &wd = windows[p_window_id];
@ -84,7 +84,7 @@ bool AccessibilityServerAccessKit::window_create(DisplayServer::WindowID p_windo
}
}
void AccessibilityServerAccessKit::window_destroy(DisplayServer::WindowID p_window_id) {
void AccessibilityServerAccessKit::window_destroy(DisplayServerEnums::WindowID p_window_id) {
WindowData *wd = windows.getptr(p_window_id);
ERR_FAIL_NULL(wd);
@ -105,7 +105,7 @@ void AccessibilityServerAccessKit::window_destroy(DisplayServer::WindowID p_wind
}
void AccessibilityServerAccessKit::_accessibility_deactivation_callback(void *p_user_data) {
DisplayServer::WindowID window_id = (DisplayServer::WindowID)(size_t)p_user_data;
DisplayServerEnums::WindowID window_id = (DisplayServerEnums::WindowID)(size_t)p_user_data;
WindowData *wd = static_cast<AccessibilityServerAccessKit *>(get_singleton())->windows.getptr(window_id);
ERR_FAIL_NULL(wd);
@ -126,7 +126,7 @@ void AccessibilityServerAccessKit::_accessibility_deactivation_callback(void *p_
}
void AccessibilityServerAccessKit::_accessibility_action_callback(struct accesskit_action_request *p_request, void *p_user_data) {
DisplayServer::WindowID window_id = (DisplayServer::WindowID)(size_t)p_user_data;
DisplayServerEnums::WindowID window_id = (DisplayServerEnums::WindowID)(size_t)p_user_data;
ERR_FAIL_COND(!static_cast<AccessibilityServerAccessKit *>(get_singleton())->windows.has(window_id));
RID rid = RID::from_uint64(p_request->target);
@ -218,7 +218,7 @@ void AccessibilityServerAccessKit::_accessibility_action_callback(struct accessk
}
accesskit_tree_update *AccessibilityServerAccessKit::_accessibility_initial_tree_update_callback(void *p_user_data) {
DisplayServer::WindowID window_id = (DisplayServer::WindowID)(size_t)p_user_data;
DisplayServerEnums::WindowID window_id = (DisplayServerEnums::WindowID)(size_t)p_user_data;
WindowData *wd = static_cast<AccessibilityServerAccessKit *>(get_singleton())->windows.getptr(window_id);
ERR_FAIL_NULL_V(wd, nullptr);
@ -243,7 +243,7 @@ accesskit_tree_update *AccessibilityServerAccessKit::_accessibility_initial_tree
return tree_update;
}
void AccessibilityServerAccessKit::set_window_callbacks(DisplayServer::WindowID p_window_id, const Callable &p_activate_callable, const Callable &p_deativate_callable) {
void AccessibilityServerAccessKit::set_window_callbacks(DisplayServerEnums::WindowID p_window_id, const Callable &p_activate_callable, const Callable &p_deativate_callable) {
WindowData *wd = static_cast<AccessibilityServerAccessKit *>(get_singleton())->windows.getptr(p_window_id);
ERR_FAIL_NULL(wd);
@ -251,7 +251,7 @@ void AccessibilityServerAccessKit::set_window_callbacks(DisplayServer::WindowID
wd->deactivate = p_deativate_callable;
}
void AccessibilityServerAccessKit::window_activation_completed(DisplayServer::WindowID p_window_id) {
void AccessibilityServerAccessKit::window_activation_completed(DisplayServerEnums::WindowID p_window_id) {
WindowData *wd = static_cast<AccessibilityServerAccessKit *>(get_singleton())->windows.getptr(p_window_id);
if (!wd) {
return;
@ -262,7 +262,7 @@ void AccessibilityServerAccessKit::window_activation_completed(DisplayServer::Wi
wd->initial_update_completed = true;
}
void AccessibilityServerAccessKit::window_deactivation_completed(DisplayServer::WindowID p_window_id) {
void AccessibilityServerAccessKit::window_deactivation_completed(DisplayServerEnums::WindowID p_window_id) {
WindowData *wd = static_cast<AccessibilityServerAccessKit *>(get_singleton())->windows.getptr(p_window_id);
if (!wd) {
return;
@ -286,7 +286,7 @@ void AccessibilityServerAccessKit::window_deactivation_completed(DisplayServer::
wd->initial_update_completed = false;
}
RID AccessibilityServerAccessKit::create_element(DisplayServer::WindowID p_window_id, AccessibilityServerEnums::AccessibilityRole p_role) {
RID AccessibilityServerAccessKit::create_element(DisplayServerEnums::WindowID p_window_id, AccessibilityServerEnums::AccessibilityRole p_role) {
AccessibilityElement *ae = memnew(AccessibilityElement);
ae->role = _accessibility_role(p_role);
ae->window_id = p_window_id;
@ -609,7 +609,7 @@ void AccessibilityServerAccessKit::update_set_focus(const RID &p_id) {
}
}
RID AccessibilityServerAccessKit::get_window_root(DisplayServer::WindowID p_window_id) const {
RID AccessibilityServerAccessKit::get_window_root(DisplayServerEnums::WindowID p_window_id) const {
const WindowData *wd = windows.getptr(p_window_id);
ERR_FAIL_NULL_V(wd, RID());
@ -617,7 +617,7 @@ RID AccessibilityServerAccessKit::get_window_root(DisplayServer::WindowID p_wind
}
accesskit_tree_update *AccessibilityServerAccessKit::_accessibility_build_tree_update(void *p_user_data) {
DisplayServer::WindowID window_id = (DisplayServer::WindowID)(size_t)p_user_data;
DisplayServerEnums::WindowID window_id = (DisplayServerEnums::WindowID)(size_t)p_user_data;
ERR_FAIL_COND_V(!static_cast<AccessibilityServerAccessKit *>(get_singleton())->windows.has(window_id), nullptr);
WindowData &wd = static_cast<AccessibilityServerAccessKit *>(get_singleton())->windows[window_id];
@ -654,7 +654,7 @@ accesskit_tree_update *AccessibilityServerAccessKit::_accessibility_build_tree_u
void AccessibilityServerAccessKit::update_if_active(const Callable &p_callable) {
ERR_FAIL_COND(!p_callable.is_valid());
update_cb = p_callable;
for (KeyValue<DisplayServer::WindowID, WindowData> &window : windows) {
for (KeyValue<DisplayServerEnums::WindowID, WindowData> &window : windows) {
#ifdef WINDOWS_ENABLED
accesskit_windows_queued_events *events = accesskit_windows_subclassing_adapter_update_if_active(window.value.adapter, _accessibility_build_tree_update, (void *)(size_t)window.key);
if (events) {
@ -691,7 +691,7 @@ _FORCE_INLINE_ void AccessibilityServerAccessKit::_ensure_node(const RID &p_id,
}
}
void AccessibilityServerAccessKit::set_window_rect(DisplayServer::WindowID p_window_id, const Rect2 &p_rect_out, const Rect2 &p_rect_in) {
void AccessibilityServerAccessKit::set_window_rect(DisplayServerEnums::WindowID p_window_id, const Rect2 &p_rect_out, const Rect2 &p_rect_in) {
#ifdef LINUXBSD_ENABLED
const WindowData *wd = windows.getptr(p_window_id);
ERR_FAIL_NULL(wd);
@ -702,7 +702,7 @@ void AccessibilityServerAccessKit::set_window_rect(DisplayServer::WindowID p_win
#endif
}
void AccessibilityServerAccessKit::set_window_focused(DisplayServer::WindowID p_window_id, bool p_focused) {
void AccessibilityServerAccessKit::set_window_focused(DisplayServerEnums::WindowID p_window_id, bool p_focused) {
const WindowData *wd = windows.getptr(p_window_id);
ERR_FAIL_NULL(wd);

22
drivers/accesskit/accessibility_server_accesskit.h
View file

@ -57,7 +57,7 @@ class AccessibilityServerAccessKit : public AccessibilityServer {
struct AccessibilityElement {
HashMap<accesskit_action, Callable> actions;
DisplayServer::WindowID window_id = DisplayServer::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID window_id = DisplayServerEnums::INVALID_WINDOW_ID;
RID parent;
LocalVector<RID> children;
Vector3i run;
@ -94,7 +94,7 @@ class AccessibilityServerAccessKit : public AccessibilityServer {
RID focus;
HashMap<DisplayServer::WindowID, WindowData> windows;
HashMap<DisplayServerEnums::WindowID, WindowData> windows;
HashMap<AccessibilityServerEnums::AccessibilityRole, accesskit_role> role_map;
HashMap<AccessibilityServerEnums::AccessibilityAction, accesskit_action> action_map;
@ -116,10 +116,10 @@ class AccessibilityServerAccessKit : public AccessibilityServer {
public:
bool is_supported() const override { return true; }
bool window_create(DisplayServer::WindowID p_window_id, void *p_handle) override;
void window_destroy(DisplayServer::WindowID p_window_id) override;
bool window_create(DisplayServerEnums::WindowID p_window_id, void *p_handle) override;
void window_destroy(DisplayServerEnums::WindowID p_window_id) override;
RID create_element(DisplayServer::WindowID p_window_id, AccessibilityServerEnums::AccessibilityRole p_role) override;
RID create_element(DisplayServerEnums::WindowID p_window_id, AccessibilityServerEnums::AccessibilityRole p_role) override;
RID create_sub_element(const RID &p_parent_rid, AccessibilityServerEnums::AccessibilityRole p_role, int p_insert_pos = -1) override;
virtual RID create_sub_text_edit_elements(const RID &p_parent_rid, const RID &p_shaped_text, float p_min_height, int p_insert_pos = -1, bool p_is_last_line = false) override;
bool has_element(const RID &p_id) const override;
@ -131,13 +131,13 @@ public:
void update_if_active(const Callable &p_callable) override;
void update_set_focus(const RID &p_id) override;
RID get_window_root(DisplayServer::WindowID p_window_id) const override;
RID get_window_root(DisplayServerEnums::WindowID p_window_id) const override;
void set_window_rect(DisplayServer::WindowID p_window_id, const Rect2 &p_rect_out, const Rect2 &p_rect_in) override;
void set_window_focused(DisplayServer::WindowID p_window_id, bool p_focused) override;
void set_window_callbacks(DisplayServer::WindowID p_window_id, const Callable &p_activate_callable, const Callable &p_deativate_callable) override;
void window_activation_completed(DisplayServer::WindowID p_window_id) override;
void window_deactivation_completed(DisplayServer::WindowID p_window_id) override;
void set_window_rect(DisplayServerEnums::WindowID p_window_id, const Rect2 &p_rect_out, const Rect2 &p_rect_in) override;
void set_window_focused(DisplayServerEnums::WindowID p_window_id, bool p_focused) override;
void set_window_callbacks(DisplayServerEnums::WindowID p_window_id, const Callable &p_activate_callable, const Callable &p_deativate_callable) override;
void window_activation_completed(DisplayServerEnums::WindowID p_window_id) override;
void window_deactivation_completed(DisplayServerEnums::WindowID p_window_id) override;
void update_set_role(const RID &p_id, AccessibilityServerEnums::AccessibilityRole p_role) override;
void update_set_name(const RID &p_id, const String &p_name) override;

112
drivers/apple_embedded/display_server_apple_embedded.h
View file

@ -71,7 +71,7 @@ class DisplayServerAppleEmbedded : public DisplayServer {
id tts = nullptr;
DisplayServer::ScreenOrientation screen_orientation;
DisplayServerEnums::ScreenOrientation screen_orientation;
ObjectID window_attached_instance_id;
@ -98,7 +98,7 @@ protected:
virtual float _screen_current_edr_headroom() const { return 1.0f; }
float hardware_reference_luminance_nits = 100.0f;
DisplayServerAppleEmbedded(const String &p_rendering_driver, DisplayServer::WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error);
DisplayServerAppleEmbedded(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
~DisplayServerAppleEmbedded();
public:
@ -112,16 +112,16 @@ public:
virtual void process_events() override;
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;
virtual void window_set_rect_changed_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_window_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_input_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_input_text_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_drop_files_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
static void _dispatch_input_events(const Ref<InputEvent> &p_event);
void send_input_event(const Ref<InputEvent> &p_event) const;
void send_input_text(const String &p_text) const;
void send_window_event(DisplayServer::WindowEvent p_event) const;
void send_window_event(DisplayServerEnums::WindowEvent p_event) const;
void _window_callback(const Callable &p_callable, const Variant &p_arg) const;
void emit_system_theme_changed();
@ -148,7 +148,7 @@ public:
// MARK: -
virtual bool has_feature(Feature p_feature) const override;
virtual bool has_feature(DisplayServerEnums::Feature p_feature) const override;
virtual bool tts_is_speaking() const override;
virtual bool tts_is_paused() const override;
@ -167,67 +167,67 @@ public:
virtual int get_screen_count() const override;
virtual int get_primary_screen() const override;
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 Point2i screen_get_position(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Size2i screen_get_size(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Rect2i screen_get_usable_rect(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Vector<DisplayServer::WindowID> get_window_list() const override;
virtual Vector<DisplayServerEnums::WindowID> get_window_list() const override;
virtual WindowID get_window_at_screen_position(const Point2i &p_position) const override;
virtual DisplayServerEnums::WindowID get_window_at_screen_position(const Point2i &p_position) const override;
virtual int64_t window_get_native_handle(HandleType p_handle_type, WindowID p_window = MAIN_WINDOW_ID) const override;
virtual int64_t window_get_native_handle(DisplayServerEnums::HandleType p_handle_type, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_attach_instance_id(ObjectID p_instance, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual ObjectID window_get_attached_instance_id(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_title(const String &p_title, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_title(const String &p_title, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
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;
virtual int window_get_current_screen(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_current_screen(int p_screen, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Point2i window_get_position(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual Point2i window_get_position_with_decorations(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_position(const Point2i &p_position, WindowID p_window = MAIN_WINDOW_ID) override;
virtual Point2i window_get_position(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual Point2i window_get_position_with_decorations(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_position(const Point2i &p_position, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_transient(WindowID p_window, WindowID p_parent) override;
virtual void window_set_transient(DisplayServerEnums::WindowID p_window, DisplayServerEnums::WindowID p_parent) override;
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;
virtual void window_set_max_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_max_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_min_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_min_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual Size2i window_get_size_with_decorations(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual Size2i window_get_size_with_decorations(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_mode(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual DisplayServerEnums::WindowMode window_get_mode(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool window_is_maximize_allowed(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual bool window_is_maximize_allowed(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_flag(DisplayServerEnums::WindowFlags p_flag, bool p_enabled, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_get_flag(DisplayServerEnums::WindowFlags p_flag, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_request_attention(WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_move_to_foreground(WindowID p_window = MAIN_WINDOW_ID) override;
virtual bool window_is_focused(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_request_attention(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_move_to_foreground(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_is_focused(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual float screen_get_max_scale() const override;
virtual void screen_set_orientation(DisplayServer::ScreenOrientation p_orientation, int p_screen) override;
virtual DisplayServer::ScreenOrientation screen_get_orientation(int p_screen) const override;
virtual void screen_set_orientation(DisplayServerEnums::ScreenOrientation p_orientation, int p_screen) override;
virtual DisplayServerEnums::ScreenOrientation screen_get_orientation(int p_screen) const override;
virtual bool window_can_draw(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual bool window_can_draw(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool can_any_window_draw() const override;
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;
virtual void window_set_vsync_mode(DisplayServerEnums::VSyncMode p_vsync_mode, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual DisplayServerEnums::VSyncMode window_get_vsync_mode(DisplayServerEnums::WindowID p_vsync_mode) const override;
virtual bool is_touchscreen_available() const override;
virtual void virtual_keyboard_show(const String &p_existing_text, const Rect2 &p_screen_rect, VirtualKeyboardType p_type, int p_max_length, int p_cursor_start, int p_cursor_end) override;
virtual void virtual_keyboard_show(const String &p_existing_text, const Rect2 &p_screen_rect, DisplayServerEnums::VirtualKeyboardType p_type, int p_max_length, int p_cursor_start, int p_cursor_end) override;
virtual void virtual_keyboard_hide() override;
void virtual_keyboard_set_height(int height);
@ -243,20 +243,20 @@ public:
// MARK: - HDR / EDR
void current_edr_headroom_changed();
virtual bool window_is_hdr_output_supported(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_request_hdr_output(const bool p_enabled, WindowID p_window = MAIN_WINDOW_ID) override;
virtual bool window_is_hdr_output_requested(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual bool window_is_hdr_output_enabled(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual bool window_is_hdr_output_supported(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_request_hdr_output(const bool p_enabled, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_is_hdr_output_requested(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool window_is_hdr_output_enabled(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_hdr_output_reference_luminance(const float p_reference_luminance, WindowID p_window = MAIN_WINDOW_ID) override;
virtual float window_get_hdr_output_reference_luminance(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual float window_get_hdr_output_current_reference_luminance(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_hdr_output_reference_luminance(const float p_reference_luminance, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual float window_get_hdr_output_reference_luminance(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual float window_get_hdr_output_current_reference_luminance(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_hdr_output_max_luminance(const float p_max_luminance, WindowID p_window = MAIN_WINDOW_ID) override;
virtual float window_get_hdr_output_max_luminance(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual float window_get_hdr_output_current_max_luminance(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_hdr_output_max_luminance(const float p_max_luminance, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual float window_get_hdr_output_max_luminance(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual float window_get_hdr_output_current_max_luminance(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual float window_get_output_max_linear_value(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual float window_get_output_max_linear_value(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
void resize_window(CGSize size);
virtual void swap_buffers() override {}

212
drivers/apple_embedded/display_server_apple_embedded.mm
View file

@ -52,7 +52,7 @@ DisplayServerAppleEmbedded *DisplayServerAppleEmbedded::get_singleton() {
return (DisplayServerAppleEmbedded *)DisplayServer::get_singleton();
}
DisplayServerAppleEmbedded::DisplayServerAppleEmbedded(const String &p_rendering_driver, WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error) {
DisplayServerAppleEmbedded::DisplayServerAppleEmbedded(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error) {
KeyMappingAppleEmbedded::initialize();
rendering_driver = p_rendering_driver;
@ -129,7 +129,7 @@ DisplayServerAppleEmbedded::DisplayServerAppleEmbedded(const String &p_rendering
}
if (rendering_context) {
if (rendering_context->window_create(MAIN_WINDOW_ID, &wpd) != OK) {
if (rendering_context->window_create(DisplayServerEnums::MAIN_WINDOW_ID, &wpd) != OK) {
ERR_PRINT(vformat("Failed to create %s window.", rendering_driver));
memdelete(rendering_context);
rendering_context = nullptr;
@ -138,18 +138,18 @@ DisplayServerAppleEmbedded::DisplayServerAppleEmbedded(const String &p_rendering
}
Size2i size = Size2i(layer.bounds.size.width, layer.bounds.size.height) * screen_get_max_scale();
rendering_context->window_set_size(MAIN_WINDOW_ID, size.width, size.height);
rendering_context->window_set_vsync_mode(MAIN_WINDOW_ID, p_vsync_mode);
rendering_context->window_set_size(DisplayServerEnums::MAIN_WINDOW_ID, size.width, size.height);
rendering_context->window_set_vsync_mode(DisplayServerEnums::MAIN_WINDOW_ID, p_vsync_mode);
rendering_device = memnew(RenderingDevice);
if (rendering_device->initialize(rendering_context, MAIN_WINDOW_ID) != OK) {
if (rendering_device->initialize(rendering_context, DisplayServerEnums::MAIN_WINDOW_ID) != OK) {
rendering_device = nullptr;
memdelete(rendering_context);
rendering_context = nullptr;
r_error = ERR_UNAVAILABLE;
return;
}
rendering_device->screen_create(MAIN_WINDOW_ID);
rendering_device->screen_create(DisplayServerEnums::MAIN_WINDOW_ID);
RendererCompositorRD::make_current();
has_made_render_compositor_current = true;
@ -187,13 +187,13 @@ DisplayServerAppleEmbedded::~DisplayServerAppleEmbedded() {
#if defined(RD_ENABLED)
if (rendering_device) {
rendering_device->screen_free(MAIN_WINDOW_ID);
rendering_device->screen_free(DisplayServerEnums::MAIN_WINDOW_ID);
memdelete(rendering_device);
rendering_device = nullptr;
}
if (rendering_context) {
rendering_context->window_destroy(MAIN_WINDOW_ID);
rendering_context->window_destroy(DisplayServerEnums::MAIN_WINDOW_ID);
memdelete(rendering_context);
rendering_context = nullptr;
}
@ -220,22 +220,22 @@ Vector<String> DisplayServerAppleEmbedded::get_rendering_drivers_func() {
// MARK: Events
void DisplayServerAppleEmbedded::window_set_rect_changed_callback(const Callable &p_callable, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_rect_changed_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
window_resize_callback = p_callable;
}
void DisplayServerAppleEmbedded::window_set_window_event_callback(const Callable &p_callable, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_window_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
window_event_callback = p_callable;
}
void DisplayServerAppleEmbedded::window_set_input_event_callback(const Callable &p_callable, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_input_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
input_event_callback = p_callable;
}
void DisplayServerAppleEmbedded::window_set_input_text_callback(const Callable &p_callable, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_input_text_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
input_text_callback = p_callable;
}
void DisplayServerAppleEmbedded::window_set_drop_files_callback(const Callable &p_callable, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_drop_files_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
// Probably not supported for iOS
}
@ -255,7 +255,7 @@ void DisplayServerAppleEmbedded::send_input_text(const String &p_text) const {
_window_callback(input_text_callback, p_text);
}
void DisplayServerAppleEmbedded::send_window_event(DisplayServer::WindowEvent p_event) const {
void DisplayServerAppleEmbedded::send_window_event(DisplayServerEnums::WindowEvent p_event) const {
_window_callback(window_event_callback, int(p_event));
}
@ -354,34 +354,34 @@ void DisplayServerAppleEmbedded::update_gyroscope(const Vector3 &p_gyroscope) {
// MARK: -
bool DisplayServerAppleEmbedded::has_feature(Feature p_feature) const {
bool DisplayServerAppleEmbedded::has_feature(DisplayServerEnums::Feature p_feature) const {
switch (p_feature) {
#ifndef DISABLE_DEPRECATED
case FEATURE_GLOBAL_MENU: {
case DisplayServerEnums::FEATURE_GLOBAL_MENU: {
return (native_menu && native_menu->has_feature(NativeMenu::FEATURE_GLOBAL_MENU));
} break;
#endif
// case FEATURE_CURSOR_SHAPE:
// case FEATURE_CUSTOM_CURSOR_SHAPE:
// case FEATURE_HIDPI:
// case FEATURE_ICON:
// case FEATURE_IME:
// case FEATURE_MOUSE:
// case FEATURE_MOUSE_WARP:
// case FEATURE_NATIVE_DIALOG:
// case FEATURE_NATIVE_DIALOG_INPUT:
// case FEATURE_NATIVE_DIALOG_FILE:
// case FEATURE_NATIVE_DIALOG_FILE_EXTRA:
// case FEATURE_NATIVE_DIALOG_FILE_MIME:
// case FEATURE_NATIVE_ICON:
// case FEATURE_WINDOW_TRANSPARENCY:
case FEATURE_CLIPBOARD:
case FEATURE_HDR_OUTPUT:
case FEATURE_KEEP_SCREEN_ON:
case FEATURE_ORIENTATION:
case FEATURE_TOUCHSCREEN:
case FEATURE_VIRTUAL_KEYBOARD:
case FEATURE_TEXT_TO_SPEECH:
// case DisplayServerEnums::FEATURE_CURSOR_SHAPE:
// case DisplayServerEnums::FEATURE_CUSTOM_CURSOR_SHAPE:
// case DisplayServerEnums::FEATURE_HIDPI:
// case DisplayServerEnums::FEATURE_ICON:
// case DisplayServerEnums::FEATURE_IME:
// case DisplayServerEnums::FEATURE_MOUSE:
// case DisplayServerEnums::FEATURE_MOUSE_WARP:
// case DisplayServerEnums::FEATURE_NATIVE_DIALOG:
// case DisplayServerEnums::FEATURE_NATIVE_DIALOG_INPUT:
// case DisplayServerEnums::FEATURE_NATIVE_DIALOG_FILE:
// case DisplayServerEnums::FEATURE_NATIVE_DIALOG_FILE_EXTRA:
// case DisplayServerEnums::FEATURE_NATIVE_DIALOG_FILE_MIME:
// case DisplayServerEnums::FEATURE_NATIVE_ICON:
// case DisplayServerEnums::FEATURE_WINDOW_TRANSPARENCY:
case DisplayServerEnums::FEATURE_CLIPBOARD:
case DisplayServerEnums::FEATURE_HDR_OUTPUT:
case DisplayServerEnums::FEATURE_KEEP_SCREEN_ON:
case DisplayServerEnums::FEATURE_ORIENTATION:
case DisplayServerEnums::FEATURE_TOUCHSCREEN:
case DisplayServerEnums::FEATURE_VIRTUAL_KEYBOARD:
case DisplayServerEnums::FEATURE_TEXT_TO_SPEECH:
return true;
default:
return false;
@ -529,26 +529,26 @@ Rect2i DisplayServerAppleEmbedded::screen_get_usable_rect(int p_screen) const {
return Rect2i(screen_get_position(p_screen), screen_get_size(p_screen));
}
Vector<DisplayServer::WindowID> DisplayServerAppleEmbedded::get_window_list() const {
Vector<DisplayServer::WindowID> list;
list.push_back(MAIN_WINDOW_ID);
Vector<DisplayServerEnums::WindowID> DisplayServerAppleEmbedded::get_window_list() const {
Vector<DisplayServerEnums::WindowID> list;
list.push_back(DisplayServerEnums::MAIN_WINDOW_ID);
return list;
}
DisplayServer::WindowID DisplayServerAppleEmbedded::get_window_at_screen_position(const Point2i &p_position) const {
return MAIN_WINDOW_ID;
DisplayServerEnums::WindowID DisplayServerAppleEmbedded::get_window_at_screen_position(const Point2i &p_position) const {
return DisplayServerEnums::MAIN_WINDOW_ID;
}
int64_t DisplayServerAppleEmbedded::window_get_native_handle(HandleType p_handle_type, WindowID p_window) const {
ERR_FAIL_COND_V(p_window != MAIN_WINDOW_ID, 0);
int64_t DisplayServerAppleEmbedded::window_get_native_handle(DisplayServerEnums::HandleType p_handle_type, DisplayServerEnums::WindowID p_window) const {
ERR_FAIL_COND_V(p_window != DisplayServerEnums::MAIN_WINDOW_ID, 0);
switch (p_handle_type) {
case DISPLAY_HANDLE: {
case DisplayServerEnums::DISPLAY_HANDLE: {
return 0; // Not supported.
}
case WINDOW_HANDLE: {
case DisplayServerEnums::WINDOW_HANDLE: {
return (int64_t)GDTAppDelegateService.viewController;
}
case WINDOW_VIEW: {
case DisplayServerEnums::WINDOW_VIEW: {
return (int64_t)GDTAppDelegateService.viewController.godotView;
}
default: {
@ -557,109 +557,109 @@ int64_t DisplayServerAppleEmbedded::window_get_native_handle(HandleType p_handle
}
}
void DisplayServerAppleEmbedded::window_attach_instance_id(ObjectID p_instance, WindowID p_window) {
void DisplayServerAppleEmbedded::window_attach_instance_id(ObjectID p_instance, DisplayServerEnums::WindowID p_window) {
window_attached_instance_id = p_instance;
}
ObjectID DisplayServerAppleEmbedded::window_get_attached_instance_id(WindowID p_window) const {
ObjectID DisplayServerAppleEmbedded::window_get_attached_instance_id(DisplayServerEnums::WindowID p_window) const {
return window_attached_instance_id;
}
void DisplayServerAppleEmbedded::window_set_title(const String &p_title, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_title(const String &p_title, DisplayServerEnums::WindowID p_window) {
// Probably not supported for iOS
}
int DisplayServerAppleEmbedded::window_get_current_screen(WindowID p_window) const {
ERR_FAIL_COND_V(p_window != MAIN_WINDOW_ID, INVALID_SCREEN);
int DisplayServerAppleEmbedded::window_get_current_screen(DisplayServerEnums::WindowID p_window) const {
ERR_FAIL_COND_V(p_window != DisplayServerEnums::MAIN_WINDOW_ID, DisplayServerEnums::INVALID_SCREEN);
return 0;
}
void DisplayServerAppleEmbedded::window_set_current_screen(int p_screen, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_current_screen(int p_screen, DisplayServerEnums::WindowID p_window) {
// Probably not supported for iOS
}
Point2i DisplayServerAppleEmbedded::window_get_position(WindowID p_window) const {
Point2i DisplayServerAppleEmbedded::window_get_position(DisplayServerEnums::WindowID p_window) const {
return Point2i();
}
Point2i DisplayServerAppleEmbedded::window_get_position_with_decorations(WindowID p_window) const {
Point2i DisplayServerAppleEmbedded::window_get_position_with_decorations(DisplayServerEnums::WindowID p_window) const {
return Point2i();
}
void DisplayServerAppleEmbedded::window_set_position(const Point2i &p_position, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_position(const Point2i &p_position, DisplayServerEnums::WindowID p_window) {
// Probably not supported for single window iOS app
}
void DisplayServerAppleEmbedded::window_set_transient(WindowID p_window, WindowID p_parent) {
void DisplayServerAppleEmbedded::window_set_transient(DisplayServerEnums::WindowID p_window, DisplayServerEnums::WindowID p_parent) {
// Probably not supported for iOS
}
void DisplayServerAppleEmbedded::window_set_max_size(const Size2i p_size, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_max_size(const Size2i p_size, DisplayServerEnums::WindowID p_window) {
// Probably not supported for iOS
}
Size2i DisplayServerAppleEmbedded::window_get_max_size(WindowID p_window) const {
Size2i DisplayServerAppleEmbedded::window_get_max_size(DisplayServerEnums::WindowID p_window) const {
return Size2i();
}
void DisplayServerAppleEmbedded::window_set_min_size(const Size2i p_size, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_min_size(const Size2i p_size, DisplayServerEnums::WindowID p_window) {
// Probably not supported for iOS
}
Size2i DisplayServerAppleEmbedded::window_get_min_size(WindowID p_window) const {
Size2i DisplayServerAppleEmbedded::window_get_min_size(DisplayServerEnums::WindowID p_window) const {
return Size2i();
}
void DisplayServerAppleEmbedded::window_set_size(const Size2i p_size, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_size(const Size2i p_size, DisplayServerEnums::WindowID p_window) {
// Probably not supported for iOS
}
Size2i DisplayServerAppleEmbedded::window_get_size(WindowID p_window) const {
Size2i DisplayServerAppleEmbedded::window_get_size(DisplayServerEnums::WindowID p_window) const {
CGRect viewBounds = GDTAppDelegateService.viewController.view.bounds;
return Size2i(viewBounds.size.width, viewBounds.size.height) * screen_get_max_scale();
}
Size2i DisplayServerAppleEmbedded::window_get_size_with_decorations(WindowID p_window) const {
Size2i DisplayServerAppleEmbedded::window_get_size_with_decorations(DisplayServerEnums::WindowID p_window) const {
return window_get_size(p_window);
}
void DisplayServerAppleEmbedded::window_set_mode(WindowMode p_mode, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_mode(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::WindowID p_window) {
// Probably not supported for iOS
}
DisplayServer::WindowMode DisplayServerAppleEmbedded::window_get_mode(WindowID p_window) const {
return WindowMode::WINDOW_MODE_FULLSCREEN;
DisplayServerEnums::WindowMode DisplayServerAppleEmbedded::window_get_mode(DisplayServerEnums::WindowID p_window) const {
return DisplayServerEnums::WindowMode::WINDOW_MODE_FULLSCREEN;
}
bool DisplayServerAppleEmbedded::window_is_maximize_allowed(WindowID p_window) const {
bool DisplayServerAppleEmbedded::window_is_maximize_allowed(DisplayServerEnums::WindowID p_window) const {
return false;
}
void DisplayServerAppleEmbedded::window_set_flag(WindowFlags p_flag, bool p_enabled, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_flag(DisplayServerEnums::WindowFlags p_flag, bool p_enabled, DisplayServerEnums::WindowID p_window) {
// Probably not supported for iOS
}
bool DisplayServerAppleEmbedded::window_get_flag(WindowFlags p_flag, WindowID p_window) const {
bool DisplayServerAppleEmbedded::window_get_flag(DisplayServerEnums::WindowFlags p_flag, DisplayServerEnums::WindowID p_window) const {
return false;
}
void DisplayServerAppleEmbedded::window_request_attention(WindowID p_window) {
void DisplayServerAppleEmbedded::window_request_attention(DisplayServerEnums::WindowID p_window) {
// Probably not supported for iOS
}
void DisplayServerAppleEmbedded::window_move_to_foreground(WindowID p_window) {
void DisplayServerAppleEmbedded::window_move_to_foreground(DisplayServerEnums::WindowID p_window) {
// Probably not supported for iOS
}
bool DisplayServerAppleEmbedded::window_is_focused(WindowID p_window) const {
bool DisplayServerAppleEmbedded::window_is_focused(DisplayServerEnums::WindowID p_window) const {
return true;
}
float DisplayServerAppleEmbedded::screen_get_max_scale() const {
return screen_get_scale(SCREEN_OF_MAIN_WINDOW);
return screen_get_scale(DisplayServerEnums::SCREEN_OF_MAIN_WINDOW);
}
void DisplayServerAppleEmbedded::screen_set_orientation(DisplayServer::ScreenOrientation p_orientation, int p_screen) {
void DisplayServerAppleEmbedded::screen_set_orientation(DisplayServerEnums::ScreenOrientation p_orientation, int p_screen) {
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX(p_screen, screen_count);
@ -675,15 +675,15 @@ void DisplayServerAppleEmbedded::screen_set_orientation(DisplayServer::ScreenOri
#endif
}
DisplayServer::ScreenOrientation DisplayServerAppleEmbedded::screen_get_orientation(int p_screen) const {
DisplayServerEnums::ScreenOrientation DisplayServerAppleEmbedded::screen_get_orientation(int p_screen) const {
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, SCREEN_LANDSCAPE);
ERR_FAIL_INDEX_V(p_screen, screen_count, DisplayServerEnums::SCREEN_LANDSCAPE);
return screen_orientation;
}
bool DisplayServerAppleEmbedded::window_can_draw(WindowID p_window) const {
bool DisplayServerAppleEmbedded::window_can_draw(DisplayServerEnums::WindowID p_window) const {
return true;
}
@ -705,37 +705,37 @@ _FORCE_INLINE_ int _convert_utf32_offset_to_utf16(const String &p_existing_text,
return limit;
}
void DisplayServerAppleEmbedded::virtual_keyboard_show(const String &p_existing_text, const Rect2 &p_screen_rect, VirtualKeyboardType p_type, int p_max_length, int p_cursor_start, int p_cursor_end) {
void DisplayServerAppleEmbedded::virtual_keyboard_show(const String &p_existing_text, const Rect2 &p_screen_rect, DisplayServerEnums::VirtualKeyboardType p_type, int p_max_length, int p_cursor_start, int p_cursor_end) {
NSString *existingString = [[NSString alloc] initWithUTF8String:p_existing_text.utf8().get_data()];
GDTAppDelegateService.viewController.keyboardView.keyboardType = UIKeyboardTypeDefault;
GDTAppDelegateService.viewController.keyboardView.textContentType = nil;
switch (p_type) {
case KEYBOARD_TYPE_DEFAULT: {
case DisplayServerEnums::KEYBOARD_TYPE_DEFAULT: {
GDTAppDelegateService.viewController.keyboardView.keyboardType = UIKeyboardTypeDefault;
} break;
case KEYBOARD_TYPE_MULTILINE: {
case DisplayServerEnums::KEYBOARD_TYPE_MULTILINE: {
GDTAppDelegateService.viewController.keyboardView.keyboardType = UIKeyboardTypeDefault;
} break;
case KEYBOARD_TYPE_NUMBER: {
case DisplayServerEnums::KEYBOARD_TYPE_NUMBER: {
GDTAppDelegateService.viewController.keyboardView.keyboardType = UIKeyboardTypeNumberPad;
} break;
case KEYBOARD_TYPE_NUMBER_DECIMAL: {
case DisplayServerEnums::KEYBOARD_TYPE_NUMBER_DECIMAL: {
GDTAppDelegateService.viewController.keyboardView.keyboardType = UIKeyboardTypeDecimalPad;
} break;
case KEYBOARD_TYPE_PHONE: {
case DisplayServerEnums::KEYBOARD_TYPE_PHONE: {
GDTAppDelegateService.viewController.keyboardView.keyboardType = UIKeyboardTypePhonePad;
GDTAppDelegateService.viewController.keyboardView.textContentType = UITextContentTypeTelephoneNumber;
} break;
case KEYBOARD_TYPE_EMAIL_ADDRESS: {
case DisplayServerEnums::KEYBOARD_TYPE_EMAIL_ADDRESS: {
GDTAppDelegateService.viewController.keyboardView.keyboardType = UIKeyboardTypeEmailAddress;
GDTAppDelegateService.viewController.keyboardView.textContentType = UITextContentTypeEmailAddress;
} break;
case KEYBOARD_TYPE_PASSWORD: {
case DisplayServerEnums::KEYBOARD_TYPE_PASSWORD: {
GDTAppDelegateService.viewController.keyboardView.keyboardType = UIKeyboardTypeDefault;
GDTAppDelegateService.viewController.keyboardView.textContentType = UITextContentTypePassword;
} break;
case KEYBOARD_TYPE_URL: {
case DisplayServerEnums::KEYBOARD_TYPE_URL: {
GDTAppDelegateService.viewController.keyboardView.keyboardType = UIKeyboardTypeWebSearch;
GDTAppDelegateService.viewController.keyboardView.textContentType = UITextContentTypeURL;
} break;
@ -794,7 +794,7 @@ void DisplayServerAppleEmbedded::resize_window(CGSize viewSize) {
#if defined(RD_ENABLED)
if (rendering_context) {
rendering_context->window_set_size(MAIN_WINDOW_ID, size.x, size.y);
rendering_context->window_set_size(DisplayServerEnums::MAIN_WINDOW_ID, size.x, size.y);
}
#endif
@ -802,7 +802,7 @@ void DisplayServerAppleEmbedded::resize_window(CGSize viewSize) {
_window_callback(window_resize_callback, resize_rect);
}
void DisplayServerAppleEmbedded::window_set_vsync_mode(DisplayServer::VSyncMode p_vsync_mode, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_vsync_mode(DisplayServerEnums::VSyncMode p_vsync_mode, DisplayServerEnums::WindowID p_window) {
_THREAD_SAFE_METHOD_
#if defined(RD_ENABLED)
if (rendering_context) {
@ -811,14 +811,14 @@ void DisplayServerAppleEmbedded::window_set_vsync_mode(DisplayServer::VSyncMode
#endif
}
DisplayServer::VSyncMode DisplayServerAppleEmbedded::window_get_vsync_mode(WindowID p_window) const {
DisplayServerEnums::VSyncMode DisplayServerAppleEmbedded::window_get_vsync_mode(DisplayServerEnums::WindowID p_window) const {
_THREAD_SAFE_METHOD_
#if defined(RD_ENABLED)
if (rendering_context) {
return rendering_context->window_get_vsync_mode(p_window);
}
#endif
return DisplayServer::VSYNC_ENABLED;
return DisplayServerEnums::VSYNC_ENABLED;
}
// MARK: - HDR / EDR
@ -830,15 +830,15 @@ void DisplayServerAppleEmbedded::_update_hdr_output() {
}
bool desired = edr_requested && _screen_hdr_is_supported();
if (rendering_context->window_get_hdr_output_enabled(MAIN_WINDOW_ID) != desired) {
rendering_context->window_set_hdr_output_enabled(MAIN_WINDOW_ID, desired);
if (rendering_context->window_get_hdr_output_enabled(DisplayServerEnums::MAIN_WINDOW_ID) != desired) {
rendering_context->window_set_hdr_output_enabled(DisplayServerEnums::MAIN_WINDOW_ID, desired);
}
float reference_luminance = _calculate_current_reference_luminance();
rendering_context->window_set_hdr_output_reference_luminance(MAIN_WINDOW_ID, reference_luminance);
rendering_context->window_set_hdr_output_reference_luminance(DisplayServerEnums::MAIN_WINDOW_ID, reference_luminance);
float max_luminance = _screen_potential_edr_headroom() * hardware_reference_luminance_nits;
rendering_context->window_set_hdr_output_max_luminance(MAIN_WINDOW_ID, max_luminance);
rendering_context->window_set_hdr_output_max_luminance(DisplayServerEnums::MAIN_WINDOW_ID, max_luminance);
#endif
}
@ -846,7 +846,7 @@ void DisplayServerAppleEmbedded::current_edr_headroom_changed() {
_update_hdr_output();
}
bool DisplayServerAppleEmbedded::window_is_hdr_output_supported(WindowID p_window) const {
bool DisplayServerAppleEmbedded::window_is_hdr_output_supported(DisplayServerEnums::WindowID p_window) const {
#if defined(RD_ENABLED)
if (rendering_device && !rendering_device->has_feature(RenderingDevice::Features::SUPPORTS_HDR_OUTPUT)) {
return false;
@ -855,7 +855,7 @@ bool DisplayServerAppleEmbedded::window_is_hdr_output_supported(WindowID p_windo
return _screen_hdr_is_supported();
}
void DisplayServerAppleEmbedded::window_request_hdr_output(const bool p_enabled, WindowID p_window) {
void DisplayServerAppleEmbedded::window_request_hdr_output(const bool p_enabled, DisplayServerEnums::WindowID p_window) {
#if defined(RD_ENABLED)
ERR_FAIL_COND_MSG(p_enabled && rendering_device && !rendering_device->has_feature(RenderingDevice::Features::SUPPORTS_HDR_OUTPUT), "HDR output is not supported by the rendering device.");
#endif
@ -864,11 +864,11 @@ void DisplayServerAppleEmbedded::window_request_hdr_output(const bool p_enabled,
_update_hdr_output();
}
bool DisplayServerAppleEmbedded::window_is_hdr_output_requested(WindowID p_window) const {
bool DisplayServerAppleEmbedded::window_is_hdr_output_requested(DisplayServerEnums::WindowID p_window) const {
return edr_requested;
}
bool DisplayServerAppleEmbedded::window_is_hdr_output_enabled(WindowID p_window) const {
bool DisplayServerAppleEmbedded::window_is_hdr_output_enabled(DisplayServerEnums::WindowID p_window) const {
#if defined(RD_ENABLED)
if (rendering_context) {
return rendering_context->window_get_hdr_output_enabled(p_window);
@ -877,11 +877,11 @@ bool DisplayServerAppleEmbedded::window_is_hdr_output_enabled(WindowID p_window)
return false;
}
void DisplayServerAppleEmbedded::window_set_hdr_output_reference_luminance(const float p_reference_luminance, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_hdr_output_reference_luminance(const float p_reference_luminance, DisplayServerEnums::WindowID p_window) {
ERR_PRINT_ONCE("Manually setting reference white luminance is not supported on Apple devices, as they provide a user-facing brightness setting that directly controls reference white luminance.");
}
float DisplayServerAppleEmbedded::window_get_hdr_output_reference_luminance(WindowID p_window) const {
float DisplayServerAppleEmbedded::window_get_hdr_output_reference_luminance(DisplayServerEnums::WindowID p_window) const {
return -1.0f; // Always auto-adjusted by the OS on Apple platforms.
}
@ -891,7 +891,7 @@ float DisplayServerAppleEmbedded::_calculate_current_reference_luminance() const
return potential * hardware_reference_luminance_nits / current;
}
float DisplayServerAppleEmbedded::window_get_hdr_output_current_reference_luminance(WindowID p_window) const {
float DisplayServerAppleEmbedded::window_get_hdr_output_current_reference_luminance(DisplayServerEnums::WindowID p_window) const {
#if defined(RD_ENABLED)
if (rendering_context) {
return rendering_context->window_get_hdr_output_reference_luminance(p_window);
@ -900,19 +900,19 @@ float DisplayServerAppleEmbedded::window_get_hdr_output_current_reference_lumina
return 200.0f;
}
void DisplayServerAppleEmbedded::window_set_hdr_output_max_luminance(const float p_max_luminance, WindowID p_window) {
void DisplayServerAppleEmbedded::window_set_hdr_output_max_luminance(const float p_max_luminance, DisplayServerEnums::WindowID p_window) {
ERR_PRINT_ONCE("Manually setting max luminance is not supported on Apple embedded devices as they provide accurate max luminance values for their built-in screens.");
}
float DisplayServerAppleEmbedded::window_get_hdr_output_max_luminance(WindowID p_window) const {
float DisplayServerAppleEmbedded::window_get_hdr_output_max_luminance(DisplayServerEnums::WindowID p_window) const {
return -1.0f;
}
float DisplayServerAppleEmbedded::window_get_hdr_output_current_max_luminance(WindowID p_window) const {
float DisplayServerAppleEmbedded::window_get_hdr_output_current_max_luminance(DisplayServerEnums::WindowID p_window) const {
return _screen_potential_edr_headroom() * hardware_reference_luminance_nits;
}
float DisplayServerAppleEmbedded::window_get_output_max_linear_value(WindowID p_window) const {
float DisplayServerAppleEmbedded::window_get_output_max_linear_value(DisplayServerEnums::WindowID p_window) const {
#if defined(RD_ENABLED)
if (rendering_context) {
return rendering_context->window_get_output_max_linear_value(p_window);

24
drivers/apple_embedded/godot_view_controller.mm
View file

@ -281,10 +281,10 @@
return NO;
}
switch (DisplayServerAppleEmbedded::get_singleton()->screen_get_orientation(DisplayServer::SCREEN_OF_MAIN_WINDOW)) {
case DisplayServer::SCREEN_SENSOR:
case DisplayServer::SCREEN_SENSOR_LANDSCAPE:
case DisplayServer::SCREEN_SENSOR_PORTRAIT:
switch (DisplayServerAppleEmbedded::get_singleton()->screen_get_orientation(DisplayServerEnums::SCREEN_OF_MAIN_WINDOW)) {
case DisplayServerEnums::SCREEN_SENSOR:
case DisplayServerEnums::SCREEN_SENSOR_LANDSCAPE:
case DisplayServerEnums::SCREEN_SENSOR_PORTRAIT:
return YES;
default:
return NO;
@ -296,24 +296,24 @@
return UIInterfaceOrientationMaskAll;
}
switch (DisplayServerAppleEmbedded::get_singleton()->screen_get_orientation(DisplayServer::SCREEN_OF_MAIN_WINDOW)) {
case DisplayServer::SCREEN_PORTRAIT:
switch (DisplayServerAppleEmbedded::get_singleton()->screen_get_orientation(DisplayServerEnums::SCREEN_OF_MAIN_WINDOW)) {
case DisplayServerEnums::SCREEN_PORTRAIT:
return UIInterfaceOrientationMaskPortrait;
case DisplayServer::SCREEN_REVERSE_LANDSCAPE:
case DisplayServerEnums::SCREEN_REVERSE_LANDSCAPE:
if (UIDevice.currentDevice.userInterfaceIdiom == UIUserInterfaceIdiomPad) {
return UIInterfaceOrientationMaskLandscapeLeft;
} else {
return UIInterfaceOrientationMaskLandscapeRight;
}
case DisplayServer::SCREEN_REVERSE_PORTRAIT:
case DisplayServerEnums::SCREEN_REVERSE_PORTRAIT:
return UIInterfaceOrientationMaskPortraitUpsideDown;
case DisplayServer::SCREEN_SENSOR_LANDSCAPE:
case DisplayServerEnums::SCREEN_SENSOR_LANDSCAPE:
return UIInterfaceOrientationMaskLandscape;
case DisplayServer::SCREEN_SENSOR_PORTRAIT:
case DisplayServerEnums::SCREEN_SENSOR_PORTRAIT:
return UIInterfaceOrientationMaskPortrait | UIInterfaceOrientationMaskPortraitUpsideDown;
case DisplayServer::SCREEN_SENSOR:
case DisplayServerEnums::SCREEN_SENSOR:
return UIInterfaceOrientationMaskAll;
case DisplayServer::SCREEN_LANDSCAPE:
case DisplayServerEnums::SCREEN_LANDSCAPE:
if (UIDevice.currentDevice.userInterfaceIdiom == UIUserInterfaceIdiomPad) {
return UIInterfaceOrientationMaskLandscapeRight;
} else {

4
drivers/apple_embedded/os_apple_embedded.mm
View file

@ -761,7 +761,7 @@ void OS_AppleEmbedded::on_focus_out() {
is_focused = false;
if (DisplayServerAppleEmbedded::get_singleton()) {
DisplayServerAppleEmbedded::get_singleton()->send_window_event(DisplayServer::WINDOW_EVENT_FOCUS_OUT);
DisplayServerAppleEmbedded::get_singleton()->send_window_event(DisplayServerEnums::WINDOW_EVENT_FOCUS_OUT);
}
if (OS::get_singleton()->get_main_loop()) {
@ -779,7 +779,7 @@ void OS_AppleEmbedded::on_focus_in() {
is_focused = true;
if (DisplayServerAppleEmbedded::get_singleton()) {
DisplayServerAppleEmbedded::get_singleton()->send_window_event(DisplayServer::WINDOW_EVENT_FOCUS_IN);
DisplayServerAppleEmbedded::get_singleton()->send_window_event(DisplayServerEnums::WINDOW_EVENT_FOCUS_IN);
}
if (OS::get_singleton()->get_main_loop()) {

5
drivers/apple_embedded/tts_apple_embedded.h
View file

@ -34,7 +34,6 @@
#include "core/templates/hash_map.h"
#include "core/templates/list.h"
#include "core/variant/array.h"
#include "servers/display/display_server.h"
#if __has_include(<AVFAudio/AVSpeechSynthesis.h>)
#import <AVFAudio/AVSpeechSynthesis.h>
@ -42,12 +41,14 @@
#import <AVFoundation/AVFoundation.h>
#endif
struct TTSUtterance;
@interface GDTTTS : NSObject <AVSpeechSynthesizerDelegate> {
bool speaking;
HashMap<id, int64_t> ids;
AVSpeechSynthesizer *av_synth;
List<DisplayServer::TTSUtterance> queue;
List<TTSUtterance> queue;
}
- (void)pauseSpeaking;

20
drivers/apple_embedded/tts_apple_embedded.mm
View file

@ -30,6 +30,8 @@
#import "tts_apple_embedded.h"
#include "servers/display/display_server.h"
@implementation GDTTTS
- (id)init {
@ -54,18 +56,18 @@
pos++;
}
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_BOUNDARY, ids[utterance], pos);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_BOUNDARY, ids[utterance], pos);
}
- (void)speechSynthesizer:(AVSpeechSynthesizer *)av_synth didCancelSpeechUtterance:(AVSpeechUtterance *)utterance {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, ids[utterance]);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, ids[utterance]);
ids.erase(utterance);
speaking = false;
[self update];
}
- (void)speechSynthesizer:(AVSpeechSynthesizer *)av_synth didFinishSpeechUtterance:(AVSpeechUtterance *)utterance {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_ENDED, ids[utterance]);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_ENDED, ids[utterance]);
ids.erase(utterance);
speaking = false;
[self update];
@ -73,7 +75,7 @@
- (void)update {
if (!speaking && queue.size() > 0) {
DisplayServer::TTSUtterance &message = queue.front()->get();
TTSUtterance &message = queue.front()->get();
AVSpeechUtterance *new_utterance = [[AVSpeechUtterance alloc] initWithString:[NSString stringWithUTF8String:message.text.utf8().get_data()]];
[new_utterance setVoice:[AVSpeechSynthesisVoice voiceWithIdentifier:[NSString stringWithUTF8String:message.voice.utf8().get_data()]]];
@ -87,7 +89,7 @@
ids[new_utterance] = message.id;
[av_synth speakUtterance:new_utterance];
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_STARTED, message.id);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_STARTED, message.id);
queue.pop_front();
speaking = true;
@ -103,8 +105,8 @@
}
- (void)stopSpeaking {
for (DisplayServer::TTSUtterance &message : queue) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, message.id);
for (TTSUtterance &message : queue) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, message.id);
}
queue.clear();
[av_synth stopSpeakingAtBoundary:AVSpeechBoundaryImmediate];
@ -125,11 +127,11 @@
}
if (text.is_empty()) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, utterance_id);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, utterance_id);
return;
}
DisplayServer::TTSUtterance message;
TTSUtterance message;
message.text = text;
message.voice = voice;
message.volume = CLAMP(volume, 0, 100);

4
drivers/d3d12/rendering_context_driver_d3d12.cpp
View file

@ -278,13 +278,13 @@ void RenderingContextDriverD3D12::surface_set_size(SurfaceID p_surface, uint32_t
surface->needs_resize = true;
}
void RenderingContextDriverD3D12::surface_set_vsync_mode(SurfaceID p_surface, DisplayServer::VSyncMode p_vsync_mode) {
void RenderingContextDriverD3D12::surface_set_vsync_mode(SurfaceID p_surface, DisplayServerEnums::VSyncMode p_vsync_mode) {
Surface *surface = (Surface *)(p_surface);
surface->vsync_mode = p_vsync_mode;
surface->needs_resize = true;
}
DisplayServer::VSyncMode RenderingContextDriverD3D12::surface_get_vsync_mode(SurfaceID p_surface) const {
DisplayServerEnums::VSyncMode RenderingContextDriverD3D12::surface_get_vsync_mode(SurfaceID p_surface) const {
Surface *surface = (Surface *)(p_surface);
return surface->vsync_mode;
}

6
drivers/d3d12/rendering_context_driver_d3d12.h
View file

@ -92,8 +92,8 @@ public:
virtual void driver_free(RenderingDeviceDriver *p_driver) override;
virtual SurfaceID surface_create(const void *p_platform_data) override;
virtual void surface_set_size(SurfaceID p_surface, uint32_t p_width, uint32_t p_height) override;
virtual void surface_set_vsync_mode(SurfaceID p_surface, DisplayServer::VSyncMode p_vsync_mode) override;
virtual DisplayServer::VSyncMode surface_get_vsync_mode(SurfaceID p_surface) const override;
virtual void surface_set_vsync_mode(SurfaceID p_surface, DisplayServerEnums::VSyncMode p_vsync_mode) override;
virtual DisplayServerEnums::VSyncMode surface_get_vsync_mode(SurfaceID p_surface) const override;
virtual void surface_set_hdr_output_enabled(SurfaceID p_surface, bool p_enabled) override;
virtual bool surface_get_hdr_output_enabled(SurfaceID p_surface) const override;
virtual void surface_set_hdr_output_reference_luminance(SurfaceID p_surface, float p_reference_luminance) override;
@ -120,7 +120,7 @@ public:
HWND hwnd = nullptr;
uint32_t width = 0;
uint32_t height = 0;
DisplayServer::VSyncMode vsync_mode = DisplayServer::VSYNC_ENABLED;
DisplayServerEnums::VSyncMode vsync_mode = DisplayServerEnums::VSYNC_ENABLED;
bool needs_resize = false;
bool hdr_output = false;

8
drivers/d3d12/rendering_device_driver_d3d12.cpp
View file

@ -2793,20 +2793,20 @@ Error RenderingDeviceDriverD3D12::swap_chain_resize(CommandQueueID p_cmd_queue,
UINT present_flags = 0;
UINT creation_flags = 0;
switch (surface->vsync_mode) {
case DisplayServer::VSYNC_MAILBOX: {
case DisplayServerEnums::VSYNC_MAILBOX: {
sync_interval = 1;
present_flags = DXGI_PRESENT_RESTART;
} break;
case DisplayServer::VSYNC_ENABLED: {
case DisplayServerEnums::VSYNC_ENABLED: {
sync_interval = 1;
present_flags = 0;
} break;
case DisplayServer::VSYNC_DISABLED: {
case DisplayServerEnums::VSYNC_DISABLED: {
sync_interval = 0;
present_flags = is_tearing_supported ? DXGI_PRESENT_ALLOW_TEARING : 0;
creation_flags = is_tearing_supported ? DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING : 0;
} break;
case DisplayServer::VSYNC_ADAPTIVE: // Unsupported.
case DisplayServerEnums::VSYNC_ADAPTIVE: // Unsupported.
default:
sync_interval = 1;
present_flags = 0;

14
drivers/egl/egl_manager.cpp
View file

@ -252,7 +252,7 @@ int EGLManager::display_get_native_visual_id(void *p_display) {
return native_visual_id;
}
Error EGLManager::window_create(DisplayServer::WindowID p_window_id, void *p_display, void *p_native_window, int p_width, int p_height) {
Error EGLManager::window_create(DisplayServerEnums::WindowID p_window_id, void *p_display, void *p_native_window, int p_width, int p_height) {
int gldisplay_id = _get_gldisplay_id(p_display);
ERR_FAIL_COND_V(gldisplay_id < 0, ERR_CANT_CREATE);
@ -320,7 +320,7 @@ Error EGLManager::window_create(DisplayServer::WindowID p_window_id, void *p_dis
return OK;
}
void EGLManager::window_destroy(DisplayServer::WindowID p_window_id) {
void EGLManager::window_destroy(DisplayServerEnums::WindowID p_window_id) {
ERR_FAIL_INDEX(p_window_id, (int)windows.size());
GLWindow &glwindow = windows[p_window_id];
@ -365,8 +365,8 @@ void EGLManager::swap_buffers() {
eglSwapBuffers(current_display.egl_display, current_window->egl_surface);
}
void EGLManager::window_make_current(DisplayServer::WindowID p_window_id) {
if (p_window_id == DisplayServer::INVALID_WINDOW_ID) {
void EGLManager::window_make_current(DisplayServerEnums::WindowID p_window_id) {
if (p_window_id == DisplayServerEnums::INVALID_WINDOW_ID) {
return;
}
@ -408,7 +408,7 @@ bool EGLManager::is_using_vsync() const {
return use_vsync;
}
EGLContext EGLManager::get_context(DisplayServer::WindowID p_window_id) {
EGLContext EGLManager::get_context(DisplayServerEnums::WindowID p_window_id) {
GLWindow &glwindow = windows[p_window_id];
if (!glwindow.initialized) {
@ -420,7 +420,7 @@ EGLContext EGLManager::get_context(DisplayServer::WindowID p_window_id) {
return display.egl_context;
}
EGLDisplay EGLManager::get_display(DisplayServer::WindowID p_window_id) {
EGLDisplay EGLManager::get_display(DisplayServerEnums::WindowID p_window_id) {
GLWindow &glwindow = windows[p_window_id];
if (!glwindow.initialized) {
@ -432,7 +432,7 @@ EGLDisplay EGLManager::get_display(DisplayServer::WindowID p_window_id) {
return display.egl_display;
}
EGLConfig EGLManager::get_config(DisplayServer::WindowID p_window_id) {
EGLConfig EGLManager::get_config(DisplayServerEnums::WindowID p_window_id) {
GLWindow &glwindow = windows[p_window_id];
if (!glwindow.initialized) {

12
drivers/egl/egl_manager.h
View file

@ -95,21 +95,21 @@ public:
int display_get_native_visual_id(void *p_display);
Error open_display(void *p_display);
Error window_create(DisplayServer::WindowID p_window_id, void *p_display, void *p_native_window, int p_width, int p_height);
Error window_create(DisplayServerEnums::WindowID p_window_id, void *p_display, void *p_native_window, int p_width, int p_height);
void window_destroy(DisplayServer::WindowID p_window_id);
void window_destroy(DisplayServerEnums::WindowID p_window_id);
void release_current();
void swap_buffers();
void window_make_current(DisplayServer::WindowID p_window_id);
void window_make_current(DisplayServerEnums::WindowID p_window_id);
void set_use_vsync(bool p_use);
bool is_using_vsync() const;
EGLContext get_context(DisplayServer::WindowID p_window_id);
EGLDisplay get_display(DisplayServer::WindowID p_window_id);
EGLConfig get_config(DisplayServer::WindowID p_window_id);
EGLContext get_context(DisplayServerEnums::WindowID p_window_id);
EGLDisplay get_display(DisplayServerEnums::WindowID p_window_id);
EGLConfig get_config(DisplayServerEnums::WindowID p_window_id);
Error initialize(void *p_native_display = nullptr);

4
drivers/gles3/rasterizer_gles3.cpp
View file

@ -367,7 +367,7 @@ RasterizerGLES3::RasterizerGLES3() {
RasterizerGLES3::~RasterizerGLES3() {
}
void RasterizerGLES3::_blit_render_target_to_screen(DisplayServer::WindowID p_screen, const RenderingServerTypes::BlitToScreen &p_blit, bool p_first) {
void RasterizerGLES3::_blit_render_target_to_screen(DisplayServerEnums::WindowID p_screen, const RenderingServerTypes::BlitToScreen &p_blit, bool p_first) {
GLES3::RenderTarget *rt = GLES3::TextureStorage::get_singleton()->get_render_target(p_blit.render_target);
ERR_FAIL_NULL(rt);
@ -442,7 +442,7 @@ void RasterizerGLES3::_blit_render_target_to_screen(DisplayServer::WindowID p_sc
}
// is this p_screen useless in a multi window environment?
void RasterizerGLES3::blit_render_targets_to_screen(DisplayServer::WindowID p_screen, const RenderingServerTypes::BlitToScreen *p_render_targets, int p_amount) {
void RasterizerGLES3::blit_render_targets_to_screen(DisplayServerEnums::WindowID p_screen, const RenderingServerTypes::BlitToScreen *p_render_targets, int p_amount) {
for (int i = 0; i < p_amount; i++) {
_blit_render_target_to_screen(p_screen, p_render_targets[i], i == 0);
}

4
drivers/gles3/rasterizer_gles3.h
View file

@ -81,7 +81,7 @@ protected:
RasterizerSceneGLES3 *scene = nullptr;
static RasterizerGLES3 *singleton;
void _blit_render_target_to_screen(DisplayServer::WindowID p_screen, const RenderingServerTypes::BlitToScreen &p_blit, bool p_first = true);
void _blit_render_target_to_screen(DisplayServerEnums::WindowID p_screen, const RenderingServerTypes::BlitToScreen &p_blit, bool p_first = true);
public:
RendererUtilities *get_utilities() { return utilities; }
@ -100,7 +100,7 @@ public:
void initialize();
void begin_frame(double frame_step);
void blit_render_targets_to_screen(DisplayServer::WindowID p_screen, const RenderingServerTypes::BlitToScreen *p_render_targets, int p_amount);
void blit_render_targets_to_screen(DisplayServerEnums::WindowID p_screen, const RenderingServerTypes::BlitToScreen *p_render_targets, int p_amount);
bool is_opengl() { return true; }
void gl_end_frame(bool p_swap_buffers);

14
drivers/metal/rendering_context_driver_metal.cpp
View file

@ -138,12 +138,12 @@ public:
#if TARGET_OS_OSX
// Display sync is only supported on macOS.
switch (vsync_mode) {
case DisplayServer::VSYNC_MAILBOX:
case DisplayServer::VSYNC_ADAPTIVE:
case DisplayServer::VSYNC_ENABLED:
case DisplayServerEnums::VSYNC_MAILBOX:
case DisplayServerEnums::VSYNC_ADAPTIVE:
case DisplayServerEnums::VSYNC_ENABLED:
layer->setDisplaySyncEnabled(true);
break;
case DisplayServer::VSYNC_DISABLED:
case DisplayServerEnums::VSYNC_DISABLED:
layer->setDisplaySyncEnabled(false);
break;
}
@ -212,7 +212,7 @@ public:
count--;
front = (front + 1) % frame_buffers.size();
if (vsync_mode != DisplayServer::VSYNC_DISABLED) {
if (vsync_mode != DisplayServerEnums::VSYNC_DISABLED) {
p_cmd_buffer->get_command_buffer()->presentDrawableAfterMinimumDuration(drawable, present_minimum_duration);
} else {
p_cmd_buffer->get_command_buffer()->presentDrawable(drawable);
@ -385,7 +385,7 @@ void RenderingContextDriverMetal::surface_set_size(SurfaceID p_surface, uint32_t
surface->needs_resize = true;
}
void RenderingContextDriverMetal::surface_set_vsync_mode(SurfaceID p_surface, DisplayServer::VSyncMode p_vsync_mode) {
void RenderingContextDriverMetal::surface_set_vsync_mode(SurfaceID p_surface, DisplayServerEnums::VSyncMode p_vsync_mode) {
Surface *surface = (Surface *)(p_surface);
if (surface->vsync_mode == p_vsync_mode) {
return;
@ -394,7 +394,7 @@ void RenderingContextDriverMetal::surface_set_vsync_mode(SurfaceID p_surface, Di
surface->needs_resize = true;
}
DisplayServer::VSyncMode RenderingContextDriverMetal::surface_get_vsync_mode(SurfaceID p_surface) const {
DisplayServerEnums::VSyncMode RenderingContextDriverMetal::surface_get_vsync_mode(SurfaceID p_surface) const {
Surface *surface = (Surface *)(p_surface);
return surface->vsync_mode;
}

6
drivers/metal/rendering_context_driver_metal.h
View file

@ -58,8 +58,8 @@ public:
void driver_free(RenderingDeviceDriver *p_driver) final override;
SurfaceID surface_create(const void *p_platform_data) final override;
void surface_set_size(SurfaceID p_surface, uint32_t p_width, uint32_t p_height) final override;
void surface_set_vsync_mode(SurfaceID p_surface, DisplayServer::VSyncMode p_vsync_mode) final override;
DisplayServer::VSyncMode surface_get_vsync_mode(SurfaceID p_surface) const final override;
void surface_set_vsync_mode(SurfaceID p_surface, DisplayServerEnums::VSyncMode p_vsync_mode) final override;
DisplayServerEnums::VSyncMode surface_get_vsync_mode(SurfaceID p_surface) const final override;
virtual void surface_set_hdr_output_enabled(SurfaceID p_surface, bool p_enabled) final override;
virtual bool surface_get_hdr_output_enabled(SurfaceID p_surface) const final override;
virtual void surface_set_hdr_output_reference_luminance(SurfaceID p_surface, float p_reference_luminance) final override;
@ -90,7 +90,7 @@ public:
public:
uint32_t width = 0;
uint32_t height = 0;
DisplayServer::VSyncMode vsync_mode = DisplayServer::VSYNC_ENABLED;
DisplayServerEnums::VSyncMode vsync_mode = DisplayServerEnums::VSYNC_ENABLED;
double present_minimum_duration = 0.0;
MTL::PixelFormat pixel_format = MTL::PixelFormatBGRA8Unorm;

4
drivers/metal/rendering_device_driver_metal3.cpp
View file

@ -243,7 +243,7 @@ Error RenderingDeviceDriverMetal::_execute_and_present_barriers(CommandQueueID p
struct DrawRequest {
NS::SharedPtr<MTL::Drawable> drawable;
DisplayServer::VSyncMode vsync_mode;
DisplayServerEnums::VSyncMode vsync_mode;
double duration;
};
@ -268,7 +268,7 @@ Error RenderingDeviceDriverMetal::_execute_and_present_barriers(CommandQueueID p
cb->addCompletedHandler([drawables = std::move(drawables)](MTL::CommandBuffer *) {
for (const DrawRequest &dr : drawables) {
switch (dr.vsync_mode) {
case DisplayServer::VSYNC_DISABLED: {
case DisplayServerEnums::VSYNC_DISABLED: {
dr.drawable->present();
} break;
default: {

4
drivers/vulkan/rendering_context_driver_vulkan.cpp
View file

@ -983,13 +983,13 @@ void RenderingContextDriverVulkan::surface_set_size(SurfaceID p_surface, uint32_
surface->needs_resize = true;
}
void RenderingContextDriverVulkan::surface_set_vsync_mode(SurfaceID p_surface, DisplayServer::VSyncMode p_vsync_mode) {
void RenderingContextDriverVulkan::surface_set_vsync_mode(SurfaceID p_surface, DisplayServerEnums::VSyncMode p_vsync_mode) {
Surface *surface = (Surface *)(p_surface);
surface->vsync_mode = p_vsync_mode;
surface->needs_resize = true;
}
DisplayServer::VSyncMode RenderingContextDriverVulkan::surface_get_vsync_mode(SurfaceID p_surface) const {
DisplayServerEnums::VSyncMode RenderingContextDriverVulkan::surface_get_vsync_mode(SurfaceID p_surface) const {
Surface *surface = (Surface *)(p_surface);
return surface->vsync_mode;
}

6
drivers/vulkan/rendering_context_driver_vulkan.h
View file

@ -136,8 +136,8 @@ public:
virtual void driver_free(RenderingDeviceDriver *p_driver) override;
virtual SurfaceID surface_create(const void *p_platform_data) override;
virtual void surface_set_size(SurfaceID p_surface, uint32_t p_width, uint32_t p_height) override;
virtual void surface_set_vsync_mode(SurfaceID p_surface, DisplayServer::VSyncMode p_vsync_mode) override;
virtual DisplayServer::VSyncMode surface_get_vsync_mode(SurfaceID p_surface) const override;
virtual void surface_set_vsync_mode(SurfaceID p_surface, DisplayServerEnums::VSyncMode p_vsync_mode) override;
virtual DisplayServerEnums::VSyncMode surface_get_vsync_mode(SurfaceID p_surface) const override;
virtual void surface_set_hdr_output_enabled(SurfaceID p_surface, bool p_enabled) override;
virtual bool surface_get_hdr_output_enabled(SurfaceID p_surface) const override;
virtual void surface_set_hdr_output_reference_luminance(SurfaceID p_surface, float p_reference_luminance) override;
@ -160,7 +160,7 @@ public:
VkSurfaceKHR vk_surface = VK_NULL_HANDLE;
uint32_t width = 0;
uint32_t height = 0;
DisplayServer::VSyncMode vsync_mode = DisplayServer::VSYNC_ENABLED;
DisplayServerEnums::VSyncMode vsync_mode = DisplayServerEnums::VSYNC_ENABLED;
bool needs_resize = false;
bool hdr_output = false;

10
drivers/vulkan/rendering_device_driver_vulkan.cpp
View file

@ -3627,19 +3627,19 @@ Error RenderingDeviceDriverVulkan::swap_chain_resize(CommandQueueID p_cmd_queue,
VkPresentModeKHR present_mode = VkPresentModeKHR::VK_PRESENT_MODE_FIFO_KHR;
String present_mode_name = "Enabled";
switch (surface->vsync_mode) {
case DisplayServer::VSYNC_MAILBOX:
case DisplayServerEnums::VSYNC_MAILBOX:
present_mode = VK_PRESENT_MODE_MAILBOX_KHR;
present_mode_name = "Mailbox";
break;
case DisplayServer::VSYNC_ADAPTIVE:
case DisplayServerEnums::VSYNC_ADAPTIVE:
present_mode = VK_PRESENT_MODE_FIFO_RELAXED_KHR;
present_mode_name = "Adaptive";
break;
case DisplayServer::VSYNC_ENABLED:
case DisplayServerEnums::VSYNC_ENABLED:
present_mode = VK_PRESENT_MODE_FIFO_KHR;
present_mode_name = "Enabled";
break;
case DisplayServer::VSYNC_DISABLED:
case DisplayServerEnums::VSYNC_DISABLED:
present_mode = VK_PRESENT_MODE_IMMEDIATE_KHR;
present_mode_name = "Disabled";
break;
@ -3649,7 +3649,7 @@ Error RenderingDeviceDriverVulkan::swap_chain_resize(CommandQueueID p_cmd_queue,
if (!present_mode_available) {
// Present mode is not available, fall back to FIFO which is guaranteed to be supported.
WARN_PRINT(vformat("The requested V-Sync mode %s is not available. Falling back to V-Sync mode Enabled.", present_mode_name));
surface->vsync_mode = DisplayServer::VSYNC_ENABLED;
surface->vsync_mode = DisplayServerEnums::VSYNC_ENABLED;
present_mode = VkPresentModeKHR::VK_PRESENT_MODE_FIFO_KHR;
}

10
editor/animation/animation_player_editor_plugin.cpp
View file

@ -1715,7 +1715,7 @@ void AnimationPlayerEditor::_editor_visibility_changed() {
bool AnimationPlayerEditor::_are_onion_layers_valid() {
ERR_FAIL_COND_V(!onion.past && !onion.future, false);
Size2 capture_size = DisplayServer::get_singleton()->window_get_size(DisplayServer::MAIN_WINDOW_ID);
Size2 capture_size = DisplayServer::get_singleton()->window_get_size(DisplayServerEnums::MAIN_WINDOW_ID);
return onion.captures.size() == onion.get_capture_count() && onion.capture_size == capture_size;
}
@ -1723,7 +1723,7 @@ void AnimationPlayerEditor::_allocate_onion_layers() {
_free_onion_layers();
int captures = onion.get_capture_count();
Size2 capture_size = DisplayServer::get_singleton()->window_get_size(DisplayServer::MAIN_WINDOW_ID);
Size2 capture_size = DisplayServer::get_singleton()->window_get_size(DisplayServerEnums::MAIN_WINDOW_ID);
onion.captures.resize(captures);
onion.captures_valid.resize(captures);
@ -1834,8 +1834,8 @@ void AnimationPlayerEditor::_prepare_onion_layers_2_prolog() {
// Tweak the root viewport to ensure it's rendered before our target.
RID root_vp = get_tree()->get_root()->get_viewport_rid();
onion.temp.screen_rect = Rect2(Vector2(), DisplayServer::get_singleton()->window_get_size(DisplayServer::MAIN_WINDOW_ID));
RS::get_singleton()->viewport_attach_to_screen(root_vp, Rect2(), DisplayServer::INVALID_WINDOW_ID);
onion.temp.screen_rect = Rect2(Vector2(), DisplayServer::get_singleton()->window_get_size(DisplayServerEnums::MAIN_WINDOW_ID));
RS::get_singleton()->viewport_attach_to_screen(root_vp, Rect2(), DisplayServerEnums::INVALID_WINDOW_ID);
RS::get_singleton()->viewport_set_update_mode(root_vp, RSE::VIEWPORT_UPDATE_ALWAYS);
RID present_rid;
@ -1921,7 +1921,7 @@ void AnimationPlayerEditor::_prepare_onion_layers_2_epilog() {
// Restore root viewport.
RID root_vp = get_tree()->get_root()->get_viewport_rid();
RS::get_singleton()->viewport_set_parent_viewport(root_vp, RID());
RS::get_singleton()->viewport_attach_to_screen(root_vp, onion.temp.screen_rect, DisplayServer::MAIN_WINDOW_ID);
RS::get_singleton()->viewport_attach_to_screen(root_vp, onion.temp.screen_rect, DisplayServerEnums::MAIN_WINDOW_ID);
RS::get_singleton()->viewport_set_update_mode(root_vp, RSE::VIEWPORT_UPDATE_WHEN_VISIBLE);
// Restore animation state.

2
editor/doc/editor_help.cpp
View file

@ -4741,7 +4741,7 @@ void EditorHelpBitTooltip::popup_under_position(const Point2 &p_point) {
vr = window->get_usable_parent_rect();
}
if (!DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_SELF_FITTING_WINDOWS) || is_embedded()) {
if (!DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_SELF_FITTING_WINDOWS) || is_embedded()) {
if (r.size.x + r.position.x > vr.size.x + vr.position.x) {
// Place it in the opposite direction. If it fails, just hug the border.
r.position.x = p_point.x - r.size.x - tooltip_offset.x;

4
editor/doc/editor_help_search.cpp
View file

@ -197,13 +197,13 @@ void EditorHelpSearch::_confirmed() {
void EditorHelpSearch::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_ENTER_TREE: {
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_NATIVE_HELP)) {
if (DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_NATIVE_HELP)) {
DisplayServer::get_singleton()->help_set_search_callbacks(callable_mp(this, &EditorHelpSearch::_native_search_cb), callable_mp(this, &EditorHelpSearch::_native_action_cb));
}
} break;
case NOTIFICATION_EXIT_TREE: {
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_NATIVE_HELP)) {
if (DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_NATIVE_HELP)) {
DisplayServer::get_singleton()->help_set_search_callbacks();
}
} break;

24
editor/editor_node.cpp
View file

@ -457,7 +457,7 @@ void EditorNode::shortcut_input(const Ref<InputEvent> &p_event) {
}
void EditorNode::_update_vsync_mode() {
const DisplayServer::VSyncMode window_vsync_mode = DisplayServer::VSyncMode(int(EDITOR_GET("interface/editor/display/vsync_mode")));
const DisplayServerEnums::VSyncMode window_vsync_mode = DisplayServerEnums::VSyncMode(int(EDITOR_GET("interface/editor/display/vsync_mode")));
DisplayServer::get_singleton()->window_set_vsync_mode(window_vsync_mode);
}
@ -939,7 +939,7 @@ void EditorNode::_notification(int p_what) {
get_tree()->set_quit_on_go_back(false);
bool is_fullscreen = EDITOR_DEF("_is_editor_fullscreen", false);
if (is_fullscreen) {
DisplayServer::get_singleton()->window_set_mode(DisplayServer::WINDOW_MODE_FULLSCREEN);
DisplayServer::get_singleton()->window_set_mode(DisplayServerEnums::WINDOW_MODE_FULLSCREEN);
}
#endif
get_tree()->get_root()->connect("files_dropped", callable_mp(this, &EditorNode::_dropped_files));
@ -1632,8 +1632,8 @@ void EditorNode::_viewport_resized() {
}
void EditorNode::_titlebar_resized() {
DisplayServer::get_singleton()->window_set_window_buttons_offset(Vector2i(title_bar->get_global_position().y + title_bar->get_size().y / 2, title_bar->get_global_position().y + title_bar->get_size().y / 2), DisplayServer::MAIN_WINDOW_ID);
const Vector3i &margin = DisplayServer::get_singleton()->window_get_safe_title_margins(DisplayServer::MAIN_WINDOW_ID);
DisplayServer::get_singleton()->window_set_window_buttons_offset(Vector2i(title_bar->get_global_position().y + title_bar->get_size().y / 2, title_bar->get_global_position().y + title_bar->get_size().y / 2), DisplayServerEnums::MAIN_WINDOW_ID);
const Vector3i &margin = DisplayServer::get_singleton()->window_get_safe_title_margins(DisplayServerEnums::MAIN_WINDOW_ID);
if (left_menu_spacer) {
int w = (gui_base->is_layout_rtl()) ? margin.y : margin.x;
left_menu_spacer->set_custom_minimum_size(Size2(w, 0));
@ -3816,8 +3816,8 @@ void EditorNode::_menu_option_confirm(int p_option, bool p_confirmed) {
feature_profile_manager->popup_centered_clamped(Size2(900, 800) * EDSCALE, 0.8);
} break;
case EDITOR_TOGGLE_FULLSCREEN: {
DisplayServer::WindowMode mode = DisplayServer::get_singleton()->window_get_mode();
if (mode == DisplayServer::WINDOW_MODE_FULLSCREEN || mode == DisplayServer::WINDOW_MODE_EXCLUSIVE_FULLSCREEN) {
DisplayServerEnums::WindowMode mode = DisplayServer::get_singleton()->window_get_mode();
if (mode == DisplayServerEnums::WINDOW_MODE_FULLSCREEN || mode == DisplayServerEnums::WINDOW_MODE_EXCLUSIVE_FULLSCREEN) {
DisplayServer::get_singleton()->window_set_mode(prev_mode);
#ifdef ANDROID_ENABLED
EditorSettings::get_singleton()->set("_is_editor_fullscreen", false);
@ -3825,7 +3825,7 @@ void EditorNode::_menu_option_confirm(int p_option, bool p_confirmed) {
#endif
} else {
prev_mode = mode;
DisplayServer::get_singleton()->window_set_mode(DisplayServer::WINDOW_MODE_FULLSCREEN);
DisplayServer::get_singleton()->window_set_mode(DisplayServerEnums::WINDOW_MODE_FULLSCREEN);
#ifdef ANDROID_ENABLED
EditorSettings::get_singleton()->set("_is_editor_fullscreen", true);
EditorSettings::get_singleton()->save();
@ -5333,7 +5333,7 @@ void EditorNode::request_instantiate_scenes(const Vector<String> &p_files) {
String EditorNode::get_multiwindow_support_tooltip_text() const {
if (SceneTree::get_singleton()->get_root()->is_embedding_subwindows()) {
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_SUBWINDOWS)) {
if (DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_SUBWINDOWS)) {
return TTR("Multi-window support is not available because the `--single-window` command line argument was used to start the editor.");
} else {
return TTR("Multi-window support is not available because the current platform doesn't support multiple windows.");
@ -8080,7 +8080,7 @@ void EditorNode::_add_to_main_menu(const String &p_name, PopupMenu *p_menu) {
}
void EditorNode::_update_main_menu_type() {
bool can_expand = bool(EDITOR_GET("interface/editor/appearance/expand_to_title")) && DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_EXTEND_TO_TITLE);
bool can_expand = bool(EDITOR_GET("interface/editor/appearance/expand_to_title")) && DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_EXTEND_TO_TITLE);
bool use_menu_button = EDITOR_GET("interface/editor/appearance/collapse_main_menu");
bool global_menu = !bool(EDITOR_GET("interface/editor/appearance/use_embedded_menu")) && NativeMenu::get_singleton()->has_feature(NativeMenu::FEATURE_GLOBAL_MENU);
MenuType new_menu_type;
@ -8282,7 +8282,7 @@ EditorNode::EditorNode() {
// Only if no touchscreen ui hint, disable emulation just in case.
Input::get_singleton()->set_emulate_touch_from_mouse(false);
}
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_CUSTOM_CURSOR_SHAPE)) {
if (DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_CUSTOM_CURSOR_SHAPE)) {
DisplayServer::get_singleton()->cursor_set_custom_image(Ref<Resource>());
}
}
@ -8899,7 +8899,7 @@ EditorNode::EditorNode() {
ED_SHORTCUT_AND_COMMAND("editor/editor_prev", TTRC("Open the previous Editor"));
// Editor menu and toolbar.
bool can_expand = bool(EDITOR_GET("interface/editor/appearance/expand_to_title")) && DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_EXTEND_TO_TITLE);
bool can_expand = bool(EDITOR_GET("interface/editor/appearance/expand_to_title")) && DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_EXTEND_TO_TITLE);
#ifdef MACOS_ENABLED
if (NativeMenu::get_singleton()->has_system_menu(NativeMenu::APPLICATION_MENU_ID)) {
@ -9498,7 +9498,7 @@ EditorNode::EditorNode() {
// Extend menu bar to window title.
if (can_expand) {
DisplayServer::get_singleton()->process_events();
DisplayServer::get_singleton()->window_set_flag(DisplayServer::WINDOW_FLAG_EXTEND_TO_TITLE, true, DisplayServer::MAIN_WINDOW_ID);
DisplayServer::get_singleton()->window_set_flag(DisplayServerEnums::WINDOW_FLAG_EXTEND_TO_TITLE, true, DisplayServerEnums::MAIN_WINDOW_ID);
title_bar->set_can_move_window(true);
}

2
editor/editor_node.h
View file

@ -317,7 +317,7 @@ private:
bool exiting = false;
bool dimmed = false;
DisplayServer::WindowMode prev_mode = DisplayServer::WINDOW_MODE_MAXIMIZED;
DisplayServerEnums::WindowMode prev_mode = DisplayServerEnums::WINDOW_MODE_MAXIMIZED;
int old_split_ofs = 0;
VSplitContainer *top_split = nullptr;
Control *vp_base = nullptr;

36
editor/export/editor_export_platform_apple_embedded.cpp
View file

@ -523,33 +523,33 @@ String EditorExportPlatformAppleEmbedded::_process_config_file_line(const Ref<Ed
strnew += p_line.replace("$required_device_capabilities", capabilities);
} else if (p_line.contains("$interface_orientations")) {
String orientations;
const DisplayServer::ScreenOrientation screen_orientation =
DisplayServer::ScreenOrientation(int(get_project_setting(p_preset, "display/window/handheld/orientation")));
const DisplayServerEnums::ScreenOrientation screen_orientation =
DisplayServerEnums::ScreenOrientation(int(get_project_setting(p_preset, "display/window/handheld/orientation")));
switch (screen_orientation) {
case DisplayServer::SCREEN_LANDSCAPE:
case DisplayServerEnums::SCREEN_LANDSCAPE:
orientations += "<string>UIInterfaceOrientationLandscapeLeft</string>\n";
break;
case DisplayServer::SCREEN_PORTRAIT:
case DisplayServerEnums::SCREEN_PORTRAIT:
orientations += "<string>UIInterfaceOrientationPortrait</string>\n";
break;
case DisplayServer::SCREEN_REVERSE_LANDSCAPE:
case DisplayServerEnums::SCREEN_REVERSE_LANDSCAPE:
orientations += "<string>UIInterfaceOrientationLandscapeRight</string>\n";
break;
case DisplayServer::SCREEN_REVERSE_PORTRAIT:
case DisplayServerEnums::SCREEN_REVERSE_PORTRAIT:
orientations += "<string>UIInterfaceOrientationPortraitUpsideDown</string>\n";
break;
case DisplayServer::SCREEN_SENSOR_LANDSCAPE:
case DisplayServerEnums::SCREEN_SENSOR_LANDSCAPE:
// Allow both landscape orientations depending on sensor direction.
orientations += "<string>UIInterfaceOrientationLandscapeLeft</string>\n";
orientations += "<string>UIInterfaceOrientationLandscapeRight</string>\n";
break;
case DisplayServer::SCREEN_SENSOR_PORTRAIT:
case DisplayServerEnums::SCREEN_SENSOR_PORTRAIT:
// Allow both portrait orientations depending on sensor direction.
orientations += "<string>UIInterfaceOrientationPortrait</string>\n";
orientations += "<string>UIInterfaceOrientationPortraitUpsideDown</string>\n";
break;
case DisplayServer::SCREEN_SENSOR:
case DisplayServerEnums::SCREEN_SENSOR:
// Allow all screen orientations depending on sensor direction.
orientations += "<string>UIInterfaceOrientationLandscapeLeft</string>\n";
orientations += "<string>UIInterfaceOrientationLandscapeRight</string>\n";
@ -561,33 +561,33 @@ String EditorExportPlatformAppleEmbedded::_process_config_file_line(const Ref<Ed
strnew += p_line.replace("$interface_orientations", orientations);
} else if (p_line.contains("$ipad_interface_orientations")) {
String orientations;
const DisplayServer::ScreenOrientation screen_orientation =
DisplayServer::ScreenOrientation(int(get_project_setting(p_preset, "display/window/handheld/orientation")));
const DisplayServerEnums::ScreenOrientation screen_orientation =
DisplayServerEnums::ScreenOrientation(int(get_project_setting(p_preset, "display/window/handheld/orientation")));
switch (screen_orientation) {
case DisplayServer::SCREEN_LANDSCAPE:
case DisplayServerEnums::SCREEN_LANDSCAPE:
orientations += "<string>UIInterfaceOrientationLandscapeRight</string>\n";
break;
case DisplayServer::SCREEN_PORTRAIT:
case DisplayServerEnums::SCREEN_PORTRAIT:
orientations += "<string>UIInterfaceOrientationPortrait</string>\n";
break;
case DisplayServer::SCREEN_REVERSE_LANDSCAPE:
case DisplayServerEnums::SCREEN_REVERSE_LANDSCAPE:
orientations += "<string>UIInterfaceOrientationLandscapeLeft</string>\n";
break;
case DisplayServer::SCREEN_REVERSE_PORTRAIT:
case DisplayServerEnums::SCREEN_REVERSE_PORTRAIT:
orientations += "<string>UIInterfaceOrientationPortraitUpsideDown</string>\n";
break;
case DisplayServer::SCREEN_SENSOR_LANDSCAPE:
case DisplayServerEnums::SCREEN_SENSOR_LANDSCAPE:
// Allow both landscape orientations depending on sensor direction.
orientations += "<string>UIInterfaceOrientationLandscapeLeft</string>\n";
orientations += "<string>UIInterfaceOrientationLandscapeRight</string>\n";
break;
case DisplayServer::SCREEN_SENSOR_PORTRAIT:
case DisplayServerEnums::SCREEN_SENSOR_PORTRAIT:
// Allow both portrait orientations depending on sensor direction.
orientations += "<string>UIInterfaceOrientationPortrait</string>\n";
orientations += "<string>UIInterfaceOrientationPortraitUpsideDown</string>\n";
break;
case DisplayServer::SCREEN_SENSOR:
case DisplayServerEnums::SCREEN_SENSOR:
// Allow all screen orientations depending on sensor direction.
orientations += "<string>UIInterfaceOrientationLandscapeLeft</string>\n";
orientations += "<string>UIInterfaceOrientationLandscapeRight</string>\n";

4
editor/file_system/editor_file_system.cpp
View file

@ -3242,9 +3242,9 @@ void EditorFileSystem::reimport_files(const Vector<String> &p_files) {
// this could lead to a slow import process, especially when the editor is unfocused.
// Temporarily disabling VSync and low_processor_usage_mode while reimporting fixes this.
const bool old_low_processor_usage_mode = OS::get_singleton()->is_in_low_processor_usage_mode();
const DisplayServer::VSyncMode old_vsync_mode = DisplayServer::get_singleton()->window_get_vsync_mode(DisplayServer::MAIN_WINDOW_ID);
const DisplayServerEnums::VSyncMode old_vsync_mode = DisplayServer::get_singleton()->window_get_vsync_mode(DisplayServerEnums::MAIN_WINDOW_ID);
OS::get_singleton()->set_low_processor_usage_mode(false);
DisplayServer::get_singleton()->window_set_vsync_mode(DisplayServer::VSyncMode::VSYNC_DISABLED);
DisplayServer::get_singleton()->window_set_vsync_mode(DisplayServerEnums::VSyncMode::VSYNC_DISABLED);
Vector<ImportFile> reimport_files;

2
editor/gui/editor_title_bar.cpp
View file

@ -56,7 +56,7 @@ void EditorTitleBar::gui_input(const Ref<InputEvent> &p_event) {
if (w) {
if (mb->get_button_index() == MouseButton::LEFT) {
if (mb->is_pressed()) {
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_WINDOW_DRAG)) {
if (DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_WINDOW_DRAG)) {
DisplayServer::get_singleton()->window_start_drag(w->get_window_id());
} else {
click_pos = DisplayServer::get_singleton()->mouse_get_position() - w->get_position();

2
editor/gui/window_wrapper.cpp
View file

@ -237,7 +237,7 @@ void WindowWrapper::restore_window_from_saved_position(const Rect2 p_window_rect
int screen = p_screen;
Rect2 restored_screen_rect = p_screen_rect;
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_SELF_FITTING_WINDOWS)) {
if (DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_SELF_FITTING_WINDOWS)) {
window_rect = Rect2i();
restored_screen_rect = Rect2i();
}

4
editor/import/3d/scene_import_settings.cpp
View file

@ -1258,8 +1258,8 @@ void SceneImportSettingsDialog::_viewport_input(const Ref<InputEvent> &p_input)
(*rot_x) = CLAMP((*rot_x), -Math::PI / 2, Math::PI / 2);
_update_camera();
}
if (mm.is_valid() && DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_CURSOR_SHAPE)) {
DisplayServer::get_singleton()->cursor_set_shape(DisplayServer::CursorShape::CURSOR_ARROW);
if (mm.is_valid() && DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_CURSOR_SHAPE)) {
DisplayServer::get_singleton()->cursor_set_shape(DisplayServerEnums::CursorShape::CURSOR_ARROW);
}
Ref<InputEventMouseButton> mb = p_input;
if (mb.is_valid() && mb->get_button_index() == MouseButton::WHEEL_DOWN) {

8
editor/project_manager/project_manager.cpp
View file

@ -1299,8 +1299,8 @@ void ProjectManager::_files_dropped(PackedStringArray p_files) {
}
void ProjectManager::_titlebar_resized() {
DisplayServer::get_singleton()->window_set_window_buttons_offset(Vector2i(title_bar->get_global_position().y + title_bar->get_size().y / 2, title_bar->get_global_position().y + title_bar->get_size().y / 2), DisplayServer::MAIN_WINDOW_ID);
const Vector3i &margin = DisplayServer::get_singleton()->window_get_safe_title_margins(DisplayServer::MAIN_WINDOW_ID);
DisplayServer::get_singleton()->window_set_window_buttons_offset(Vector2i(title_bar->get_global_position().y + title_bar->get_size().y / 2, title_bar->get_global_position().y + title_bar->get_size().y / 2), DisplayServerEnums::MAIN_WINDOW_ID);
const Vector3i &margin = DisplayServer::get_singleton()->window_get_safe_title_margins(DisplayServerEnums::MAIN_WINDOW_ID);
if (left_menu_spacer) {
int w = (root_container->is_layout_rtl()) ? margin.y : margin.x;
left_menu_spacer->set_custom_minimum_size(Size2(w, 0));
@ -1422,7 +1422,7 @@ ProjectManager::ProjectManager() {
root_container->add_child(main_vbox);
// Title bar.
bool can_expand = bool(EDITOR_GET("interface/editor/appearance/expand_to_title")) && DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_EXTEND_TO_TITLE);
bool can_expand = bool(EDITOR_GET("interface/editor/appearance/expand_to_title")) && DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_EXTEND_TO_TITLE);
{
title_bar = memnew(EditorTitleBar);
@ -1967,7 +1967,7 @@ ProjectManager::ProjectManager() {
// Extend menu bar to window title.
if (can_expand) {
DisplayServer::get_singleton()->process_events();
DisplayServer::get_singleton()->window_set_flag(DisplayServer::WINDOW_FLAG_EXTEND_TO_TITLE, true, DisplayServer::MAIN_WINDOW_ID);
DisplayServer::get_singleton()->window_set_flag(DisplayServerEnums::WINDOW_FLAG_EXTEND_TO_TITLE, true, DisplayServerEnums::MAIN_WINDOW_ID);
title_bar->set_can_move_window(true);
title_bar->connect(SceneStringName(item_rect_changed), callable_mp(this, &ProjectManager::_titlebar_resized));
}

2
editor/run/editor_run.cpp
View file

@ -286,7 +286,7 @@ EditorRun::WindowPlacement EditorRun::get_window_placement() {
int window_placement = EDITOR_GET("run/window_placement/rect");
if (screen_rect != Rect2()) {
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_HIDPI)) {
if (DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_HIDPI)) {
bool hidpi_proj = GET_CONFIG_WITH_OVERRIDE("display", "window/dpi/allow_hidpi");
int display_scale = 1;

12
editor/run/embedded_process.cpp
View file

@ -193,7 +193,7 @@ void EmbeddedProcess::embed_process(OS::ProcessID p_pid) {
return;
}
ERR_FAIL_COND_MSG(!DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_WINDOW_EMBEDDING), "Embedded process not supported by this display server.");
ERR_FAIL_COND_MSG(!DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_WINDOW_EMBEDDING), "Embedded process not supported by this display server.");
if (current_process_id != 0) {
// Stop embedding the last process.
@ -369,7 +369,7 @@ void EmbeddedProcess::_check_mouse_over() {
}
// Don't grab the focus if mouse over another window.
DisplayServer::WindowID window_id_over = DisplayServer::get_singleton()->get_window_at_screen_position(mouse_position);
DisplayServerEnums::WindowID window_id_over = DisplayServer::get_singleton()->get_window_at_screen_position(mouse_position);
if (window_id_over > 0 && window_id_over != window->get_window_id()) {
return;
}
@ -377,8 +377,8 @@ void EmbeddedProcess::_check_mouse_over() {
// Check if there's an exclusive popup, an open menu, or a tooltip.
// We don't want to grab focus to prevent the game window from coming to the front of the modal window
// or the open menu from closing when the mouse cursor moves outside the menu and over the embedded game.
Vector<DisplayServer::WindowID> wl = DisplayServer::get_singleton()->get_window_list();
for (const DisplayServer::WindowID &window_id : wl) {
Vector<DisplayServerEnums::WindowID> wl = DisplayServer::get_singleton()->get_window_list();
for (const DisplayServerEnums::WindowID &window_id : wl) {
Window *w = Window::get_from_id(window_id);
if (w && (w->is_exclusive() || w->get_flag(Window::FLAG_POPUP))) {
return;
@ -428,8 +428,8 @@ void EmbeddedProcess::_check_focused_process_id() {
}
Window *EmbeddedProcess::_get_current_modal_window() {
Vector<DisplayServer::WindowID> wl = DisplayServer::get_singleton()->get_window_list();
for (const DisplayServer::WindowID &window_id : wl) {
Vector<DisplayServerEnums::WindowID> wl = DisplayServer::get_singleton()->get_window_list();
for (const DisplayServerEnums::WindowID &window_id : wl) {
Window *w = Window::get_from_id(window_id);
if (!w) {
continue;

14
editor/run/game_view_plugin.cpp
View file

@ -723,7 +723,7 @@ void GameView::_update_speed_state_size() {
}
GameView::EmbedAvailability GameView::_get_embed_available() {
if (!DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_WINDOW_EMBEDDING)) {
if (!DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_WINDOW_EMBEDDING)) {
return EMBED_NOT_AVAILABLE_FEATURE_NOT_SUPPORTED;
}
if (get_tree()->get_root()->is_embedding_subwindows()) {
@ -750,14 +750,14 @@ GameView::EmbedAvailability GameView::_get_embed_available() {
return EMBED_NOT_AVAILABLE_MAXIMIZED;
}
DisplayServer::WindowMode window_mode = (DisplayServer::WindowMode)(GLOBAL_GET("display/window/size/mode").operator int());
if (window_mode == DisplayServer::WindowMode::WINDOW_MODE_MINIMIZED) {
DisplayServerEnums::WindowMode window_mode = (DisplayServerEnums::WindowMode)(GLOBAL_GET("display/window/size/mode").operator int());
if (window_mode == DisplayServerEnums::WindowMode::WINDOW_MODE_MINIMIZED) {
return EMBED_NOT_AVAILABLE_MINIMIZED;
}
if (window_mode == DisplayServer::WindowMode::WINDOW_MODE_MAXIMIZED) {
if (window_mode == DisplayServerEnums::WindowMode::WINDOW_MODE_MAXIMIZED) {
return EMBED_NOT_AVAILABLE_MAXIMIZED;
}
if (window_mode == DisplayServer::WindowMode::WINDOW_MODE_FULLSCREEN || window_mode == DisplayServer::WindowMode::WINDOW_MODE_EXCLUSIVE_FULLSCREEN) {
if (window_mode == DisplayServerEnums::WindowMode::WINDOW_MODE_FULLSCREEN || window_mode == DisplayServerEnums::WindowMode::WINDOW_MODE_EXCLUSIVE_FULLSCREEN) {
return EMBED_NOT_AVAILABLE_FULLSCREEN;
}
@ -945,7 +945,7 @@ void GameView::_notification(int p_what) {
} break;
case NOTIFICATION_READY: {
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_WINDOW_EMBEDDING)) {
if (DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_WINDOW_EMBEDDING)) {
// Embedding available.
int game_mode = EDITOR_GET("run/window_placement/game_embed_mode");
switch (game_mode) {
@ -1099,7 +1099,7 @@ void GameView::_update_arguments_for_instance(int p_idx, List<String> &r_argumen
// Add the editor window's native ID so the started game can directly set it as its parent.
List<String>::Element *N = r_arguments.insert_before(user_args_element, "--wid");
N = r_arguments.insert_after(N, itos(DisplayServer::get_singleton()->window_get_native_handle(DisplayServer::WINDOW_HANDLE, get_window()->get_window_id())));
N = r_arguments.insert_after(N, itos(DisplayServer::get_singleton()->window_get_native_handle(DisplayServerEnums::WINDOW_HANDLE, get_window()->get_window_id())));
#if MACOS_ENABLED
N = r_arguments.insert_after(N, "--embedded");

2
editor/script/script_editor_base.cpp
View file

@ -274,7 +274,7 @@ TextEditorBase::EditMenus::EditMenus() {
void TextEditorBase::_make_context_menu(bool p_selection, bool p_foldable, const Vector2 &p_position, bool p_show) {
context_menu->clear();
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_EMOJI_AND_SYMBOL_PICKER)) {
if (DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_EMOJI_AND_SYMBOL_PICKER)) {
context_menu->add_item(TTRC("Emoji & Symbols"), EDIT_EMOJI_AND_SYMBOL);
context_menu->add_separator();
}

4
editor/settings/editor_settings.cpp
View file

@ -1947,12 +1947,12 @@ String EditorSettings::get_editor_layouts_config() const {
float EditorSettings::get_auto_display_scale() {
#ifdef LINUXBSD_ENABLED
if (DisplayServer::get_singleton()->get_name() == "Wayland") {
float main_window_scale = DisplayServer::get_singleton()->screen_get_scale(DisplayServer::SCREEN_OF_MAIN_WINDOW);
float main_window_scale = DisplayServer::get_singleton()->screen_get_scale(DisplayServerEnums::SCREEN_OF_MAIN_WINDOW);
if (DisplayServer::get_singleton()->get_screen_count() == 1 || Math::fract(main_window_scale) != 0) {
// If we have a single screen or the screen of the window is fractional, all
// bets are off. At this point, let's just return the current's window scale,
// which is special-cased to the scale of `SCREEN_OF_MAIN_WINDOW`.
// which is special-cased to the scale of `DisplayServerEnums::SCREEN_OF_MAIN_WINDOW`.
return main_window_scale;
}

1
editor/settings/editor_settings.h
View file

@ -60,6 +60,7 @@ public:
NETWORK_ONLINE,
};
// Keep values synced with DisplayServerEnums constants.
enum InitialScreen {
INITIAL_SCREEN_AUTO = -5, // Remembers last screen position.
INITIAL_SCREEN_WITH_MOUSE_FOCUS = -4,

2
editor/shader/text_shader_editor.cpp
View file

@ -1161,7 +1161,7 @@ void TextShaderEditor::_bookmark_item_pressed(int p_idx) {
void TextShaderEditor::_make_context_menu(bool p_selection, Vector2 p_position) {
context_menu->clear();
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_EMOJI_AND_SYMBOL_PICKER)) {
if (DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_EMOJI_AND_SYMBOL_PICKER)) {
context_menu->add_item(TTR("Emoji & Symbols"), EDIT_EMOJI_AND_SYMBOL);
context_menu->add_separator();
}

110
main/main.cpp
View file

@ -235,13 +235,13 @@ static bool single_threaded_scene = false;
// Display
static DisplayServer::WindowMode window_mode = DisplayServer::WINDOW_MODE_WINDOWED;
static DisplayServer::ScreenOrientation window_orientation = DisplayServer::SCREEN_LANDSCAPE;
static DisplayServer::VSyncMode window_vsync_mode = DisplayServer::VSYNC_ENABLED;
static DisplayServerEnums::WindowMode window_mode = DisplayServerEnums::WINDOW_MODE_WINDOWED;
static DisplayServerEnums::ScreenOrientation window_orientation = DisplayServerEnums::SCREEN_LANDSCAPE;
static DisplayServerEnums::VSyncMode window_vsync_mode = DisplayServerEnums::VSYNC_ENABLED;
static uint32_t window_flags = 0;
static Size2i window_size = Size2i(1152, 648);
static int init_screen = DisplayServer::SCREEN_PRIMARY;
static int init_screen = DisplayServerEnums::SCREEN_PRIMARY;
static bool init_fullscreen = false;
static bool init_maximized = false;
static bool init_windowed = false;
@ -1302,10 +1302,10 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph
}
} else if (arg == "-f" || arg == "--fullscreen") { // force fullscreen
init_fullscreen = true;
window_mode = DisplayServer::WINDOW_MODE_FULLSCREEN;
window_mode = DisplayServerEnums::WINDOW_MODE_FULLSCREEN;
} else if (arg == "-m" || arg == "--maximized") { // force maximized window
init_maximized = true;
window_mode = DisplayServer::WINDOW_MODE_MAXIMIZED;
window_mode = DisplayServerEnums::WINDOW_MODE_MAXIMIZED;
} else if (arg == "-w" || arg == "--windowed") { // force windowed window
init_windowed = true;
@ -2174,7 +2174,7 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph
main_args.push_back("--editor");
if (!init_windowed && !init_fullscreen) {
init_maximized = true;
window_mode = DisplayServer::WINDOW_MODE_MAXIMIZED;
window_mode = DisplayServerEnums::WINDOW_MODE_MAXIMIZED;
}
}
@ -2645,33 +2645,33 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph
}
if (!bool(GLOBAL_GET("display/window/size/resizable"))) {
window_flags |= DisplayServer::WINDOW_FLAG_RESIZE_DISABLED_BIT;
window_flags |= DisplayServerEnums::WINDOW_FLAG_RESIZE_DISABLED_BIT;
}
if (bool(GLOBAL_GET("display/window/size/minimize_disabled"))) {
window_flags |= DisplayServer::WINDOW_FLAG_MINIMIZE_DISABLED_BIT;
window_flags |= DisplayServerEnums::WINDOW_FLAG_MINIMIZE_DISABLED_BIT;
}
if (bool(GLOBAL_GET("display/window/size/maximize_disabled"))) {
window_flags |= DisplayServer::WINDOW_FLAG_MAXIMIZE_DISABLED_BIT;
window_flags |= DisplayServerEnums::WINDOW_FLAG_MAXIMIZE_DISABLED_BIT;
}
if (bool(GLOBAL_GET("display/window/size/borderless"))) {
window_flags |= DisplayServer::WINDOW_FLAG_BORDERLESS_BIT;
window_flags |= DisplayServerEnums::WINDOW_FLAG_BORDERLESS_BIT;
}
if (bool(GLOBAL_GET("display/window/size/always_on_top"))) {
window_flags |= DisplayServer::WINDOW_FLAG_ALWAYS_ON_TOP_BIT;
window_flags |= DisplayServerEnums::WINDOW_FLAG_ALWAYS_ON_TOP_BIT;
}
if (bool(GLOBAL_GET("display/window/size/transparent"))) {
window_flags |= DisplayServer::WINDOW_FLAG_TRANSPARENT_BIT;
window_flags |= DisplayServerEnums::WINDOW_FLAG_TRANSPARENT_BIT;
}
if (bool(GLOBAL_GET("display/window/size/extend_to_title"))) {
window_flags |= DisplayServer::WINDOW_FLAG_EXTEND_TO_TITLE_BIT;
window_flags |= DisplayServerEnums::WINDOW_FLAG_EXTEND_TO_TITLE_BIT;
}
if (bool(GLOBAL_GET("display/window/size/no_focus"))) {
window_flags |= DisplayServer::WINDOW_FLAG_NO_FOCUS_BIT;
window_flags |= DisplayServerEnums::WINDOW_FLAG_NO_FOCUS_BIT;
}
if (bool(GLOBAL_GET("display/window/size/sharp_corners"))) {
window_flags |= DisplayServer::WINDOW_FLAG_SHARP_CORNERS_BIT;
window_flags |= DisplayServerEnums::WINDOW_FLAG_SHARP_CORNERS_BIT;
}
window_mode = (DisplayServer::WindowMode)(GLOBAL_GET("display/window/size/mode").operator int());
window_mode = (DisplayServerEnums::WindowMode)(GLOBAL_GET("display/window/size/mode").operator int());
int initial_position_type = GLOBAL_GET("display/window/size/initial_position_type").operator int();
if (initial_position_type == Window::WINDOW_INITIAL_POSITION_ABSOLUTE) { // Absolute.
if (!init_use_custom_pos) {
@ -2680,7 +2680,7 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph
}
} else if (initial_position_type == Window::WINDOW_INITIAL_POSITION_CENTER_PRIMARY_SCREEN || initial_position_type == Window::WINDOW_INITIAL_POSITION_CENTER_MAIN_WINDOW_SCREEN) { // Center of Primary Screen.
if (!init_use_custom_screen) {
init_screen = DisplayServer::SCREEN_PRIMARY;
init_screen = DisplayServerEnums::SCREEN_PRIMARY;
init_use_custom_screen = true;
}
} else if (initial_position_type == Window::WINDOW_INITIAL_POSITION_CENTER_OTHER_SCREEN) { // Center of Other Screen.
@ -2690,12 +2690,12 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph
}
} else if (initial_position_type == Window::WINDOW_INITIAL_POSITION_CENTER_SCREEN_WITH_MOUSE_FOCUS) { // Center of Screen With Mouse Pointer.
if (!init_use_custom_screen) {
init_screen = DisplayServer::SCREEN_WITH_MOUSE_FOCUS;
init_screen = DisplayServerEnums::SCREEN_WITH_MOUSE_FOCUS;
init_use_custom_screen = true;
}
} else if (initial_position_type == Window::WINDOW_INITIAL_POSITION_CENTER_SCREEN_WITH_KEYBOARD_FOCUS) { // Center of Screen With Keyboard Focus.
if (!init_use_custom_screen) {
init_screen = DisplayServer::SCREEN_WITH_KEYBOARD_FOCUS;
init_screen = DisplayServerEnums::SCREEN_WITH_KEYBOARD_FOCUS;
init_use_custom_screen = true;
}
}
@ -2778,12 +2778,12 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph
}
{
window_orientation = DisplayServer::ScreenOrientation(int(GLOBAL_DEF_BASIC("display/window/handheld/orientation", DisplayServer::ScreenOrientation::SCREEN_LANDSCAPE)));
window_orientation = DisplayServerEnums::ScreenOrientation(int(GLOBAL_DEF_BASIC("display/window/handheld/orientation", DisplayServerEnums::ScreenOrientation::SCREEN_LANDSCAPE)));
}
{
window_vsync_mode = DisplayServer::VSyncMode(int(GLOBAL_DEF_BASIC("display/window/vsync/vsync_mode", DisplayServer::VSyncMode::VSYNC_ENABLED)));
window_vsync_mode = DisplayServerEnums::VSyncMode(int(GLOBAL_DEF_BASIC("display/window/vsync/vsync_mode", DisplayServerEnums::VSyncMode::VSYNC_ENABLED)));
if (disable_vsync) {
window_vsync_mode = DisplayServer::VSyncMode::VSYNC_DISABLED;
window_vsync_mode = DisplayServerEnums::VSyncMode::VSYNC_DISABLED;
}
}
@ -3115,13 +3115,13 @@ Error Main::setup2(bool p_show_boot_logo) {
String mode = config->get_value("EditorWindow", "mode", "maximized");
window_size = config->get_value("EditorWindow", "size", window_size);
if (mode == "windowed") {
window_mode = DisplayServer::WINDOW_MODE_WINDOWED;
window_mode = DisplayServerEnums::WINDOW_MODE_WINDOWED;
init_windowed = true;
} else if (mode == "fullscreen") {
window_mode = DisplayServer::WINDOW_MODE_FULLSCREEN;
window_mode = DisplayServerEnums::WINDOW_MODE_FULLSCREEN;
init_fullscreen = true;
} else {
window_mode = DisplayServer::WINDOW_MODE_MAXIMIZED;
window_mode = DisplayServerEnums::WINDOW_MODE_MAXIMIZED;
init_maximized = true;
}
@ -3133,7 +3133,7 @@ Error Main::setup2(bool p_show_boot_logo) {
}
if (init_screen == EditorSettings::InitialScreen::INITIAL_SCREEN_AUTO) {
init_screen = DisplayServer::SCREEN_PRIMARY;
init_screen = DisplayServerEnums::SCREEN_PRIMARY;
}
OS::get_singleton()->benchmark_end_measure("Startup", "Initialize Early Settings");
@ -3222,28 +3222,28 @@ Error Main::setup2(bool p_show_boot_logo) {
Color boot_bg_color = GLOBAL_DEF_BASIC("application/boot_splash/bg_color", boot_splash_bg_color);
DisplayServer::set_early_window_clear_color_override(true, boot_bg_color);
DisplayServer::Context context;
DisplayServerEnums::Context context;
if (editor) {
context = DisplayServer::CONTEXT_EDITOR;
context = DisplayServerEnums::CONTEXT_EDITOR;
} else if (project_manager) {
context = DisplayServer::CONTEXT_PROJECTMAN;
context = DisplayServerEnums::CONTEXT_PROJECTMAN;
} else {
context = DisplayServer::CONTEXT_ENGINE;
context = DisplayServerEnums::CONTEXT_ENGINE;
}
if (init_embed_parent_window_id) {
// Reset flags and other settings to be sure it's borderless and windowed. The position and size should have been initialized correctly
// from --position and --resolution parameters.
window_mode = DisplayServer::WINDOW_MODE_WINDOWED;
window_flags = DisplayServer::WINDOW_FLAG_BORDERLESS_BIT;
window_mode = DisplayServerEnums::WINDOW_MODE_WINDOWED;
window_flags = DisplayServerEnums::WINDOW_FLAG_BORDERLESS_BIT;
if (bool(GLOBAL_GET("display/window/size/transparent"))) {
window_flags |= DisplayServer::WINDOW_FLAG_TRANSPARENT_BIT;
window_flags |= DisplayServerEnums::WINDOW_FLAG_TRANSPARENT_BIT;
}
}
#ifdef TOOLS_ENABLED
if ((project_manager || editor) && init_expand_to_title) {
window_flags |= DisplayServer::WINDOW_FLAG_EXTEND_TO_TITLE_BIT;
window_flags |= DisplayServerEnums::WINDOW_FLAG_EXTEND_TO_TITLE_BIT;
}
#endif
@ -3390,20 +3390,20 @@ Error Main::setup2(bool p_show_boot_logo) {
break;
}
if (!(force_res || use_custom_res)) {
display_server->window_set_size(Size2(window_size) * ui_scale, DisplayServer::MAIN_WINDOW_ID);
display_server->window_set_size(Size2(window_size) * ui_scale, DisplayServerEnums::MAIN_WINDOW_ID);
}
if (display_server->has_feature(DisplayServer::FEATURE_SUBWINDOWS) && !display_server->has_feature(DisplayServer::FEATURE_SELF_FITTING_WINDOWS)) {
if (display_server->has_feature(DisplayServerEnums::FEATURE_SUBWINDOWS) && !display_server->has_feature(DisplayServerEnums::FEATURE_SELF_FITTING_WINDOWS)) {
Size2 real_size = DisplayServer::get_singleton()->window_get_size();
Rect2i scr_rect = display_server->screen_get_usable_rect(init_screen);
display_server->window_set_position(scr_rect.position + (scr_rect.size - real_size) / 2, DisplayServer::MAIN_WINDOW_ID);
display_server->window_set_position(scr_rect.position + (scr_rect.size - real_size) / 2, DisplayServerEnums::MAIN_WINDOW_ID);
}
}
#endif
if (display_server->has_feature(DisplayServer::FEATURE_SUBWINDOWS)) {
display_server->show_window(DisplayServer::MAIN_WINDOW_ID);
if (display_server->has_feature(DisplayServerEnums::FEATURE_SUBWINDOWS)) {
display_server->show_window(DisplayServerEnums::MAIN_WINDOW_ID);
}
if (display_server->has_feature(DisplayServer::FEATURE_ORIENTATION)) {
if (display_server->has_feature(DisplayServerEnums::FEATURE_ORIENTATION)) {
display_server->screen_set_orientation(window_orientation);
}
@ -3422,7 +3422,7 @@ Error Main::setup2(bool p_show_boot_logo) {
if (editor && init_windowed) {
// We still need to check we are actually in windowed mode, because
// certain platform might only support one fullscreen window.
if (DisplayServer::get_singleton()->window_get_mode() == DisplayServer::WINDOW_MODE_WINDOWED) {
if (DisplayServer::get_singleton()->window_get_mode() == DisplayServerEnums::WINDOW_MODE_WINDOWED) {
Vector2i current_size = DisplayServer::get_singleton()->window_get_size();
Vector2i current_pos = DisplayServer::get_singleton()->window_get_position();
int screen = DisplayServer::get_singleton()->window_get_current_screen();
@ -3443,16 +3443,16 @@ Error Main::setup2(bool p_show_boot_logo) {
if (GLOBAL_GET("debug/settings/stdout/print_fps") || print_fps) {
// Print requested V-Sync mode at startup to diagnose the printed FPS not going above the monitor refresh rate.
switch (window_vsync_mode) {
case DisplayServer::VSyncMode::VSYNC_DISABLED:
case DisplayServerEnums::VSyncMode::VSYNC_DISABLED:
print_line("Requested V-Sync mode: Disabled");
break;
case DisplayServer::VSyncMode::VSYNC_ENABLED:
case DisplayServerEnums::VSyncMode::VSYNC_ENABLED:
print_line("Requested V-Sync mode: Enabled - FPS will likely be capped to the monitor refresh rate.");
break;
case DisplayServer::VSyncMode::VSYNC_ADAPTIVE:
case DisplayServerEnums::VSyncMode::VSYNC_ADAPTIVE:
print_line("Requested V-Sync mode: Adaptive");
break;
case DisplayServer::VSyncMode::VSYNC_MAILBOX:
case DisplayServerEnums::VSyncMode::VSYNC_MAILBOX:
print_line("Requested V-Sync mode: Mailbox");
break;
}
@ -3572,12 +3572,12 @@ Error Main::setup2(bool p_show_boot_logo) {
if (init_windowed) {
//do none..
} else if (init_maximized) {
DisplayServer::get_singleton()->window_set_mode(DisplayServer::WINDOW_MODE_MAXIMIZED);
DisplayServer::get_singleton()->window_set_mode(DisplayServerEnums::WINDOW_MODE_MAXIMIZED);
} else if (init_fullscreen) {
DisplayServer::get_singleton()->window_set_mode(DisplayServer::WINDOW_MODE_FULLSCREEN);
DisplayServer::get_singleton()->window_set_mode(DisplayServerEnums::WINDOW_MODE_FULLSCREEN);
}
if (init_always_on_top) {
DisplayServer::get_singleton()->window_set_flag(DisplayServer::WINDOW_FLAG_ALWAYS_ON_TOP, true);
DisplayServer::get_singleton()->window_set_flag(DisplayServerEnums::WINDOW_FLAG_ALWAYS_ON_TOP, true);
}
}
@ -3934,7 +3934,7 @@ void Main::setup_boot_logo() {
}
#if defined(TOOLS_ENABLED) && defined(MACOS_ENABLED)
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_ICON) && OS::get_singleton()->get_bundle_icon_path().is_empty()) {
if (DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_ICON) && OS::get_singleton()->get_bundle_icon_path().is_empty()) {
Ref<Image> icon = memnew(Image(app_icon_png));
DisplayServer::get_singleton()->set_icon(icon);
}
@ -4431,7 +4431,7 @@ int Main::start() {
bool embed_subwindows = GLOBAL_GET("display/window/subwindows/embed_subwindows");
if (single_window || (!project_manager && !editor && embed_subwindows) || !DisplayServer::get_singleton()->has_feature(DisplayServer::Feature::FEATURE_SUBWINDOWS)) {
if (single_window || (!project_manager && !editor && embed_subwindows) || !DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_SUBWINDOWS)) {
sml->get_root()->set_embedding_subwindows(true);
}
@ -4718,7 +4718,7 @@ int Main::start() {
}
#endif
String mac_icon_path = GLOBAL_GET("application/config/macos_native_icon");
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_NATIVE_ICON) && !mac_icon_path.is_empty() && !has_icon) {
if (DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_NATIVE_ICON) && !mac_icon_path.is_empty() && !has_icon) {
DisplayServer::get_singleton()->set_native_icon(mac_icon_path);
has_icon = true;
}
@ -4726,14 +4726,14 @@ int Main::start() {
#ifdef WINDOWS_ENABLED
String win_icon_path = GLOBAL_GET("application/config/windows_native_icon");
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_NATIVE_ICON) && !win_icon_path.is_empty()) {
if (DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_NATIVE_ICON) && !win_icon_path.is_empty()) {
DisplayServer::get_singleton()->set_native_icon(win_icon_path);
has_icon = true;
}
#endif
String icon_path = GLOBAL_GET("application/config/icon");
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_ICON) && !icon_path.is_empty() && !has_icon) {
if (DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_ICON) && !icon_path.is_empty() && !has_icon) {
Ref<Image> icon;
icon.instantiate();
if (ImageLoader::load_image(icon_path, icon) == OK) {
@ -4776,7 +4776,7 @@ int Main::start() {
#endif
}
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_ICON) && !has_icon && OS::get_singleton()->get_bundle_icon_path().is_empty()) {
if (DisplayServer::get_singleton()->has_feature(DisplayServerEnums::FEATURE_ICON) && !has_icon && OS::get_singleton()->get_bundle_icon_path().is_empty()) {
Ref<Image> icon = memnew(Image(app_icon_png));
DisplayServer::get_singleton()->set_icon(icon);
}

4
main/main_timer_sync.cpp
View file

@ -243,8 +243,8 @@ int64_t MainTimerSync::DeltaSmoother::smooth_delta(int64_t p_delta) {
}
// only attempt smoothing if vsync is selected
DisplayServer::VSyncMode vsync_mode = DisplayServer::get_singleton()->window_get_vsync_mode(DisplayServer::MAIN_WINDOW_ID);
if (vsync_mode != DisplayServer::VSYNC_ENABLED) {
DisplayServerEnums::VSyncMode vsync_mode = DisplayServer::get_singleton()->window_get_vsync_mode(DisplayServerEnums::MAIN_WINDOW_ID);
if (vsync_mode != DisplayServerEnums::VSYNC_ENABLED) {
return p_delta;
}

24
modules/openxr/extensions/platform/openxr_opengl_extension.cpp
View file

@ -156,15 +156,15 @@ void *OpenXROpenGLExtension::set_session_create_and_get_next_pointer(void *p_nex
graphics_binding_gl.type = XR_TYPE_GRAPHICS_BINDING_OPENGL_WIN32_KHR,
graphics_binding_gl.next = p_next_pointer;
graphics_binding_gl.hDC = (HDC)display_server->window_get_native_handle(DisplayServer::WINDOW_VIEW);
graphics_binding_gl.hGLRC = (HGLRC)display_server->window_get_native_handle(DisplayServer::OPENGL_CONTEXT);
graphics_binding_gl.hDC = (HDC)display_server->window_get_native_handle(DisplayServerEnums::WINDOW_VIEW);
graphics_binding_gl.hGLRC = (HGLRC)display_server->window_get_native_handle(DisplayServerEnums::OPENGL_CONTEXT);
#elif defined(ANDROID_ENABLED)
graphics_binding_gl.type = XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR;
graphics_binding_gl.next = p_next_pointer;
graphics_binding_gl.display = (void *)display_server->window_get_native_handle(DisplayServer::DISPLAY_HANDLE);
graphics_binding_gl.display = (void *)display_server->window_get_native_handle(DisplayServerEnums::DISPLAY_HANDLE);
graphics_binding_gl.config = (EGLConfig)0; // https://github.com/KhronosGroup/OpenXR-SDK-Source/blob/master/src/tests/hello_xr/graphicsplugin_opengles.cpp#L122
graphics_binding_gl.context = (void *)display_server->window_get_native_handle(DisplayServer::OPENGL_CONTEXT);
graphics_binding_gl.context = (void *)display_server->window_get_native_handle(DisplayServerEnums::OPENGL_CONTEXT);
#else
#if defined(EGL_ENABLED) && defined(WAYLAND_ENABLED)
if (display_server->get_name() == "Wayland") {
@ -174,9 +174,9 @@ void *OpenXROpenGLExtension::set_session_create_and_get_next_pointer(void *p_nex
graphics_binding_egl.next = p_next_pointer;
graphics_binding_egl.getProcAddress = eglGetProcAddress;
graphics_binding_egl.display = (void *)display_server->window_get_native_handle(DisplayServer::EGL_DISPLAY);
graphics_binding_egl.config = (void *)display_server->window_get_native_handle(DisplayServer::EGL_CONFIG);
graphics_binding_egl.context = (void *)display_server->window_get_native_handle(DisplayServer::OPENGL_CONTEXT);
graphics_binding_egl.display = (void *)display_server->window_get_native_handle(DisplayServerEnums::EGL_DISPLAY);
graphics_binding_egl.config = (void *)display_server->window_get_native_handle(DisplayServerEnums::EGL_CONFIG);
graphics_binding_egl.context = (void *)display_server->window_get_native_handle(DisplayServerEnums::OPENGL_CONTEXT);
return &graphics_binding_egl;
}
@ -185,11 +185,11 @@ void *OpenXROpenGLExtension::set_session_create_and_get_next_pointer(void *p_nex
graphics_binding_gl.type = XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR;
graphics_binding_gl.next = p_next_pointer;
void *display_handle = (void *)display_server->window_get_native_handle(DisplayServer::DISPLAY_HANDLE);
void *glxcontext_handle = (void *)display_server->window_get_native_handle(DisplayServer::OPENGL_CONTEXT);
void *glxdrawable_handle = (void *)display_server->window_get_native_handle(DisplayServer::WINDOW_HANDLE);
void *glx_fbconfig_handle = (void *)display_server->window_get_native_handle(DisplayServer::GLX_FBCONFIG);
VisualID glx_visualid = (VisualID)display_server->window_get_native_handle(DisplayServer::GLX_VISUALID);
void *display_handle = (void *)display_server->window_get_native_handle(DisplayServerEnums::DISPLAY_HANDLE);
void *glxcontext_handle = (void *)display_server->window_get_native_handle(DisplayServerEnums::OPENGL_CONTEXT);
void *glxdrawable_handle = (void *)display_server->window_get_native_handle(DisplayServerEnums::WINDOW_HANDLE);
void *glx_fbconfig_handle = (void *)display_server->window_get_native_handle(DisplayServerEnums::GLX_FBCONFIG);
VisualID glx_visualid = (VisualID)display_server->window_get_native_handle(DisplayServerEnums::GLX_VISUALID);
graphics_binding_gl.xDisplay = (Display *)display_handle;
graphics_binding_gl.glxContext = (GLXContext)glxcontext_handle;

2
platform/android/android_input_handler.cpp
View file

@ -134,7 +134,7 @@ void AndroidInputHandler::process_key_event(int p_physical_keycode, int p_unicod
if (p_physical_keycode == AKEYCODE_BACK && p_pressed) {
if (DisplayServerAndroid *dsa = Object::cast_to<DisplayServerAndroid>(DisplayServer::get_singleton())) {
dsa->send_window_event(DisplayServer::WINDOW_EVENT_GO_BACK_REQUEST, true);
dsa->send_window_event(DisplayServerEnums::WINDOW_EVENT_GO_BACK_REQUEST, true);
}
}

226
platform/android/display_server_android.cpp
View file

@ -64,33 +64,33 @@ DisplayServerAndroid *DisplayServerAndroid::get_singleton() {
return static_cast<DisplayServerAndroid *>(DisplayServer::get_singleton());
}
bool DisplayServerAndroid::has_feature(Feature p_feature) const {
bool DisplayServerAndroid::has_feature(DisplayServerEnums::Feature p_feature) const {
switch (p_feature) {
#ifndef DISABLE_DEPRECATED
case FEATURE_GLOBAL_MENU: {
case DisplayServerEnums::FEATURE_GLOBAL_MENU: {
return (native_menu && native_menu->has_feature(NativeMenu::FEATURE_GLOBAL_MENU));
} break;
#endif
case FEATURE_CURSOR_SHAPE:
//case FEATURE_CUSTOM_CURSOR_SHAPE:
//case FEATURE_HIDPI:
//case FEATURE_ICON:
//case FEATURE_IME:
case FEATURE_MOUSE:
//case FEATURE_MOUSE_WARP:
case FEATURE_NATIVE_DIALOG:
case FEATURE_NATIVE_DIALOG_INPUT:
case FEATURE_NATIVE_DIALOG_FILE:
//case FEATURE_NATIVE_DIALOG_FILE_EXTRA:
case FEATURE_NATIVE_DIALOG_FILE_MIME:
//case FEATURE_NATIVE_ICON:
case FEATURE_WINDOW_TRANSPARENCY:
case FEATURE_CLIPBOARD:
case FEATURE_KEEP_SCREEN_ON:
case FEATURE_ORIENTATION:
case FEATURE_TOUCHSCREEN:
case FEATURE_VIRTUAL_KEYBOARD:
case FEATURE_TEXT_TO_SPEECH:
case DisplayServerEnums::FEATURE_CURSOR_SHAPE:
//case DisplayServerEnums::FEATURE_CUSTOM_CURSOR_SHAPE:
//case DisplayServerEnums::FEATURE_HIDPI:
//case DisplayServerEnums::FEATURE_ICON:
//case DisplayServerEnums::FEATURE_IME:
case DisplayServerEnums::FEATURE_MOUSE:
//case DisplayServerEnums::FEATURE_MOUSE_WARP:
case DisplayServerEnums::FEATURE_NATIVE_DIALOG:
case DisplayServerEnums::FEATURE_NATIVE_DIALOG_INPUT:
case DisplayServerEnums::FEATURE_NATIVE_DIALOG_FILE:
//case DisplayServerEnums::FEATURE_NATIVE_DIALOG_FILE_EXTRA:
case DisplayServerEnums::FEATURE_NATIVE_DIALOG_FILE_MIME:
//case DisplayServerEnums::FEATURE_NATIVE_ICON:
case DisplayServerEnums::FEATURE_WINDOW_TRANSPARENCY:
case DisplayServerEnums::FEATURE_CLIPBOARD:
case DisplayServerEnums::FEATURE_KEEP_SCREEN_ON:
case DisplayServerEnums::FEATURE_ORIENTATION:
case DisplayServerEnums::FEATURE_TOUCHSCREEN:
case DisplayServerEnums::FEATURE_VIRTUAL_KEYBOARD:
case DisplayServerEnums::FEATURE_TEXT_TO_SPEECH:
return true;
default:
return false;
@ -222,7 +222,7 @@ void DisplayServerAndroid::emit_input_dialog_callback(String p_text) {
}
}
Error DisplayServerAndroid::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, WindowID p_window_id) {
Error DisplayServerAndroid::file_dialog_show(const String &p_title, const String &p_current_directory, const String &p_filename, bool p_show_hidden, DisplayServerEnums::FileDialogMode p_mode, const Vector<String> &p_filters, const Callable &p_callback, DisplayServerEnums::WindowID p_window_id) {
GodotJavaWrapper *godot_java = OS_Android::get_singleton()->get_godot_java();
ERR_FAIL_NULL_V(godot_java, FAILED);
file_picker_callback = p_callback;
@ -271,7 +271,7 @@ bool DisplayServerAndroid::screen_is_kept_on() const {
return keep_screen_on;
}
void DisplayServerAndroid::screen_set_orientation(DisplayServer::ScreenOrientation p_orientation, int p_screen) {
void DisplayServerAndroid::screen_set_orientation(DisplayServerEnums::ScreenOrientation p_orientation, int p_screen) {
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX(p_screen, screen_count);
@ -282,17 +282,17 @@ void DisplayServerAndroid::screen_set_orientation(DisplayServer::ScreenOrientati
godot_io_java->set_screen_orientation(p_orientation);
}
DisplayServer::ScreenOrientation DisplayServerAndroid::screen_get_orientation(int p_screen) const {
DisplayServerEnums::ScreenOrientation DisplayServerAndroid::screen_get_orientation(int p_screen) const {
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, SCREEN_LANDSCAPE);
ERR_FAIL_INDEX_V(p_screen, screen_count, DisplayServerEnums::SCREEN_LANDSCAPE);
GodotIOJavaWrapper *godot_io_java = OS_Android::get_singleton()->get_godot_io_java();
ERR_FAIL_NULL_V(godot_io_java, SCREEN_LANDSCAPE);
ERR_FAIL_NULL_V(godot_io_java, DisplayServerEnums::SCREEN_LANDSCAPE);
const int orientation = godot_io_java->get_screen_orientation();
ERR_FAIL_INDEX_V_MSG(orientation, 7, SCREEN_LANDSCAPE, "Unrecognized screen orientation");
return (ScreenOrientation)orientation;
ERR_FAIL_INDEX_V_MSG(orientation, 7, DisplayServerEnums::SCREEN_LANDSCAPE, "Unrecognized screen orientation");
return (DisplayServerEnums::ScreenOrientation)orientation;
}
int DisplayServerAndroid::get_display_rotation() const {
@ -385,7 +385,7 @@ bool DisplayServerAndroid::is_touchscreen_available() const {
return true;
}
void DisplayServerAndroid::virtual_keyboard_show(const String &p_existing_text, const Rect2 &p_screen_rect, VirtualKeyboardType p_type, int p_max_length, int p_cursor_start, int p_cursor_end) {
void DisplayServerAndroid::virtual_keyboard_show(const String &p_existing_text, const Rect2 &p_screen_rect, DisplayServerEnums::VirtualKeyboardType p_type, int p_max_length, int p_cursor_start, int p_cursor_end) {
GodotIOJavaWrapper *godot_io_java = OS_Android::get_singleton()->get_godot_io_java();
ERR_FAIL_NULL(godot_io_java);
@ -421,23 +421,23 @@ bool DisplayServerAndroid::has_hardware_keyboard() const {
return godot_io_java->has_hardware_keyboard();
}
void DisplayServerAndroid::window_set_window_event_callback(const Callable &p_callable, DisplayServer::WindowID p_window) {
void DisplayServerAndroid::window_set_window_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
window_event_callback = p_callable;
}
void DisplayServerAndroid::window_set_input_event_callback(const Callable &p_callable, DisplayServer::WindowID p_window) {
void DisplayServerAndroid::window_set_input_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
input_event_callback = p_callable;
}
void DisplayServerAndroid::window_set_input_text_callback(const Callable &p_callable, DisplayServer::WindowID p_window) {
void DisplayServerAndroid::window_set_input_text_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
input_text_callback = p_callable;
}
void DisplayServerAndroid::window_set_rect_changed_callback(const Callable &p_callable, DisplayServer::WindowID p_window) {
void DisplayServerAndroid::window_set_rect_changed_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
rect_changed_callback = p_callable;
}
void DisplayServerAndroid::window_set_drop_files_callback(const Callable &p_callable, DisplayServer::WindowID p_window) {
void DisplayServerAndroid::window_set_drop_files_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
// Not supported on Android.
}
@ -452,7 +452,7 @@ void DisplayServerAndroid::_window_callback(const Callable &p_callable, bool p_d
}
}
void DisplayServerAndroid::send_window_event(DisplayServer::WindowEvent p_event, bool p_deferred) const {
void DisplayServerAndroid::send_window_event(DisplayServerEnums::WindowEvent p_event, bool p_deferred) const {
_window_callback(window_event_callback, p_deferred, int(p_event));
}
@ -468,43 +468,43 @@ void DisplayServerAndroid::_dispatch_input_events(const Ref<InputEvent> &p_event
DisplayServerAndroid::get_singleton()->send_input_event(p_event);
}
Vector<DisplayServer::WindowID> DisplayServerAndroid::get_window_list() const {
Vector<WindowID> ret;
ret.push_back(MAIN_WINDOW_ID);
Vector<DisplayServerEnums::WindowID> DisplayServerAndroid::get_window_list() const {
Vector<DisplayServerEnums::WindowID> ret;
ret.push_back(DisplayServerEnums::MAIN_WINDOW_ID);
return ret;
}
DisplayServer::WindowID DisplayServerAndroid::get_window_at_screen_position(const Point2i &p_position) const {
return MAIN_WINDOW_ID;
DisplayServerEnums::WindowID DisplayServerAndroid::get_window_at_screen_position(const Point2i &p_position) const {
return DisplayServerEnums::MAIN_WINDOW_ID;
}
int64_t DisplayServerAndroid::window_get_native_handle(HandleType p_handle_type, WindowID p_window) const {
ERR_FAIL_COND_V(p_window != MAIN_WINDOW_ID, 0);
int64_t DisplayServerAndroid::window_get_native_handle(DisplayServerEnums::HandleType p_handle_type, DisplayServerEnums::WindowID p_window) const {
ERR_FAIL_COND_V(p_window != DisplayServerEnums::MAIN_WINDOW_ID, 0);
switch (p_handle_type) {
case WINDOW_HANDLE: {
case DisplayServerEnums::WINDOW_HANDLE: {
return reinterpret_cast<int64_t>(static_cast<OS_Android *>(OS::get_singleton())->get_godot_java()->get_activity());
}
case WINDOW_VIEW: {
case DisplayServerEnums::WINDOW_VIEW: {
return 0; // Not supported.
}
#ifdef GLES3_ENABLED
case DISPLAY_HANDLE: {
case DisplayServerEnums::DISPLAY_HANDLE: {
if (rendering_driver == "opengl3") {
return reinterpret_cast<int64_t>(eglGetCurrentDisplay());
}
return 0;
}
case OPENGL_CONTEXT: {
case DisplayServerEnums::OPENGL_CONTEXT: {
if (rendering_driver == "opengl3") {
return reinterpret_cast<int64_t>(eglGetCurrentContext());
}
return 0;
}
case EGL_DISPLAY: {
case DisplayServerEnums::EGL_DISPLAY: {
// @todo Find a way to get this from the Java side.
return 0;
}
case EGL_CONFIG: {
case DisplayServerEnums::EGL_CONFIG: {
// @todo Find a way to get this from the Java side.
return 0;
}
@ -515,95 +515,95 @@ int64_t DisplayServerAndroid::window_get_native_handle(HandleType p_handle_type,
}
}
void DisplayServerAndroid::window_attach_instance_id(ObjectID p_instance, DisplayServer::WindowID p_window) {
void DisplayServerAndroid::window_attach_instance_id(ObjectID p_instance, DisplayServerEnums::WindowID p_window) {
window_attached_instance_id = p_instance;
}
ObjectID DisplayServerAndroid::window_get_attached_instance_id(DisplayServer::WindowID p_window) const {
ObjectID DisplayServerAndroid::window_get_attached_instance_id(DisplayServerEnums::WindowID p_window) const {
return window_attached_instance_id;
}
void DisplayServerAndroid::window_set_title(const String &p_title, DisplayServer::WindowID p_window) {
void DisplayServerAndroid::window_set_title(const String &p_title, DisplayServerEnums::WindowID p_window) {
// Not supported on Android.
}
int DisplayServerAndroid::window_get_current_screen(DisplayServer::WindowID p_window) const {
ERR_FAIL_COND_V(p_window != MAIN_WINDOW_ID, INVALID_SCREEN);
int DisplayServerAndroid::window_get_current_screen(DisplayServerEnums::WindowID p_window) const {
ERR_FAIL_COND_V(p_window != DisplayServerEnums::MAIN_WINDOW_ID, DisplayServerEnums::INVALID_SCREEN);
return 0;
}
void DisplayServerAndroid::window_set_current_screen(int p_screen, DisplayServer::WindowID p_window) {
void DisplayServerAndroid::window_set_current_screen(int p_screen, DisplayServerEnums::WindowID p_window) {
// Not supported on Android.
}
Point2i DisplayServerAndroid::window_get_position(DisplayServer::WindowID p_window) const {
Point2i DisplayServerAndroid::window_get_position(DisplayServerEnums::WindowID p_window) const {
return Point2i();
}
Point2i DisplayServerAndroid::window_get_position_with_decorations(DisplayServer::WindowID p_window) const {
Point2i DisplayServerAndroid::window_get_position_with_decorations(DisplayServerEnums::WindowID p_window) const {
return Point2i();
}
void DisplayServerAndroid::window_set_position(const Point2i &p_position, DisplayServer::WindowID p_window) {
void DisplayServerAndroid::window_set_position(const Point2i &p_position, DisplayServerEnums::WindowID p_window) {
// Not supported on Android.
}
void DisplayServerAndroid::window_set_transient(DisplayServer::WindowID p_window, DisplayServer::WindowID p_parent) {
void DisplayServerAndroid::window_set_transient(DisplayServerEnums::WindowID p_window, DisplayServerEnums::WindowID p_parent) {
// Not supported on Android.
}
void DisplayServerAndroid::window_set_max_size(const Size2i p_size, DisplayServer::WindowID p_window) {
void DisplayServerAndroid::window_set_max_size(const Size2i p_size, DisplayServerEnums::WindowID p_window) {
// Not supported on Android.
}
Size2i DisplayServerAndroid::window_get_max_size(DisplayServer::WindowID p_window) const {
Size2i DisplayServerAndroid::window_get_max_size(DisplayServerEnums::WindowID p_window) const {
return Size2i();
}
void DisplayServerAndroid::window_set_min_size(const Size2i p_size, DisplayServer::WindowID p_window) {
void DisplayServerAndroid::window_set_min_size(const Size2i p_size, DisplayServerEnums::WindowID p_window) {
// Not supported on Android.
}
Size2i DisplayServerAndroid::window_get_min_size(DisplayServer::WindowID p_window) const {
Size2i DisplayServerAndroid::window_get_min_size(DisplayServerEnums::WindowID p_window) const {
return Size2i();
}
void DisplayServerAndroid::window_set_size(const Size2i p_size, DisplayServer::WindowID p_window) {
void DisplayServerAndroid::window_set_size(const Size2i p_size, DisplayServerEnums::WindowID p_window) {
// Not supported on Android.
}
Size2i DisplayServerAndroid::window_get_size(DisplayServer::WindowID p_window) const {
Size2i DisplayServerAndroid::window_get_size(DisplayServerEnums::WindowID p_window) const {
return OS_Android::get_singleton()->get_display_size();
}
Size2i DisplayServerAndroid::window_get_size_with_decorations(DisplayServer::WindowID p_window) const {
Size2i DisplayServerAndroid::window_get_size_with_decorations(DisplayServerEnums::WindowID p_window) const {
return OS_Android::get_singleton()->get_display_size();
}
void DisplayServerAndroid::window_set_mode(DisplayServer::WindowMode p_mode, DisplayServer::WindowID p_window) {
OS_Android::get_singleton()->get_godot_java()->enable_immersive_mode(p_mode == WINDOW_MODE_FULLSCREEN || p_mode == WINDOW_MODE_EXCLUSIVE_FULLSCREEN);
void DisplayServerAndroid::window_set_mode(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::WindowID p_window) {
OS_Android::get_singleton()->get_godot_java()->enable_immersive_mode(p_mode == DisplayServerEnums::WINDOW_MODE_FULLSCREEN || p_mode == DisplayServerEnums::WINDOW_MODE_EXCLUSIVE_FULLSCREEN);
}
DisplayServer::WindowMode DisplayServerAndroid::window_get_mode(DisplayServer::WindowID p_window) const {
DisplayServerEnums::WindowMode DisplayServerAndroid::window_get_mode(DisplayServerEnums::WindowID p_window) const {
if (OS_Android::get_singleton()->get_godot_java()->is_in_immersive_mode()) {
return WINDOW_MODE_FULLSCREEN;
return DisplayServerEnums::WINDOW_MODE_FULLSCREEN;
} else {
return WINDOW_MODE_MAXIMIZED;
return DisplayServerEnums::WINDOW_MODE_MAXIMIZED;
}
}
bool DisplayServerAndroid::window_is_maximize_allowed(DisplayServer::WindowID p_window) const {
bool DisplayServerAndroid::window_is_maximize_allowed(DisplayServerEnums::WindowID p_window) const {
return false;
}
void DisplayServerAndroid::window_set_flag(DisplayServer::WindowFlags p_flag, bool p_enabled, DisplayServer::WindowID p_window) {
void DisplayServerAndroid::window_set_flag(DisplayServerEnums::WindowFlags p_flag, bool p_enabled, DisplayServerEnums::WindowID p_window) {
// Not supported on Android.
}
bool DisplayServerAndroid::window_get_flag(DisplayServer::WindowFlags p_flag, DisplayServer::WindowID p_window) const {
ERR_FAIL_COND_V(p_window != MAIN_WINDOW_ID, false);
bool DisplayServerAndroid::window_get_flag(DisplayServerEnums::WindowFlags p_flag, DisplayServerEnums::WindowID p_window) const {
ERR_FAIL_COND_V(p_window != DisplayServerEnums::MAIN_WINDOW_ID, false);
switch (p_flag) {
case WindowFlags::WINDOW_FLAG_TRANSPARENT:
case DisplayServerEnums::WindowFlags::WINDOW_FLAG_TRANSPARENT:
return is_window_transparency_available();
default:
@ -611,19 +611,19 @@ bool DisplayServerAndroid::window_get_flag(DisplayServer::WindowFlags p_flag, Di
}
}
void DisplayServerAndroid::window_request_attention(DisplayServer::WindowID p_window) {
void DisplayServerAndroid::window_request_attention(DisplayServerEnums::WindowID p_window) {
// Not supported on Android.
}
void DisplayServerAndroid::window_move_to_foreground(DisplayServer::WindowID p_window) {
void DisplayServerAndroid::window_move_to_foreground(DisplayServerEnums::WindowID p_window) {
// Not supported on Android.
}
bool DisplayServerAndroid::window_is_focused(WindowID p_window) const {
bool DisplayServerAndroid::window_is_focused(DisplayServerEnums::WindowID p_window) const {
return true;
}
bool DisplayServerAndroid::window_can_draw(DisplayServer::WindowID p_window) const {
bool DisplayServerAndroid::window_can_draw(DisplayServerEnums::WindowID p_window) const {
return true;
}
@ -654,7 +654,7 @@ Vector<String> DisplayServerAndroid::get_rendering_drivers_func() {
return drivers;
}
DisplayServer *DisplayServerAndroid::create_func(const String &p_rendering_driver, DisplayServer::WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error) {
DisplayServer *DisplayServerAndroid::create_func(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error) {
DisplayServer *ds = memnew(DisplayServerAndroid(p_rendering_driver, p_mode, p_vsync_mode, p_flags, p_position, p_resolution, p_screen, p_context, p_parent_window, r_error));
if (r_error != OK) {
if (p_rendering_driver == "vulkan") {
@ -722,11 +722,11 @@ void DisplayServerAndroid::reset_window() {
#if defined(RD_ENABLED)
if (rendering_context_global) {
if (rendering_device) {
rendering_device->screen_free(MAIN_WINDOW_ID);
rendering_device->screen_free(DisplayServerEnums::MAIN_WINDOW_ID);
}
VSyncMode last_vsync_mode = rendering_context_global->window_get_vsync_mode(MAIN_WINDOW_ID);
rendering_context_global->window_destroy(MAIN_WINDOW_ID);
DisplayServerEnums::VSyncMode last_vsync_mode = rendering_context_global->window_get_vsync_mode(DisplayServerEnums::MAIN_WINDOW_ID);
rendering_context_global->window_destroy(DisplayServerEnums::MAIN_WINDOW_ID);
union {
#ifdef VULKAN_ENABLED
@ -741,17 +741,17 @@ void DisplayServerAndroid::reset_window() {
}
#endif
if (rendering_context_global->window_create(MAIN_WINDOW_ID, &wpd) != OK) {
if (rendering_context_global->window_create(DisplayServerEnums::MAIN_WINDOW_ID, &wpd) != OK) {
ERR_PRINT(vformat("Failed to reset %s window.", rendering_driver));
return;
}
Size2i display_size = OS_Android::get_singleton()->get_display_size();
rendering_context_global->window_set_size(MAIN_WINDOW_ID, display_size.width, display_size.height);
rendering_context_global->window_set_vsync_mode(MAIN_WINDOW_ID, last_vsync_mode);
rendering_context_global->window_set_size(DisplayServerEnums::MAIN_WINDOW_ID, display_size.width, display_size.height);
rendering_context_global->window_set_vsync_mode(DisplayServerEnums::MAIN_WINDOW_ID, last_vsync_mode);
if (rendering_device) {
rendering_device->screen_create(MAIN_WINDOW_ID);
rendering_device->screen_create(DisplayServerEnums::MAIN_WINDOW_ID);
}
}
#endif
@ -771,7 +771,7 @@ void DisplayServerAndroid::notify_application_paused() {
#endif // defined(RD_ENABLED)
}
DisplayServerAndroid::DisplayServerAndroid(const String &p_rendering_driver, DisplayServer::WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error) {
DisplayServerAndroid::DisplayServerAndroid(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error) {
rendering_driver = p_rendering_driver;
keep_screen_on = GLOBAL_GET("display/window/energy_saving/keep_screen_on");
@ -793,24 +793,24 @@ DisplayServerAndroid::DisplayServerAndroid(const String &p_rendering_driver, Dis
RenderingContextDriverVulkanAndroid::WindowPlatformData wpd;
wpd.window = native_window;
if (rendering_context_global->window_create(MAIN_WINDOW_ID, &wpd) != OK) {
if (rendering_context_global->window_create(DisplayServerEnums::MAIN_WINDOW_ID, &wpd) != OK) {
ERR_PRINT(vformat("Failed to create %s window.", rendering_driver));
r_error = ERR_UNAVAILABLE;
return;
}
Size2i display_size = OS_Android::get_singleton()->get_display_size();
rendering_context_global->window_set_size(MAIN_WINDOW_ID, display_size.width, display_size.height);
rendering_context_global->window_set_vsync_mode(MAIN_WINDOW_ID, p_vsync_mode);
rendering_context_global->window_set_size(DisplayServerEnums::MAIN_WINDOW_ID, display_size.width, display_size.height);
rendering_context_global->window_set_vsync_mode(DisplayServerEnums::MAIN_WINDOW_ID, p_vsync_mode);
rendering_device = memnew(RenderingDevice);
if (rendering_device->initialize(rendering_context_global, MAIN_WINDOW_ID) != OK) {
if (rendering_device->initialize(rendering_context_global, DisplayServerEnums::MAIN_WINDOW_ID) != OK) {
rendering_device = nullptr;
r_error = ERR_UNAVAILABLE;
return;
}
rendering_device->screen_create(MAIN_WINDOW_ID);
rendering_device->screen_create(DisplayServerEnums::MAIN_WINDOW_ID);
RendererCompositorRD::make_current();
}
@ -859,7 +859,7 @@ void DisplayServerAndroid::process_gyroscope(const Vector3 &p_gyroscope) {
}
void DisplayServerAndroid::_mouse_update_mode() {
MouseMode wanted_mouse_mode = mouse_mode_override_enabled
DisplayServerEnums::MouseMode wanted_mouse_mode = mouse_mode_override_enabled
? mouse_mode_override
: mouse_mode_base;
@ -870,13 +870,13 @@ void DisplayServerAndroid::_mouse_update_mode() {
return;
}
if (wanted_mouse_mode == MouseMode::MOUSE_MODE_HIDDEN) {
if (wanted_mouse_mode == DisplayServerEnums::MouseMode::MOUSE_MODE_HIDDEN) {
OS_Android::get_singleton()->get_godot_java()->get_godot_view()->set_pointer_icon(CURSOR_TYPE_NULL);
} else {
cursor_set_shape(cursor_shape);
}
if (wanted_mouse_mode == MouseMode::MOUSE_MODE_CAPTURED) {
if (wanted_mouse_mode == DisplayServerEnums::MouseMode::MOUSE_MODE_CAPTURED) {
OS_Android::get_singleton()->get_godot_java()->get_godot_view()->request_pointer_capture();
} else {
OS_Android::get_singleton()->get_godot_java()->get_godot_view()->release_pointer_capture();
@ -885,8 +885,8 @@ void DisplayServerAndroid::_mouse_update_mode() {
mouse_mode = wanted_mouse_mode;
}
void DisplayServerAndroid::mouse_set_mode(MouseMode p_mode) {
ERR_FAIL_INDEX(p_mode, MouseMode::MOUSE_MODE_MAX);
void DisplayServerAndroid::mouse_set_mode(DisplayServerEnums::MouseMode p_mode) {
ERR_FAIL_INDEX(p_mode, DisplayServerEnums::MouseMode::MOUSE_MODE_MAX);
if (p_mode == mouse_mode_base) {
return;
}
@ -894,12 +894,12 @@ void DisplayServerAndroid::mouse_set_mode(MouseMode p_mode) {
_mouse_update_mode();
}
DisplayServer::MouseMode DisplayServerAndroid::mouse_get_mode() const {
DisplayServerEnums::MouseMode DisplayServerAndroid::mouse_get_mode() const {
return mouse_mode;
}
void DisplayServerAndroid::mouse_set_mode_override(MouseMode p_mode) {
ERR_FAIL_INDEX(p_mode, MouseMode::MOUSE_MODE_MAX);
void DisplayServerAndroid::mouse_set_mode_override(DisplayServerEnums::MouseMode p_mode) {
ERR_FAIL_INDEX(p_mode, DisplayServerEnums::MouseMode::MOUSE_MODE_MAX);
if (p_mode == mouse_mode_override) {
return;
}
@ -907,7 +907,7 @@ void DisplayServerAndroid::mouse_set_mode_override(MouseMode p_mode) {
_mouse_update_mode();
}
DisplayServer::MouseMode DisplayServerAndroid::mouse_get_mode_override() const {
DisplayServerEnums::MouseMode DisplayServerAndroid::mouse_get_mode_override() const {
return mouse_mode_override;
}
@ -928,7 +928,7 @@ BitField<MouseButtonMask> DisplayServerAndroid::mouse_get_button_state() const {
return Input::get_singleton()->get_mouse_button_mask();
}
void DisplayServerAndroid::_cursor_set_shape_helper(CursorShape p_shape, bool force) {
void DisplayServerAndroid::_cursor_set_shape_helper(DisplayServerEnums::CursorShape p_shape, bool force) {
if (!OS_Android::get_singleton()->get_godot_java()->get_godot_view()->can_update_pointer_icon()) {
return;
}
@ -938,22 +938,22 @@ void DisplayServerAndroid::_cursor_set_shape_helper(CursorShape p_shape, bool fo
cursor_shape = p_shape;
if (mouse_mode == MouseMode::MOUSE_MODE_VISIBLE || mouse_mode == MouseMode::MOUSE_MODE_CONFINED) {
if (mouse_mode == DisplayServerEnums::MouseMode::MOUSE_MODE_VISIBLE || mouse_mode == DisplayServerEnums::MouseMode::MOUSE_MODE_CONFINED) {
OS_Android::get_singleton()->get_godot_java()->get_godot_view()->set_pointer_icon(android_cursors[cursor_shape]);
}
}
void DisplayServerAndroid::cursor_set_shape(DisplayServer::CursorShape p_shape) {
ERR_FAIL_INDEX(p_shape, CURSOR_MAX);
void DisplayServerAndroid::cursor_set_shape(DisplayServerEnums::CursorShape p_shape) {
ERR_FAIL_INDEX(p_shape, DisplayServerEnums::CURSOR_MAX);
_cursor_set_shape_helper(p_shape);
}
DisplayServer::CursorShape DisplayServerAndroid::cursor_get_shape() const {
DisplayServerEnums::CursorShape DisplayServerAndroid::cursor_get_shape() const {
return cursor_shape;
}
void DisplayServerAndroid::cursor_set_custom_image(const Ref<Resource> &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
ERR_FAIL_INDEX(p_shape, CURSOR_MAX);
void DisplayServerAndroid::cursor_set_custom_image(const Ref<Resource> &p_cursor, DisplayServerEnums::CursorShape p_shape, const Vector2 &p_hotspot) {
ERR_FAIL_INDEX(p_shape, DisplayServerEnums::CURSOR_MAX);
String cursor_path = p_cursor.is_valid() ? p_cursor->get_path() : "";
if (!cursor_path.is_empty()) {
cursor_path = ProjectSettings::get_singleton()->globalize_path(cursor_path);
@ -962,7 +962,7 @@ void DisplayServerAndroid::cursor_set_custom_image(const Ref<Resource> &p_cursor
_cursor_set_shape_helper(p_shape, true);
}
void DisplayServerAndroid::window_set_vsync_mode(DisplayServer::VSyncMode p_vsync_mode, WindowID p_window) {
void DisplayServerAndroid::window_set_vsync_mode(DisplayServerEnums::VSyncMode p_vsync_mode, DisplayServerEnums::WindowID p_window) {
#if defined(RD_ENABLED)
if (rendering_context_global) {
rendering_context_global->window_set_vsync_mode(p_window, p_vsync_mode);
@ -970,13 +970,13 @@ void DisplayServerAndroid::window_set_vsync_mode(DisplayServer::VSyncMode p_vsyn
#endif
}
DisplayServer::VSyncMode DisplayServerAndroid::window_get_vsync_mode(WindowID p_window) const {
DisplayServerEnums::VSyncMode DisplayServerAndroid::window_get_vsync_mode(DisplayServerEnums::WindowID p_window) const {
#if defined(RD_ENABLED)
if (rendering_context_global) {
return rendering_context_global->window_get_vsync_mode(p_window);
}
#endif
return DisplayServer::VSYNC_ENABLED;
return DisplayServerEnums::VSYNC_ENABLED;
}
void DisplayServerAndroid::reset_swap_buffers_flag() {

158
platform/android/display_server_android.h
View file

@ -47,36 +47,36 @@ class DisplayServerAndroid : public DisplayServer {
// https://developer.android.com/reference/android/view/PointerIcon
// mapping between Godot's cursor shape to Android's'
int android_cursors[CURSOR_MAX] = {
1000, //CURSOR_ARROW
1008, //CURSOR_IBEAM
1002, //CURSOR_POINTIN
1007, //CURSOR_CROSS
1004, //CURSOR_WAIT
1004, //CURSOR_BUSY
1021, //CURSOR_DRAG
1021, //CURSOR_CAN_DRO
1000, //CURSOR_FORBIDD (no corresponding icon in Android's icon so fallback to default)
1015, //CURSOR_VSIZE
1014, //CURSOR_HSIZE
1017, //CURSOR_BDIAGSI
1016, //CURSOR_FDIAGSI
1020, //CURSOR_MOVE
1015, //CURSOR_VSPLIT
1014, //CURSOR_HSPLIT
1003, //CURSOR_HELP
int android_cursors[DisplayServerEnums::CURSOR_MAX] = {
1000, //DisplayServerEnums::CURSOR_ARROW
1008, //DisplayServerEnums::CURSOR_IBEAM
1002, //DisplayServerEnums::CURSOR_POINTIN
1007, //DisplayServerEnums::CURSOR_CROSS
1004, //DisplayServerEnums::CURSOR_WAIT
1004, //DisplayServerEnums::CURSOR_BUSY
1021, //DisplayServerEnums::CURSOR_DRAG
1021, //DisplayServerEnums::CURSOR_CAN_DRO
1000, //DisplayServerEnums::CURSOR_FORBIDD (no corresponding icon in Android's icon so fallback to default)
1015, //DisplayServerEnums::CURSOR_VSIZE
1014, //DisplayServerEnums::CURSOR_HSIZE
1017, //DisplayServerEnums::CURSOR_BDIAGSI
1016, //DisplayServerEnums::CURSOR_FDIAGSI
1020, //DisplayServerEnums::CURSOR_MOVE
1015, //DisplayServerEnums::CURSOR_VSPLIT
1014, //DisplayServerEnums::CURSOR_HSPLIT
1003, //DisplayServerEnums::CURSOR_HELP
};
const int CURSOR_TYPE_NULL = 0;
MouseMode mouse_mode = MouseMode::MOUSE_MODE_VISIBLE;
MouseMode mouse_mode_base = MouseMode::MOUSE_MODE_VISIBLE;
MouseMode mouse_mode_override = MouseMode::MOUSE_MODE_VISIBLE;
DisplayServerEnums::MouseMode mouse_mode = DisplayServerEnums::MouseMode::MOUSE_MODE_VISIBLE;
DisplayServerEnums::MouseMode mouse_mode_base = DisplayServerEnums::MouseMode::MOUSE_MODE_VISIBLE;
DisplayServerEnums::MouseMode mouse_mode_override = DisplayServerEnums::MouseMode::MOUSE_MODE_VISIBLE;
bool mouse_mode_override_enabled = false;
void _mouse_update_mode();
bool keep_screen_on;
bool swap_buffers_flag;
CursorShape cursor_shape = CursorShape::CURSOR_ARROW;
DisplayServerEnums::CursorShape cursor_shape = DisplayServerEnums::CursorShape::CURSOR_ARROW;
#if defined(RD_ENABLED)
RenderingDevice *rendering_device = nullptr;
@ -106,7 +106,7 @@ class DisplayServerAndroid : public DisplayServer {
public:
static DisplayServerAndroid *get_singleton();
virtual bool has_feature(Feature p_feature) const override;
virtual bool has_feature(DisplayServerEnums::Feature p_feature) const override;
virtual String get_name() const override;
virtual bool tts_is_speaking() const override;
@ -133,7 +133,7 @@ public:
virtual Error dialog_input_text(String p_title, String p_description, String p_partial, const Callable &p_callback) override;
void emit_input_dialog_callback(String p_text);
virtual Error file_dialog_show(const String &p_title, const String &p_current_directory, const String &p_filename, bool p_show_hidden, const FileDialogMode p_mode, const Vector<String> &p_filters, const Callable &p_callback, WindowID p_window_id) override;
virtual Error file_dialog_show(const String &p_title, const String &p_current_directory, const String &p_filename, bool p_show_hidden, const DisplayServerEnums::FileDialogMode p_mode, const Vector<String> &p_filters, const Callable &p_callback, DisplayServerEnums::WindowID p_window_id) override;
void emit_file_picker_callback(bool p_ok, const Vector<String> &p_selected_paths);
virtual Color get_accent_color() const override;
@ -145,83 +145,83 @@ public:
virtual void screen_set_keep_on(bool p_enable) override;
virtual bool screen_is_kept_on() const override;
virtual void screen_set_orientation(ScreenOrientation p_orientation, int p_screen = SCREEN_OF_MAIN_WINDOW) override;
virtual ScreenOrientation screen_get_orientation(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual void screen_set_orientation(DisplayServerEnums::ScreenOrientation p_orientation, int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) override;
virtual DisplayServerEnums::ScreenOrientation screen_get_orientation(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
int get_display_rotation() const;
virtual int get_screen_count() const override;
virtual int get_primary_screen() const override;
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;
virtual float screen_get_scale(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_refresh_rate(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual Point2i screen_get_position(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Size2i screen_get_size(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Rect2i screen_get_usable_rect(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual int screen_get_dpi(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_scale(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_refresh_rate(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual bool is_touchscreen_available() const override;
virtual void virtual_keyboard_show(const String &p_existing_text, const Rect2 &p_screen_rect = Rect2(), VirtualKeyboardType p_type = KEYBOARD_TYPE_DEFAULT, int p_max_length = -1, int p_cursor_start = -1, int p_cursor_end = -1) override;
virtual void virtual_keyboard_show(const String &p_existing_text, const Rect2 &p_screen_rect = Rect2(), DisplayServerEnums::VirtualKeyboardType p_type = DisplayServerEnums::KEYBOARD_TYPE_DEFAULT, int p_max_length = -1, int p_cursor_start = -1, int p_cursor_end = -1) override;
virtual void virtual_keyboard_hide() override;
virtual int virtual_keyboard_get_height() const override;
virtual bool has_hardware_keyboard() const override;
virtual void set_hardware_keyboard_connection_change_callback(const Callable &p_callable) override;
void emit_hardware_keyboard_connection_changed(bool p_connected);
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_rect_changed_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;
virtual void window_set_window_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_input_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_input_text_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_rect_changed_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_drop_files_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
void send_window_event(WindowEvent p_event, bool p_deferred = false) const;
void send_window_event(DisplayServerEnums::WindowEvent p_event, bool p_deferred = false) const;
void send_input_event(const Ref<InputEvent> &p_event) const;
void send_input_text(const String &p_text) const;
virtual Vector<WindowID> get_window_list() const override;
virtual WindowID get_window_at_screen_position(const Point2i &p_position) const override;
virtual Vector<DisplayServerEnums::WindowID> get_window_list() const override;
virtual DisplayServerEnums::WindowID get_window_at_screen_position(const Point2i &p_position) const override;
virtual int64_t window_get_native_handle(HandleType p_handle_type, WindowID p_window = MAIN_WINDOW_ID) const override;
virtual int64_t window_get_native_handle(DisplayServerEnums::HandleType p_handle_type, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_title(const String &p_title, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_attach_instance_id(ObjectID p_instance, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual ObjectID window_get_attached_instance_id(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_title(const String &p_title, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
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;
virtual int window_get_current_screen(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_current_screen(int p_screen, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Point2i window_get_position(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual Point2i window_get_position_with_decorations(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_position(const Point2i &p_position, WindowID p_window = MAIN_WINDOW_ID) override;
virtual Point2i window_get_position(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual Point2i window_get_position_with_decorations(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_position(const Point2i &p_position, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_transient(WindowID p_window, WindowID p_parent) override;
virtual void window_set_transient(DisplayServerEnums::WindowID p_window, DisplayServerEnums::WindowID p_parent) override;
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;
virtual void window_set_max_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_max_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_min_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_min_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual Size2i window_get_size_with_decorations(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual Size2i window_get_size_with_decorations(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_mode(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual DisplayServerEnums::WindowMode window_get_mode(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool window_is_maximize_allowed(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual bool window_is_maximize_allowed(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_flag(DisplayServerEnums::WindowFlags p_flag, bool p_enabled, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_get_flag(DisplayServerEnums::WindowFlags p_flag, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_request_attention(WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_move_to_foreground(WindowID p_window = MAIN_WINDOW_ID) override;
virtual bool window_is_focused(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_request_attention(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_move_to_foreground(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_is_focused(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool window_can_draw(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual bool window_can_draw(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool can_any_window_draw() const override;
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;
virtual void window_set_vsync_mode(DisplayServerEnums::VSyncMode p_vsync_mode, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual DisplayServerEnums::VSyncMode window_get_vsync_mode(DisplayServerEnums::WindowID p_vsync_mode) const override;
virtual void window_set_color(const Color &p_color) override;
@ -232,19 +232,19 @@ public:
void process_magnetometer(const Vector3 &p_magnetometer);
void process_gyroscope(const Vector3 &p_gyroscope);
void _cursor_set_shape_helper(CursorShape p_shape, bool force = false);
virtual void cursor_set_shape(CursorShape p_shape) override;
virtual CursorShape cursor_get_shape() const override;
virtual void cursor_set_custom_image(const Ref<Resource> &p_cursor, CursorShape p_shape = CURSOR_ARROW, const Vector2 &p_hotspot = Vector2()) override;
void _cursor_set_shape_helper(DisplayServerEnums::CursorShape p_shape, bool force = false);
virtual void cursor_set_shape(DisplayServerEnums::CursorShape p_shape) override;
virtual DisplayServerEnums::CursorShape cursor_get_shape() const override;
virtual void cursor_set_custom_image(const Ref<Resource> &p_cursor, DisplayServerEnums::CursorShape p_shape = DisplayServerEnums::CURSOR_ARROW, const Vector2 &p_hotspot = Vector2()) override;
virtual void mouse_set_mode(MouseMode p_mode) override;
virtual MouseMode mouse_get_mode() const override;
virtual void mouse_set_mode_override(MouseMode p_mode) override;
virtual MouseMode mouse_get_mode_override() const override;
virtual void mouse_set_mode(DisplayServerEnums::MouseMode p_mode) override;
virtual DisplayServerEnums::MouseMode mouse_get_mode() const override;
virtual void mouse_set_mode_override(DisplayServerEnums::MouseMode p_mode) override;
virtual DisplayServerEnums::MouseMode mouse_get_mode_override() const override;
virtual void mouse_set_mode_override_enabled(bool p_override_enabled) override;
virtual bool mouse_is_mode_override_enabled() const override;
static DisplayServer *create_func(const String &p_rendering_driver, WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error);
static DisplayServer *create_func(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
static Vector<String> get_rendering_drivers_func();
static void register_android_driver();
@ -269,6 +269,6 @@ public:
virtual bool is_window_transparency_available() const override;
DisplayServerAndroid(const String &p_rendering_driver, WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error);
DisplayServerAndroid(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
~DisplayServerAndroid();
};

2
platform/android/export/export_plugin.cpp
View file

@ -1220,7 +1220,7 @@ void EditorExportPlatformAndroid::_fix_manifest(const Ref<EditorExportPreset> &p
String package_name = p_preset->get("package/unique_name");
const int screen_orientation =
_get_android_orientation_value(DisplayServer::ScreenOrientation(int(get_project_setting(p_preset, "display/window/handheld/orientation"))));
_get_android_orientation_value(DisplayServerEnums::ScreenOrientation(int(get_project_setting(p_preset, "display/window/handheld/orientation"))));
bool screen_support_small = p_preset->get("screen/support_small");
bool screen_support_normal = p_preset->get("screen/support_normal");

34
platform/android/export/gradle_export_util.cpp
View file

@ -33,41 +33,41 @@
#include "core/string/translation_server.h"
#include "modules/regex/regex.h"
int _get_android_orientation_value(DisplayServer::ScreenOrientation screen_orientation) {
int _get_android_orientation_value(DisplayServerEnums::ScreenOrientation screen_orientation) {
switch (screen_orientation) {
case DisplayServer::SCREEN_PORTRAIT:
case DisplayServerEnums::SCREEN_PORTRAIT:
return 1;
case DisplayServer::SCREEN_REVERSE_LANDSCAPE:
case DisplayServerEnums::SCREEN_REVERSE_LANDSCAPE:
return 8;
case DisplayServer::SCREEN_REVERSE_PORTRAIT:
case DisplayServerEnums::SCREEN_REVERSE_PORTRAIT:
return 9;
case DisplayServer::SCREEN_SENSOR_LANDSCAPE:
case DisplayServerEnums::SCREEN_SENSOR_LANDSCAPE:
return 11;
case DisplayServer::SCREEN_SENSOR_PORTRAIT:
case DisplayServerEnums::SCREEN_SENSOR_PORTRAIT:
return 12;
case DisplayServer::SCREEN_SENSOR:
case DisplayServerEnums::SCREEN_SENSOR:
return 13;
case DisplayServer::SCREEN_LANDSCAPE:
case DisplayServerEnums::SCREEN_LANDSCAPE:
default:
return 0;
}
}
String _get_android_orientation_label(DisplayServer::ScreenOrientation screen_orientation) {
String _get_android_orientation_label(DisplayServerEnums::ScreenOrientation screen_orientation) {
switch (screen_orientation) {
case DisplayServer::SCREEN_PORTRAIT:
case DisplayServerEnums::SCREEN_PORTRAIT:
return "portrait";
case DisplayServer::SCREEN_REVERSE_LANDSCAPE:
case DisplayServerEnums::SCREEN_REVERSE_LANDSCAPE:
return "reverseLandscape";
case DisplayServer::SCREEN_REVERSE_PORTRAIT:
case DisplayServerEnums::SCREEN_REVERSE_PORTRAIT:
return "reversePortrait";
case DisplayServer::SCREEN_SENSOR_LANDSCAPE:
case DisplayServerEnums::SCREEN_SENSOR_LANDSCAPE:
return "userLandscape";
case DisplayServer::SCREEN_SENSOR_PORTRAIT:
case DisplayServerEnums::SCREEN_SENSOR_PORTRAIT:
return "userPortrait";
case DisplayServer::SCREEN_SENSOR:
case DisplayServerEnums::SCREEN_SENSOR:
return "fullUser";
case DisplayServer::SCREEN_LANDSCAPE:
case DisplayServerEnums::SCREEN_LANDSCAPE:
default:
return "landscape";
}
@ -306,7 +306,7 @@ String _get_activity_tag(const Ref<EditorExportPlatform> &p_export_platform, con
}
// Update the GodotApp activity tag.
String orientation = _get_android_orientation_label(DisplayServer::ScreenOrientation(int(p_export_platform->get_project_setting(p_preset, "display/window/handheld/orientation"))));
String orientation = _get_android_orientation_label(DisplayServerEnums::ScreenOrientation(int(p_export_platform->get_project_setting(p_preset, "display/window/handheld/orientation"))));
String manifest_activity_text = vformat(
" <activity android:name=\".GodotApp\" "
"tools:replace=\"android:screenOrientation,android:excludeFromRecents,android:resizeableActivity\" "

4
platform/android/export/gradle_export_util.h
View file

@ -77,9 +77,9 @@ struct MetadataInfo {
String value;
};
int _get_android_orientation_value(DisplayServer::ScreenOrientation screen_orientation);
int _get_android_orientation_value(DisplayServerEnums::ScreenOrientation screen_orientation);
String _get_android_orientation_label(DisplayServer::ScreenOrientation screen_orientation);
String _get_android_orientation_label(DisplayServerEnums::ScreenOrientation screen_orientation);
int _get_app_category_value(int category_index);

2
platform/android/java/lib/src/main/java/org/godotengine/godot/input/GodotEditText.java
View file

@ -57,7 +57,7 @@ public class GodotEditText extends EditText {
private final static int HANDLER_OPEN_IME_KEYBOARD = 2;
private final static int HANDLER_CLOSE_IME_KEYBOARD = 3;
// Enum must be kept up-to-date with DisplayServer::VirtualKeyboardType
// Enum must be kept up-to-date with DisplayServerEnums::VirtualKeyboardType
public enum VirtualKeyboardType {
KEYBOARD_TYPE_DEFAULT,
KEYBOARD_TYPE_MULTILINE,

2
platform/android/java/lib/src/main/java/org/godotengine/godot/tts/GodotTTS.java
View file

@ -57,7 +57,7 @@ import java.util.Set;
*/
@Keep
public class GodotTTS extends UtteranceProgressListener implements TextToSpeech.OnInitListener {
// Note: These constants must be in sync with DisplayServer::TTSUtteranceEvent enum from "servers/display/display_server.h".
// Note: These constants must be in sync with DisplayServerEnums::TTSUtteranceEvent enum from "servers/display/display_server.h".
final private static int EVENT_START = 0;
final private static int EVENT_END = 1;
final private static int EVENT_CANCEL = 2;

2
platform/android/java_godot_lib_jni.cpp
View file

@ -273,7 +273,7 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_back(JNIEnv *env, jcl
}
if (DisplayServerAndroid *dsa = Object::cast_to<DisplayServerAndroid>(DisplayServer::get_singleton())) {
dsa->send_window_event(DisplayServer::WINDOW_EVENT_GO_BACK_REQUEST);
dsa->send_window_event(DisplayServerEnums::WINDOW_EVENT_GO_BACK_REQUEST);
}
}

4
platform/android/os_android.cpp
View file

@ -415,7 +415,7 @@ void OS_Android::_on_main_screen_changed(const String &p_screen_name) {
#endif
void OS_Android::main_loop_focusout() {
DisplayServerAndroid::get_singleton()->send_window_event(DisplayServer::WINDOW_EVENT_FOCUS_OUT);
DisplayServerAndroid::get_singleton()->send_window_event(DisplayServerEnums::WINDOW_EVENT_FOCUS_OUT);
if (OS::get_singleton()->get_main_loop()) {
OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_APPLICATION_FOCUS_OUT);
}
@ -423,7 +423,7 @@ void OS_Android::main_loop_focusout() {
}
void OS_Android::main_loop_focusin() {
DisplayServerAndroid::get_singleton()->send_window_event(DisplayServer::WINDOW_EVENT_FOCUS_IN);
DisplayServerAndroid::get_singleton()->send_window_event(DisplayServerEnums::WINDOW_EVENT_FOCUS_IN);
if (OS::get_singleton()->get_main_loop()) {
OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_APPLICATION_FOCUS_IN);
}

10
platform/android/tts_android.cpp
View file

@ -152,7 +152,7 @@ void TTS_Android::_java_utterance_callback(int p_event, int64_t p_id, int p_pos)
ERR_FAIL_COND_MSG(!initialized || tts == nullptr, "Text to Speech not initialized.");
if (ids.has(p_id)) {
int pos = 0;
if ((DisplayServer::TTSUtteranceEvent)p_event == DisplayServer::TTS_UTTERANCE_BOUNDARY) {
if ((DisplayServerEnums::TTSUtteranceEvent)p_event == DisplayServerEnums::TTS_UTTERANCE_BOUNDARY) {
// Convert position from UTF-16 to UTF-32.
const Char16String &string = ids[p_id];
for (int i = 0; i < MIN(p_pos, string.length()); i++) {
@ -162,10 +162,10 @@ void TTS_Android::_java_utterance_callback(int p_event, int64_t p_id, int p_pos)
}
pos++;
}
} else if ((DisplayServer::TTSUtteranceEvent)p_event != DisplayServer::TTS_UTTERANCE_STARTED) {
} else if ((DisplayServerEnums::TTSUtteranceEvent)p_event != DisplayServerEnums::TTS_UTTERANCE_STARTED) {
ids.erase(p_id);
}
DisplayServer::get_singleton()->tts_post_utterance_event((DisplayServer::TTSUtteranceEvent)p_event, p_id, pos);
DisplayServer::get_singleton()->tts_post_utterance_event((DisplayServerEnums::TTSUtteranceEvent)p_event, p_id, pos);
}
}
@ -240,7 +240,7 @@ void TTS_Android::speak(const String &p_text, const String &p_voice, int p_volum
}
if (p_text.is_empty()) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, p_utterance_id);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, p_utterance_id);
return;
}
@ -290,7 +290,7 @@ void TTS_Android::stop() {
}
ERR_FAIL_COND_MSG(!initialized || tts == nullptr, "Text to Speech not initialized.");
for (const KeyValue<int64_t, Char16String> &E : ids) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, E.key);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, E.key);
}
ids.clear();

10
platform/ios/display_server_ios.h
View file

@ -37,20 +37,20 @@ class DisplayServerIOS final : public DisplayServerAppleEmbedded {
_THREAD_SAFE_CLASS_
DisplayServerIOS(const String &p_rendering_driver, DisplayServer::WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error);
DisplayServerIOS(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
~DisplayServerIOS();
public:
static DisplayServerIOS *get_singleton();
static void register_ios_driver();
static DisplayServer *create_func(const String &p_rendering_driver, WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error);
static DisplayServer *create_func(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
virtual String get_name() const override;
virtual int screen_get_dpi(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_scale(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_refresh_rate(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual int screen_get_dpi(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_scale(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_refresh_rate(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
protected:
virtual bool _screen_hdr_is_supported() const override;

4
platform/ios/display_server_ios.mm
View file

@ -39,7 +39,7 @@ DisplayServerIOS *DisplayServerIOS::get_singleton() {
return (DisplayServerIOS *)DisplayServerAppleEmbedded::get_singleton();
}
DisplayServerIOS::DisplayServerIOS(const String &p_rendering_driver, WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error) :
DisplayServerIOS::DisplayServerIOS(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error) :
DisplayServerAppleEmbedded(p_rendering_driver, p_mode, p_vsync_mode, p_flags, p_position, p_resolution, p_screen, p_context, p_parent_window, r_error) {
// See: https://github.com/godotengine/godot/pull/106814#discussion_r2854262156 for why this was set to 203 nits.
hardware_reference_luminance_nits = 203.0f;
@ -48,7 +48,7 @@ DisplayServerIOS::DisplayServerIOS(const String &p_rendering_driver, WindowMode
DisplayServerIOS::~DisplayServerIOS() {
}
DisplayServer *DisplayServerIOS::create_func(const String &p_rendering_driver, WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error) {
DisplayServer *DisplayServerIOS::create_func(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error) {
return memnew(DisplayServerIOS(p_rendering_driver, p_mode, p_vsync_mode, p_flags, p_position, p_resolution, p_screen, p_context, p_parent_window, r_error));
}

14
platform/linuxbsd/freedesktop_portal_desktop.cpp
View file

@ -680,12 +680,12 @@ bool FreeDesktopPortalDesktop::send_request(DBusMessage *p_message, const String
return true;
}
Error FreeDesktopPortalDesktop::file_dialog_show(DisplayServer::WindowID p_window_id, const String &p_xid, const String &p_title, const String &p_current_directory, const String &p_root, const String &p_filename, DisplayServer::FileDialogMode p_mode, const Vector<String> &p_filters, const TypedArray<Dictionary> &p_options, const Callable &p_callback, bool p_options_in_cb) {
Error FreeDesktopPortalDesktop::file_dialog_show(DisplayServerEnums::WindowID p_window_id, const String &p_xid, const String &p_title, const String &p_current_directory, const String &p_root, const String &p_filename, DisplayServerEnums::FileDialogMode p_mode, const Vector<String> &p_filters, const TypedArray<Dictionary> &p_options, const Callable &p_callback, bool p_options_in_cb) {
if (unsupported) {
return FAILED;
}
ERR_FAIL_INDEX_V(int(p_mode), DisplayServer::FILE_DIALOG_MODE_SAVE_MAX, FAILED);
ERR_FAIL_INDEX_V(int(p_mode), DisplayServerEnums::FILE_DIALOG_MODE_SAVE_MAX, FAILED);
ERR_FAIL_NULL_V(monitor_connection, FAILED);
Vector<String> filter_names;
@ -739,7 +739,7 @@ Error FreeDesktopPortalDesktop::file_dialog_show(DisplayServer::WindowID p_windo
// Generate FileChooser message.
const char *method = nullptr;
if (p_mode == DisplayServer::FILE_DIALOG_MODE_SAVE_FILE) {
if (p_mode == DisplayServerEnums::FILE_DIALOG_MODE_SAVE_FILE) {
method = "SaveFile";
} else {
method = "OpenFile";
@ -757,13 +757,13 @@ Error FreeDesktopPortalDesktop::file_dialog_show(DisplayServer::WindowID p_windo
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &arr_iter);
append_dbus_dict_string(&arr_iter, "handle_token", token);
append_dbus_dict_bool(&arr_iter, "multiple", p_mode == DisplayServer::FILE_DIALOG_MODE_OPEN_FILES);
append_dbus_dict_bool(&arr_iter, "directory", p_mode == DisplayServer::FILE_DIALOG_MODE_OPEN_DIR);
append_dbus_dict_bool(&arr_iter, "multiple", p_mode == DisplayServerEnums::FILE_DIALOG_MODE_OPEN_FILES);
append_dbus_dict_bool(&arr_iter, "directory", p_mode == DisplayServerEnums::FILE_DIALOG_MODE_OPEN_DIR);
append_dbus_dict_filters(&arr_iter, filter_names, filter_exts, filter_mimes);
append_dbus_dict_options(&arr_iter, p_options, fd.option_ids);
append_dbus_dict_string(&arr_iter, "current_folder", p_current_directory, true);
if (p_mode == DisplayServer::FILE_DIALOG_MODE_SAVE_FILE) {
if (p_mode == DisplayServerEnums::FILE_DIALOG_MODE_SAVE_FILE) {
append_dbus_dict_string(&arr_iter, "current_name", p_filename);
}
@ -948,7 +948,7 @@ void FreeDesktopPortalDesktop::_thread_monitor(void *p_ud) {
cb.opt_in_cb = fd.opt_in_cb;
portal->pending_file_cbs.push_back(cb);
}
if (fd.prev_focus != DisplayServer::INVALID_WINDOW_ID) {
if (fd.prev_focus != DisplayServerEnums::INVALID_WINDOW_ID) {
callable_mp(DisplayServer::get_singleton(), &DisplayServer::window_move_to_foreground).call_deferred(fd.prev_focus);
}
}

4
platform/linuxbsd/freedesktop_portal_desktop.h
View file

@ -87,7 +87,7 @@ private:
struct FileDialogData {
Vector<String> filter_names;
HashMap<String, String> option_ids;
DisplayServer::WindowID prev_focus = DisplayServer::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID prev_focus = DisplayServerEnums::INVALID_WINDOW_ID;
Callable callback;
String filter;
String path;
@ -132,7 +132,7 @@ public:
bool is_inhibit_supported();
// org.freedesktop.portal.FileChooser methods.
Error file_dialog_show(DisplayServer::WindowID p_window_id, const String &p_xid, const String &p_title, const String &p_current_directory, const String &p_root, const String &p_filename, DisplayServer::FileDialogMode p_mode, const Vector<String> &p_filters, const TypedArray<Dictionary> &p_options, const Callable &p_callback, bool p_options_in_cb);
Error file_dialog_show(DisplayServerEnums::WindowID p_window_id, const String &p_xid, const String &p_title, const String &p_current_directory, const String &p_root, const String &p_filename, DisplayServerEnums::FileDialogMode p_mode, const Vector<String> &p_filters, const TypedArray<Dictionary> &p_options, const Callable &p_callback, bool p_options_in_cb);
void process_callbacks();
// org.freedesktop.portal.Settings methods.

21
platform/linuxbsd/tts_linux.cpp
View file

@ -32,6 +32,7 @@
#include "core/config/project_settings.h"
#include "core/object/callable_method_pointer.h"
#include "servers/display/display_server.h"
#include "servers/text/text_server.h"
TTS_Linux *TTS_Linux::singleton = nullptr;
@ -91,7 +92,7 @@ void TTS_Linux::_speech_index_mark(int p_msg_id, int p_type, const String &p_ind
_THREAD_SAFE_METHOD_
if (ids.has(p_msg_id)) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_BOUNDARY, ids[p_msg_id], p_index_mark.to_int());
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_BOUNDARY, ids[p_msg_id], p_index_mark.to_int());
}
}
@ -125,19 +126,19 @@ void TTS_Linux::_speech_event(int p_msg_id, int p_type) {
if (!paused && ids.has(p_msg_id)) {
if ((SPDNotificationType)p_type == SPD_EVENT_END) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_ENDED, ids[p_msg_id]);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_ENDED, ids[p_msg_id]);
ids.erase(p_msg_id);
last_msg_id = -1;
speaking = false;
} else if ((SPDNotificationType)p_type == SPD_EVENT_CANCEL) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, ids[p_msg_id]);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, ids[p_msg_id]);
ids.erase(p_msg_id);
last_msg_id = -1;
speaking = false;
}
}
if (!speaking && queue.size() > 0) {
DisplayServer::TTSUtterance &message = queue.front()->get();
TTSUtterance &message = queue.front()->get();
// Inject index mark after each word.
String text;
@ -175,7 +176,7 @@ void TTS_Linux::_speech_event(int p_msg_id, int p_type) {
spd_set_data_mode(synth, SPD_DATA_SSML);
last_msg_id = spd_say(synth, SPD_TEXT, text.utf8().get_data());
ids[last_msg_id] = message.id;
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_STARTED, message.id);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_STARTED, message.id);
queue.pop_front();
speaking = true;
@ -217,11 +218,11 @@ void TTS_Linux::speak(const String &p_text, const String &p_voice, int p_volume,
}
if (p_text.is_empty()) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, p_utterance_id);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, p_utterance_id);
return;
}
DisplayServer::TTSUtterance message;
TTSUtterance message;
message.text = p_text;
message.voice = p_voice;
message.volume = CLAMP(p_volume, 0, 100);
@ -258,11 +259,11 @@ void TTS_Linux::stop() {
_THREAD_SAFE_METHOD_
ERR_FAIL_NULL(synth);
for (DisplayServer::TTSUtterance &message : queue) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, message.id);
for (TTSUtterance &message : queue) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, message.id);
}
if ((last_msg_id != -1) && ids.has(last_msg_id)) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, ids[last_msg_id]);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, ids[last_msg_id]);
}
queue.clear();
ids.clear();

6
platform/linuxbsd/tts_linux.h
View file

@ -30,13 +30,13 @@
#pragma once
#include "core/object/object.h"
#include "core/os/thread.h"
#include "core/os/thread_safe.h"
#include "core/string/ustring.h"
#include "core/templates/hash_map.h"
#include "core/templates/list.h"
#include "core/variant/array.h"
#include "servers/display/display_server.h"
#ifdef SOWRAP_ENABLED
#include "speechd-so_wrap.h"
@ -44,11 +44,13 @@
#include <libspeechd.h>
#endif
struct TTSUtterance;
class TTS_Linux : public Object {
GDSOFTCLASS(TTS_Linux, Object);
_THREAD_SAFE_CLASS_
List<DisplayServer::TTSUtterance> queue;
List<TTSUtterance> queue;
SPDConnection *synth = nullptr;
bool speaking = false;
bool paused = false;

360
platform/linuxbsd/wayland/display_server_wayland.cpp
View file

File diff suppressed because it is too large Load diff

174
platform/linuxbsd/wayland/display_server_wayland.h
View file

@ -62,15 +62,15 @@ class DisplayServerWayland : public DisplayServer {
GDSOFTCLASS(DisplayServerWayland, DisplayServer);
struct WindowData {
WindowID id = INVALID_WINDOW_ID;
DisplayServerEnums::WindowID id = DisplayServerEnums::INVALID_WINDOW_ID;
WindowID parent_id = INVALID_WINDOW_ID;
DisplayServerEnums::WindowID parent_id = DisplayServerEnums::INVALID_WINDOW_ID;
// For popups.
WindowID root_id = INVALID_WINDOW_ID;
DisplayServerEnums::WindowID root_id = DisplayServerEnums::INVALID_WINDOW_ID;
// For toplevels.
List<WindowID> popup_stack;
List<DisplayServerEnums::WindowID> popup_stack;
Rect2i rect;
Size2i max_size;
@ -87,11 +87,11 @@ class DisplayServerWayland : public DisplayServer {
// Flags whether we have allocated a buffer through the video drivers.
bool visible = false;
DisplayServer::VSyncMode vsync_mode = VSYNC_ENABLED;
DisplayServerEnums::VSyncMode vsync_mode = DisplayServerEnums::VSYNC_ENABLED;
uint32_t flags = 0;
DisplayServer::WindowMode mode = WINDOW_MODE_WINDOWED;
DisplayServerEnums::WindowMode mode = DisplayServerEnums::WINDOW_MODE_WINDOWED;
Callable rect_changed_callback;
Callable window_event_callback;
@ -114,28 +114,28 @@ class DisplayServerWayland : public DisplayServer {
CAPABILITY, // New "suspended" wm_capability flag.
};
CursorShape cursor_shape = CURSOR_ARROW;
DisplayServer::MouseMode mouse_mode = DisplayServer::MOUSE_MODE_VISIBLE;
DisplayServer::MouseMode mouse_mode_base = MOUSE_MODE_VISIBLE;
DisplayServer::MouseMode mouse_mode_override = MOUSE_MODE_VISIBLE;
DisplayServerEnums::CursorShape cursor_shape = DisplayServerEnums::CURSOR_ARROW;
DisplayServerEnums::MouseMode mouse_mode = DisplayServerEnums::MOUSE_MODE_VISIBLE;
DisplayServerEnums::MouseMode mouse_mode_base = DisplayServerEnums::MOUSE_MODE_VISIBLE;
DisplayServerEnums::MouseMode mouse_mode_override = DisplayServerEnums::MOUSE_MODE_VISIBLE;
bool mouse_mode_override_enabled = false;
void _mouse_update_mode();
HashMap<CursorShape, CustomCursor> custom_cursors;
HashMap<DisplayServerEnums::CursorShape, CustomCursor> custom_cursors;
HashMap<WindowID, WindowData> windows;
WindowID window_id_counter = MAIN_WINDOW_ID;
HashMap<DisplayServerEnums::WindowID, WindowData> windows;
DisplayServerEnums::WindowID window_id_counter = DisplayServerEnums::MAIN_WINDOW_ID;
WaylandThread wayland_thread;
Context context;
DisplayServerEnums::Context context;
bool swap_cancel_ok = false;
// NOTE: These are the based on WINDOW_FLAG_POPUP, which does NOT imply what it
// NOTE: These are the based on DisplayServerEnums::WINDOW_FLAG_POPUP, which does NOT imply what it
// seems. It's particularly confusing for our usecase, but just know that these
// are the "take all input thx" windows while the `popup_stack` variable keeps
// track of all the generic floating window concept.
List<WindowID> popup_menu_list;
List<DisplayServerEnums::WindowID> popup_menu_list;
BitField<MouseButtonMask> last_mouse_monitor_mask = MouseButtonMask::NONE;
String ime_text;
@ -166,21 +166,21 @@ class DisplayServerWayland : public DisplayServer {
FreeDesktopScreenSaver *screensaver = nullptr;
bool screensaver_inhibited = false;
#endif
static String _get_app_id_from_context(Context p_context);
static String _get_app_id_from_context(DisplayServerEnums::Context p_context);
void _send_window_event(WindowEvent p_event, WindowID p_window_id = MAIN_WINDOW_ID);
void _send_window_event(DisplayServerEnums::WindowEvent p_event, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID);
static void dispatch_input_events(const Ref<InputEvent> &p_event);
void _dispatch_input_event(const Ref<InputEvent> &p_event);
void _update_window_rect(const Rect2i &p_rect, WindowID p_window_id = MAIN_WINDOW_ID);
void _update_window_rect(const Rect2i &p_rect, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID);
void try_suspend();
void initialize_tts() const;
public:
virtual bool has_feature(Feature p_feature) const override;
virtual bool has_feature(DisplayServerEnums::Feature p_feature) const override;
virtual String get_name() const override;
@ -201,16 +201,16 @@ public:
virtual Color get_accent_color() const override;
virtual void set_system_theme_change_callback(const Callable &p_callable) override;
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, WindowID p_window_id) override;
virtual Error file_dialog_with_options_show(const String &p_title, const String &p_current_directory, const String &p_root, const String &p_filename, bool p_show_hidden, FileDialogMode p_mode, const Vector<String> &p_filters, const TypedArray<Dictionary> &p_options, const Callable &p_callback, WindowID p_window_id) override;
virtual Error file_dialog_show(const String &p_title, const String &p_current_directory, const String &p_filename, bool p_show_hidden, DisplayServerEnums::FileDialogMode p_mode, const Vector<String> &p_filters, const Callable &p_callback, DisplayServerEnums::WindowID p_window_id) override;
virtual Error file_dialog_with_options_show(const String &p_title, const String &p_current_directory, const String &p_root, const String &p_filename, bool p_show_hidden, DisplayServerEnums::FileDialogMode p_mode, const Vector<String> &p_filters, const TypedArray<Dictionary> &p_options, const Callable &p_callback, DisplayServerEnums::WindowID p_window_id) override;
#endif
virtual void beep() const override;
virtual void mouse_set_mode(MouseMode p_mode) override;
virtual MouseMode mouse_get_mode() const override;
virtual void mouse_set_mode_override(MouseMode p_mode) override;
virtual MouseMode mouse_get_mode_override() const override;
virtual void mouse_set_mode(DisplayServerEnums::MouseMode p_mode) override;
virtual DisplayServerEnums::MouseMode mouse_get_mode() const override;
virtual void mouse_set_mode_override(DisplayServerEnums::MouseMode p_mode) override;
virtual DisplayServerEnums::MouseMode mouse_get_mode_override() const override;
virtual void mouse_set_mode_override_enabled(bool p_override_enabled) override;
virtual bool mouse_is_mode_override_enabled() const override;
@ -226,83 +226,83 @@ public:
virtual int get_screen_count() const override;
virtual int get_primary_screen() const override;
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;
virtual float screen_get_scale(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_refresh_rate(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual Point2i screen_get_position(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Size2i screen_get_size(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Rect2i screen_get_usable_rect(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual int screen_get_dpi(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_scale(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_refresh_rate(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual void screen_set_keep_on(bool p_enable) override;
virtual bool screen_is_kept_on() const override;
virtual Vector<DisplayServer::WindowID> get_window_list() const override;
virtual Vector<DisplayServerEnums::WindowID> get_window_list() const override;
virtual WindowID create_sub_window(WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Rect2i &p_rect = Rect2i(), bool p_exclusive = false, WindowID p_transient_parent = INVALID_WINDOW_ID) override;
virtual void show_window(WindowID p_id) override;
virtual void delete_sub_window(WindowID p_id) override;
virtual DisplayServerEnums::WindowID create_sub_window(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Rect2i &p_rect = Rect2i(), bool p_exclusive = false, DisplayServerEnums::WindowID p_transient_parent = DisplayServerEnums::INVALID_WINDOW_ID) override;
virtual void show_window(DisplayServerEnums::WindowID p_id) override;
virtual void delete_sub_window(DisplayServerEnums::WindowID p_id) override;
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;
virtual DisplayServerEnums::WindowID window_get_active_popup() const override;
virtual void window_set_popup_safe_rect(DisplayServerEnums::WindowID p_window, const Rect2i &p_rect) override;
virtual Rect2i window_get_popup_safe_rect(DisplayServerEnums::WindowID p_window) const override;
virtual int64_t window_get_native_handle(HandleType p_handle_type, WindowID p_window = MAIN_WINDOW_ID) const override;
virtual int64_t window_get_native_handle(DisplayServerEnums::HandleType p_handle_type, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual WindowID get_window_at_screen_position(const Point2i &p_position) const override;
virtual DisplayServerEnums::WindowID get_window_at_screen_position(const Point2i &p_position) const override;
virtual void window_attach_instance_id(ObjectID p_instance, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual ObjectID window_get_attached_instance_id(WindowID p_window_id = MAIN_WINDOW_ID) const override;
virtual void window_attach_instance_id(ObjectID p_instance, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual ObjectID window_get_attached_instance_id(DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_title(const String &p_title, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual void window_set_mouse_passthrough(const Vector<Vector2> &p_region, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual void window_set_title(const String &p_title, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_mouse_passthrough(const Vector<Vector2> &p_region, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_rect_changed_callback(const Callable &p_callable, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual void window_set_window_event_callback(const Callable &p_callable, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual void window_set_input_event_callback(const Callable &p_callable, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual void window_set_input_text_callback(const Callable &p_callable, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual void window_set_drop_files_callback(const Callable &p_callable, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual void window_set_rect_changed_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_window_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_input_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_input_text_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_drop_files_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual int window_get_current_screen(WindowID p_window_id = MAIN_WINDOW_ID) const override;
virtual void window_set_current_screen(int p_screen, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual int window_get_current_screen(DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_current_screen(int p_screen, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Point2i window_get_position(WindowID p_window_id = MAIN_WINDOW_ID) const override;
virtual Point2i window_get_position_with_decorations(WindowID p_window_id = MAIN_WINDOW_ID) const override;
virtual void window_set_position(const Point2i &p_position, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual Point2i window_get_position(DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual Point2i window_get_position_with_decorations(DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_position(const Point2i &p_position, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_max_size(const Size2i p_size, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual Size2i window_get_max_size(WindowID p_window_id = MAIN_WINDOW_ID) const override;
virtual void gl_window_make_current(DisplayServer::WindowID p_window_id) override;
virtual void window_set_max_size(const Size2i p_size, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_max_size(DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void gl_window_make_current(DisplayServerEnums::WindowID p_window_id) override;
virtual void window_set_transient(WindowID p_window_id, WindowID p_parent) override;
virtual void window_set_transient(DisplayServerEnums::WindowID p_window_id, DisplayServerEnums::WindowID p_parent) override;
virtual void window_set_min_size(const Size2i p_size, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual Size2i window_get_min_size(WindowID p_window_id = MAIN_WINDOW_ID) const override;
virtual void window_set_min_size(const Size2i p_size, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_min_size(DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_size(const Size2i p_size, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual Size2i window_get_size(WindowID p_window_id = MAIN_WINDOW_ID) const override;
virtual Size2i window_get_size_with_decorations(WindowID p_window_id = MAIN_WINDOW_ID) const override;
virtual void window_set_size(const Size2i p_size, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_size(DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual Size2i window_get_size_with_decorations(DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual float window_get_scale(WindowID p_window_id = MAIN_WINDOW_ID) const override;
virtual float window_get_scale(DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_mode(WindowMode p_mode, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual WindowMode window_get_mode(WindowID p_window_id = MAIN_WINDOW_ID) const override;
virtual void window_set_mode(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual DisplayServerEnums::WindowMode window_get_mode(DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool window_is_maximize_allowed(WindowID p_window_id = MAIN_WINDOW_ID) const override;
virtual bool window_is_maximize_allowed(DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_flag(WindowFlags p_flag, bool p_enabled, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual bool window_get_flag(WindowFlags p_flag, WindowID p_window_id = MAIN_WINDOW_ID) const override;
virtual void window_set_flag(DisplayServerEnums::WindowFlags p_flag, bool p_enabled, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_get_flag(DisplayServerEnums::WindowFlags p_flag, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_request_attention(WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual void window_request_attention(DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_move_to_foreground(WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual bool window_is_focused(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_move_to_foreground(DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_is_focused(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool window_can_draw(WindowID p_window_id = MAIN_WINDOW_ID) const override;
virtual bool window_can_draw(DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool can_any_window_draw() const override;
virtual void window_set_ime_active(const bool p_active, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual void window_set_ime_position(const Point2i &p_pos, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual void window_set_ime_active(const bool p_active, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_ime_position(const Point2i &p_pos, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual int accessibility_should_increase_contrast() const override;
virtual int accessibility_screen_reader_active() const override;
@ -310,19 +310,19 @@ public:
virtual Point2i ime_get_selection() const override;
virtual String ime_get_text() const override;
virtual void window_set_vsync_mode(DisplayServer::VSyncMode p_vsync_mode, WindowID p_window_id = MAIN_WINDOW_ID) override;
virtual DisplayServer::VSyncMode window_get_vsync_mode(WindowID p_window_id) const override;
virtual void window_set_vsync_mode(DisplayServerEnums::VSyncMode p_vsync_mode, DisplayServerEnums::WindowID p_window_id = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual DisplayServerEnums::VSyncMode window_get_vsync_mode(DisplayServerEnums::WindowID p_window_id) const override;
virtual void window_start_drag(WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_start_resize(WindowResizeEdge p_edge, WindowID p_window) override;
virtual void window_start_drag(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_start_resize(DisplayServerEnums::WindowResizeEdge p_edge, DisplayServerEnums::WindowID p_window) override;
virtual void cursor_set_shape(CursorShape p_shape) override;
virtual CursorShape cursor_get_shape() const override;
virtual void cursor_set_custom_image(const Ref<Resource> &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) override;
virtual void cursor_set_shape(DisplayServerEnums::CursorShape p_shape) override;
virtual DisplayServerEnums::CursorShape cursor_get_shape() const override;
virtual void cursor_set_custom_image(const Ref<Resource> &p_cursor, DisplayServerEnums::CursorShape p_shape, const Vector2 &p_hotspot) override;
virtual bool get_swap_cancel_ok() override;
virtual Error embed_process(WindowID p_window, OS::ProcessID p_pid, const Rect2i &p_rect, bool p_visible, bool p_grab_focus) override;
virtual Error embed_process(DisplayServerEnums::WindowID p_window, OS::ProcessID p_pid, const Rect2i &p_rect, bool p_visible, bool p_grab_focus) override;
virtual Error request_close_embedded_process(OS::ProcessID p_pid) override;
virtual Error remove_embedded_process(OS::ProcessID p_pid) override;
virtual OS::ProcessID get_focused_process_id() override;
@ -344,16 +344,16 @@ public:
virtual void set_icon(const Ref<Image> &p_icon) override;
virtual void set_context(Context p_context) override;
virtual void set_context(DisplayServerEnums::Context p_context) override;
virtual bool is_window_transparency_available() const override;
static DisplayServer *create_func(const String &p_rendering_driver, WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Point2i *p_position, const Size2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error);
static DisplayServer *create_func(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Point2i *p_position, const Size2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
static Vector<String> get_rendering_drivers_func();
static void register_wayland_driver();
DisplayServerWayland(const String &p_rendering_driver, WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i &p_resolution, Context p_context, int64_t p_parent_window, Error &r_error);
DisplayServerWayland(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i &p_resolution, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
~DisplayServerWayland();
};

234
platform/linuxbsd/wayland/wayland_thread.cpp
View file

@ -444,7 +444,7 @@ bool WaylandThread::_load_cursor_theme(int p_cursor_size) {
"help"
};
for (int i = 0; i < DisplayServer::CURSOR_MAX; i++) {
for (int i = 0; i < DisplayServerEnums::CURSOR_MAX; i++) {
struct wl_cursor *cursor = wl_cursor_theme_get_cursor(wl_cursor_theme, cursor_names[i]);
if (!cursor && cursor_names_fallback[i]) {
@ -829,7 +829,7 @@ void WaylandThread::_wl_registry_on_global_remove(void *data, struct wl_registry
}
if (name == registry->wp_viewporter_name) {
for (KeyValue<DisplayServer::WindowID, WindowState> &pair : registry->wayland_thread->windows) {
for (KeyValue<DisplayServerEnums::WindowID, WindowState> &pair : registry->wayland_thread->windows) {
WindowState &ws = pair.value;
if (registry->wp_viewporter) {
wp_viewporter_destroy(registry->wp_viewporter);
@ -867,7 +867,7 @@ void WaylandThread::_wl_registry_on_global_remove(void *data, struct wl_registry
}
if (name == registry->wp_fractional_scale_manager_name) {
for (KeyValue<DisplayServer::WindowID, WindowState> &pair : registry->wayland_thread->windows) {
for (KeyValue<DisplayServerEnums::WindowID, WindowState> &pair : registry->wayland_thread->windows) {
WindowState &ws = pair.value;
if (registry->wp_fractional_scale_manager) {
@ -1368,7 +1368,7 @@ void WaylandThread::_xdg_toplevel_on_configure(void *data, struct xdg_toplevel *
// Expect the window to be in a plain state. It will get properly set if the
// compositor reports otherwise below.
ws->mode = DisplayServer::WINDOW_MODE_WINDOWED;
ws->mode = DisplayServerEnums::WINDOW_MODE_WINDOWED;
ws->maximized = false;
ws->fullscreen = false;
ws->resizing = false;
@ -1382,12 +1382,12 @@ void WaylandThread::_xdg_toplevel_on_configure(void *data, struct xdg_toplevel *
wl_array_for_each(state, states) {
switch (*state) {
case XDG_TOPLEVEL_STATE_MAXIMIZED: {
ws->mode = DisplayServer::WINDOW_MODE_MAXIMIZED;
ws->mode = DisplayServerEnums::WINDOW_MODE_MAXIMIZED;
ws->maximized = true;
} break;
case XDG_TOPLEVEL_STATE_FULLSCREEN: {
ws->mode = DisplayServer::WINDOW_MODE_FULLSCREEN;
ws->mode = DisplayServerEnums::WINDOW_MODE_FULLSCREEN;
ws->fullscreen = true;
} break;
@ -1435,7 +1435,7 @@ void WaylandThread::_xdg_toplevel_on_close(void *data, struct xdg_toplevel *xdg_
Ref<WindowEventMessage> msg;
msg.instantiate();
msg->id = ws->id;
msg->event = DisplayServer::WINDOW_EVENT_CLOSE_REQUEST;
msg->event = DisplayServerEnums::WINDOW_EVENT_CLOSE_REQUEST;
ws->wayland_thread->push_message(msg);
}
@ -1523,7 +1523,7 @@ void WaylandThread::_xdg_popup_on_popup_done(void *data, struct xdg_popup *xdg_p
Ref<WindowEventMessage> ev_msg;
ev_msg.instantiate();
ev_msg->id = ws->id;
ev_msg->event = DisplayServer::WINDOW_EVENT_FORCE_CLOSE;
ev_msg->event = DisplayServerEnums::WINDOW_EVENT_FORCE_CLOSE;
ws->wayland_thread->push_message(ev_msg);
}
@ -1586,7 +1586,7 @@ void WaylandThread::libdecor_frame_on_configure(struct libdecor_frame *frame, st
// Expect the window to be in a plain state. It will get properly set if the
// compositor reports otherwise below.
ws->mode = DisplayServer::WINDOW_MODE_WINDOWED;
ws->mode = DisplayServerEnums::WINDOW_MODE_WINDOWED;
ws->maximized = false;
ws->fullscreen = false;
ws->resizing = false;
@ -1598,12 +1598,12 @@ void WaylandThread::libdecor_frame_on_configure(struct libdecor_frame *frame, st
if (libdecor_configuration_get_window_state(configuration, &window_state)) {
if (window_state & LIBDECOR_WINDOW_STATE_MAXIMIZED) {
ws->mode = DisplayServer::WINDOW_MODE_MAXIMIZED;
ws->mode = DisplayServerEnums::WINDOW_MODE_MAXIMIZED;
ws->maximized = true;
}
if (window_state & LIBDECOR_WINDOW_STATE_FULLSCREEN) {
ws->mode = DisplayServer::WINDOW_MODE_FULLSCREEN;
ws->mode = DisplayServerEnums::WINDOW_MODE_FULLSCREEN;
ws->fullscreen = true;
}
@ -1642,7 +1642,7 @@ void WaylandThread::libdecor_frame_on_close(struct libdecor_frame *frame, void *
Ref<WindowEventMessage> winevent_msg;
winevent_msg.instantiate();
winevent_msg->id = ws->id;
winevent_msg->event = DisplayServer::WINDOW_EVENT_CLOSE_REQUEST;
winevent_msg->event = DisplayServerEnums::WINDOW_EVENT_CLOSE_REQUEST;
ws->wayland_thread->push_message(winevent_msg);
@ -1828,14 +1828,14 @@ void WaylandThread::_wl_pointer_on_leave(void *data, struct wl_pointer *wl_point
PointerData &pd = ss->pointer_data_buffer;
if (pd.pointed_id == DisplayServer::INVALID_WINDOW_ID) {
if (pd.pointed_id == DisplayServerEnums::INVALID_WINDOW_ID) {
// We're probably on a decoration or some other third-party thing.
return;
}
DisplayServer::WindowID id = pd.pointed_id;
DisplayServerEnums::WindowID id = pd.pointed_id;
pd.pointed_id = DisplayServer::INVALID_WINDOW_ID;
pd.pointed_id = DisplayServerEnums::INVALID_WINDOW_ID;
pd.pressed_button_mask.clear();
DEBUG_LOG_WAYLAND_THREAD(vformat("Pointer left window %d.", id));
@ -1946,20 +1946,20 @@ void WaylandThread::_wl_pointer_on_frame(void *data, struct wl_pointer *wl_point
PointerData &pd = ss->pointer_data_buffer;
if (pd.pointed_id != old_pd.pointed_id) {
if (old_pd.pointed_id != DisplayServer::INVALID_WINDOW_ID) {
if (old_pd.pointed_id != DisplayServerEnums::INVALID_WINDOW_ID) {
Ref<WindowEventMessage> msg;
msg.instantiate();
msg->id = old_pd.pointed_id;
msg->event = DisplayServer::WINDOW_EVENT_MOUSE_EXIT;
msg->event = DisplayServerEnums::WINDOW_EVENT_MOUSE_EXIT;
wayland_thread->push_message(msg);
}
if (pd.pointed_id != DisplayServer::INVALID_WINDOW_ID) {
if (pd.pointed_id != DisplayServerEnums::INVALID_WINDOW_ID) {
Ref<WindowEventMessage> msg;
msg.instantiate();
msg->id = pd.pointed_id;
msg->event = DisplayServer::WINDOW_EVENT_MOUSE_ENTER;
msg->event = DisplayServerEnums::WINDOW_EVENT_MOUSE_ENTER;
wayland_thread->push_message(msg);
}
@ -1972,10 +1972,10 @@ void WaylandThread::_wl_pointer_on_frame(void *data, struct wl_pointer *wl_point
// wl_pointer::button) within the same wl_pointer::frame. Because of this, we
// need to account for when the currently pointed window might be invalid
// (third-party or even none) and fall back to the old one.
if (pd.pointed_id != DisplayServer::INVALID_WINDOW_ID) {
if (pd.pointed_id != DisplayServerEnums::INVALID_WINDOW_ID) {
ws = ss->wayland_thread->window_get_state(pd.pointed_id);
ERR_FAIL_NULL(ws);
} else if (old_pd.pointed_id != DisplayServer::INVALID_WINDOW_ID) {
} else if (old_pd.pointed_id != DisplayServerEnums::INVALID_WINDOW_ID) {
ws = ss->wayland_thread->window_get_state(old_pd.pointed_id);
ERR_FAIL_NULL(ws);
}
@ -2293,7 +2293,7 @@ void WaylandThread::_wl_keyboard_on_enter(void *data, struct wl_keyboard *wl_key
Ref<WindowEventMessage> msg;
msg.instantiate();
msg->id = ws->id;
msg->event = DisplayServer::WINDOW_EVENT_FOCUS_IN;
msg->event = DisplayServerEnums::WINDOW_EVENT_FOCUS_IN;
wayland_thread->push_message(msg);
DEBUG_LOG_WAYLAND_THREAD(vformat("Keyboard focused window %d.", ws->id));
@ -2316,7 +2316,7 @@ void WaylandThread::_wl_keyboard_on_leave(void *data, struct wl_keyboard *wl_key
ss->repeating_keycode = XKB_KEYCODE_INVALID;
if (ss->focused_id == DisplayServer::INVALID_WINDOW_ID) {
if (ss->focused_id == DisplayServerEnums::INVALID_WINDOW_ID) {
// We're probably on a decoration or some other third-party thing.
return;
}
@ -2324,12 +2324,12 @@ void WaylandThread::_wl_keyboard_on_leave(void *data, struct wl_keyboard *wl_key
WindowState *ws = wayland_thread->window_get_state(ss->focused_id);
ERR_FAIL_NULL(ws);
ss->focused_id = DisplayServer::INVALID_WINDOW_ID;
ss->focused_id = DisplayServerEnums::INVALID_WINDOW_ID;
Ref<WindowEventMessage> msg;
msg.instantiate();
msg->id = ws->id;
msg->event = DisplayServer::WINDOW_EVENT_FOCUS_OUT;
msg->event = DisplayServerEnums::WINDOW_EVENT_FOCUS_OUT;
wayland_thread->push_message(msg);
ss->shift_pressed = false;
@ -2348,7 +2348,7 @@ void WaylandThread::_wl_keyboard_on_key(void *data, struct wl_keyboard *wl_keybo
SeatState *ss = (SeatState *)data;
ERR_FAIL_NULL(ss);
if (ss->focused_id == DisplayServer::INVALID_WINDOW_ID) {
if (ss->focused_id == DisplayServerEnums::INVALID_WINDOW_ID) {
return;
}
@ -2433,7 +2433,7 @@ void WaylandThread::_wl_data_device_on_leave(void *data, struct wl_data_device *
memdelete(wl_data_offer_get_offer_state(ss->wl_data_offer_dnd));
wl_data_offer_destroy(ss->wl_data_offer_dnd);
ss->wl_data_offer_dnd = nullptr;
ss->dnd_id = DisplayServer::INVALID_WINDOW_ID;
ss->dnd_id = DisplayServerEnums::INVALID_WINDOW_ID;
}
}
@ -2470,7 +2470,7 @@ void WaylandThread::_wl_data_device_on_drop(void *data, struct wl_data_device *w
memdelete(wl_data_offer_get_offer_state(ss->wl_data_offer_dnd));
wl_data_offer_destroy(ss->wl_data_offer_dnd);
ss->wl_data_offer_dnd = nullptr;
ss->dnd_id = DisplayServer::INVALID_WINDOW_ID;
ss->dnd_id = DisplayServerEnums::INVALID_WINDOW_ID;
}
void WaylandThread::_wl_data_device_on_selection(void *data, struct wl_data_device *wl_data_device, struct wl_data_offer *id) {
@ -2831,14 +2831,14 @@ void WaylandThread::_wp_tablet_tool_on_proximity_out(void *data, struct zwp_tabl
TabletToolState *ts = wp_tablet_tool_get_state(wp_tablet_tool_v2);
ERR_FAIL_NULL(ts);
if (ts->data_pending.proximal_id == DisplayServer::INVALID_WINDOW_ID) {
if (ts->data_pending.proximal_id == DisplayServerEnums::INVALID_WINDOW_ID) {
// We're probably on a decoration or some other third-party thing.
return;
}
DisplayServer::WindowID id = ts->data_pending.proximal_id;
DisplayServerEnums::WindowID id = ts->data_pending.proximal_id;
ts->data_pending.proximal_id = DisplayServer::INVALID_WINDOW_ID;
ts->data_pending.proximal_id = DisplayServerEnums::INVALID_WINDOW_ID;
ts->data_pending.pressed_button_mask.clear();
DEBUG_LOG_WAYLAND_THREAD(vformat("Tablet tool left window %d.", id));
@ -2974,26 +2974,26 @@ void WaylandThread::_wp_tablet_tool_on_frame(void *data, struct zwp_tablet_tool_
TabletToolData &td = ts->data_pending;
if (td.proximal_id != old_td.proximal_id) {
if (old_td.proximal_id != DisplayServer::INVALID_WINDOW_ID) {
if (old_td.proximal_id != DisplayServerEnums::INVALID_WINDOW_ID) {
Ref<WindowEventMessage> msg;
msg.instantiate();
msg->id = old_td.proximal_id;
msg->event = DisplayServer::WINDOW_EVENT_MOUSE_EXIT;
msg->event = DisplayServerEnums::WINDOW_EVENT_MOUSE_EXIT;
wayland_thread->push_message(msg);
}
if (td.proximal_id != DisplayServer::INVALID_WINDOW_ID) {
if (td.proximal_id != DisplayServerEnums::INVALID_WINDOW_ID) {
Ref<WindowEventMessage> msg;
msg.instantiate();
msg->id = td.proximal_id;
msg->event = DisplayServer::WINDOW_EVENT_MOUSE_ENTER;
msg->event = DisplayServerEnums::WINDOW_EVENT_MOUSE_ENTER;
wayland_thread->push_message(msg);
}
}
if (td.proximal_id == DisplayServer::INVALID_WINDOW_ID) {
if (td.proximal_id == DisplayServerEnums::INVALID_WINDOW_ID) {
// We're probably on a decoration or some other third-party thing. Let's
// "commit" the data and call it a day.
old_td = td;
@ -3128,7 +3128,7 @@ void WaylandThread::_wp_text_input_on_leave(void *data, struct zwp_text_input_v3
return;
}
if (ss->ime_window_id == DisplayServer::INVALID_WINDOW_ID) {
if (ss->ime_window_id == DisplayServerEnums::INVALID_WINDOW_ID) {
return;
}
@ -3139,7 +3139,7 @@ void WaylandThread::_wp_text_input_on_leave(void *data, struct zwp_text_input_v3
msg->selection = Vector2i();
ss->wayland_thread->push_message(msg);
ss->ime_window_id = DisplayServer::INVALID_WINDOW_ID;
ss->ime_window_id = DisplayServerEnums::INVALID_WINDOW_ID;
ss->ime_enabled = false;
ss->ime_active = false;
ss->ime_text = String();
@ -3153,7 +3153,7 @@ void WaylandThread::_wp_text_input_on_preedit_string(void *data, struct zwp_text
return;
}
if (ss->ime_window_id == DisplayServer::INVALID_WINDOW_ID) {
if (ss->ime_window_id == DisplayServerEnums::INVALID_WINDOW_ID) {
return;
}
@ -3205,7 +3205,7 @@ void WaylandThread::_wp_text_input_on_commit_string(void *data, struct zwp_text_
return;
}
if (ss->ime_window_id == DisplayServer::INVALID_WINDOW_ID) {
if (ss->ime_window_id == DisplayServerEnums::INVALID_WINDOW_ID) {
return;
}
@ -3222,7 +3222,7 @@ void WaylandThread::_wp_text_input_on_done(void *data, struct zwp_text_input_v3
return;
}
if (ss->ime_window_id == DisplayServer::INVALID_WINDOW_ID) {
if (ss->ime_window_id == DisplayServerEnums::INVALID_WINDOW_ID) {
return;
}
@ -3617,7 +3617,7 @@ void WaylandThread::window_state_update_size(WindowState *p_ws, int p_width, int
Ref<WindowEventMessage> dpi_msg;
dpi_msg.instantiate();
dpi_msg->id = p_ws->id;
dpi_msg->event = DisplayServer::WINDOW_EVENT_DPI_CHANGE;
dpi_msg->event = DisplayServerEnums::WINDOW_EVENT_DPI_CHANGE;
p_ws->wayland_thread->push_message(dpi_msg);
}
}
@ -3666,7 +3666,7 @@ void WaylandThread::seat_state_lock_pointer(SeatState *p_ss) {
if (p_ss->wp_locked_pointer == nullptr) {
struct wl_surface *locked_surface = window_get_wl_surface(p_ss->pointer_data.last_pointed_id);
if (locked_surface == nullptr) {
locked_surface = window_get_wl_surface(DisplayServer::MAIN_WINDOW_ID);
locked_surface = window_get_wl_surface(DisplayServerEnums::MAIN_WINDOW_ID);
}
ERR_FAIL_NULL(locked_surface);
@ -3687,7 +3687,7 @@ void WaylandThread::seat_state_warp_pointer(SeatState *p_ss, int p_x, int p_y) {
return;
}
if (p_ss->pointer_data.pointed_id == DisplayServer::INVALID_WINDOW_ID) {
if (p_ss->pointer_data.pointed_id == DisplayServerEnums::INVALID_WINDOW_ID) {
return;
}
@ -3734,7 +3734,7 @@ void WaylandThread::seat_state_update_cursor(SeatState *p_ss) {
int scale = 1;
if (thread->cursor_visible) {
DisplayServer::CursorShape shape = thread->cursor_shape;
DisplayServerEnums::CursorShape shape = thread->cursor_shape;
struct CustomCursor *custom_cursor = thread->custom_cursors.getptr(shape);
@ -3847,7 +3847,7 @@ Ref<WaylandThread::Message> WaylandThread::pop_message() {
return Ref<Message>();
}
void WaylandThread::window_create(DisplayServer::WindowID p_window_id, const Size2i &p_size, DisplayServer::WindowID p_parent_id) {
void WaylandThread::window_create(DisplayServerEnums::WindowID p_window_id, const Size2i &p_size, DisplayServerEnums::WindowID p_parent_id) {
ERR_FAIL_COND(windows.has(p_window_id));
WindowState &ws = windows[p_window_id];
@ -3911,7 +3911,7 @@ void WaylandThread::window_create(DisplayServer::WindowID p_window_id, const Siz
}
}
if (p_parent_id != DisplayServer::INVALID_WINDOW_ID) {
if (p_parent_id != DisplayServerEnums::INVALID_WINDOW_ID) {
// NOTE: It's important to set the parent ASAP to avoid misunderstandings with
// the compositor. For example, niri immediately resizes the window to full
// size as soon as it's configured if it's not parented to another toplevel.
@ -3937,7 +3937,7 @@ void WaylandThread::window_create(DisplayServer::WindowID p_window_id, const Siz
window_state_update_size(&ws, ws.rect.size.width, ws.rect.size.height);
}
void WaylandThread::window_create_popup(DisplayServer::WindowID p_window_id, DisplayServer::WindowID p_parent_id, Rect2i p_rect) {
void WaylandThread::window_create_popup(DisplayServerEnums::WindowID p_window_id, DisplayServerEnums::WindowID p_parent_id, Rect2i p_rect) {
ERR_FAIL_COND(windows.has(p_window_id));
ERR_FAIL_COND(!windows.has(p_parent_id));
@ -4024,7 +4024,7 @@ void WaylandThread::window_create_popup(DisplayServer::WindowID p_window_id, Dis
wl_display_roundtrip(wl_display);
}
void WaylandThread::window_destroy(DisplayServer::WindowID p_window_id) {
void WaylandThread::window_destroy(DisplayServerEnums::WindowID p_window_id) {
ERR_FAIL_COND(!windows.has(p_window_id));
WindowState &ws = windows[p_window_id];
@ -4074,7 +4074,7 @@ void WaylandThread::window_destroy(DisplayServer::WindowID p_window_id) {
windows.erase(p_window_id);
}
struct wl_surface *WaylandThread::window_get_wl_surface(DisplayServer::WindowID p_window_id) const {
struct wl_surface *WaylandThread::window_get_wl_surface(DisplayServerEnums::WindowID p_window_id) const {
const WindowState *ws = windows.getptr(p_window_id);
if (ws) {
return ws->wl_surface;
@ -4083,15 +4083,15 @@ struct wl_surface *WaylandThread::window_get_wl_surface(DisplayServer::WindowID
return nullptr;
}
WaylandThread::WindowState *WaylandThread::window_get_state(DisplayServer::WindowID p_window_id) {
WaylandThread::WindowState *WaylandThread::window_get_state(DisplayServerEnums::WindowID p_window_id) {
return windows.getptr(p_window_id);
}
const WaylandThread::WindowState *WaylandThread::window_get_state(DisplayServer::WindowID p_window_id) const {
const WaylandThread::WindowState *WaylandThread::window_get_state(DisplayServerEnums::WindowID p_window_id) const {
return windows.getptr(p_window_id);
}
Size2i WaylandThread::window_set_size(DisplayServer::WindowID p_window_id, const Size2i &p_size) {
Size2i WaylandThread::window_set_size(DisplayServerEnums::WindowID p_window_id, const Size2i &p_size) {
ERR_FAIL_COND_V(!windows.has(p_window_id), p_size);
WindowState &ws = windows[p_window_id];
@ -4149,7 +4149,7 @@ void WaylandThread::beep() const {
}
}
void WaylandThread::window_start_drag(DisplayServer::WindowID p_window_id) {
void WaylandThread::window_start_drag(DisplayServerEnums::WindowID p_window_id) {
ERR_FAIL_COND(!windows.has(p_window_id));
WindowState &ws = windows[p_window_id];
SeatState *ss = wl_seat_get_seat_state(wl_seat_current);
@ -4165,7 +4165,7 @@ void WaylandThread::window_start_drag(DisplayServer::WindowID p_window_id) {
#endif
}
void WaylandThread::window_start_resize(DisplayServer::WindowResizeEdge p_edge, DisplayServer::WindowID p_window) {
void WaylandThread::window_start_resize(DisplayServerEnums::WindowResizeEdge p_edge, DisplayServerEnums::WindowID p_window) {
ERR_FAIL_COND(!windows.has(p_window));
WindowState &ws = windows[p_window];
SeatState *ss = wl_seat_get_seat_state(wl_seat_current);
@ -4173,28 +4173,28 @@ void WaylandThread::window_start_resize(DisplayServer::WindowResizeEdge p_edge,
if (ss && ws.xdg_toplevel) {
xdg_toplevel_resize_edge edge = XDG_TOPLEVEL_RESIZE_EDGE_NONE;
switch (p_edge) {
case DisplayServer::WINDOW_EDGE_TOP_LEFT: {
case DisplayServerEnums::WINDOW_EDGE_TOP_LEFT: {
edge = XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT;
} break;
case DisplayServer::WINDOW_EDGE_TOP: {
case DisplayServerEnums::WINDOW_EDGE_TOP: {
edge = XDG_TOPLEVEL_RESIZE_EDGE_TOP;
} break;
case DisplayServer::WINDOW_EDGE_TOP_RIGHT: {
case DisplayServerEnums::WINDOW_EDGE_TOP_RIGHT: {
edge = XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT;
} break;
case DisplayServer::WINDOW_EDGE_LEFT: {
case DisplayServerEnums::WINDOW_EDGE_LEFT: {
edge = XDG_TOPLEVEL_RESIZE_EDGE_LEFT;
} break;
case DisplayServer::WINDOW_EDGE_RIGHT: {
case DisplayServerEnums::WINDOW_EDGE_RIGHT: {
edge = XDG_TOPLEVEL_RESIZE_EDGE_RIGHT;
} break;
case DisplayServer::WINDOW_EDGE_BOTTOM_LEFT: {
case DisplayServerEnums::WINDOW_EDGE_BOTTOM_LEFT: {
edge = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT;
} break;
case DisplayServer::WINDOW_EDGE_BOTTOM: {
case DisplayServerEnums::WINDOW_EDGE_BOTTOM: {
edge = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM;
} break;
case DisplayServer::WINDOW_EDGE_BOTTOM_RIGHT: {
case DisplayServerEnums::WINDOW_EDGE_BOTTOM_RIGHT: {
edge = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT;
} break;
default:
@ -4207,28 +4207,28 @@ void WaylandThread::window_start_resize(DisplayServer::WindowResizeEdge p_edge,
if (ws.libdecor_frame) {
libdecor_resize_edge edge = LIBDECOR_RESIZE_EDGE_NONE;
switch (p_edge) {
case DisplayServer::WINDOW_EDGE_TOP_LEFT: {
case DisplayServerEnums::WINDOW_EDGE_TOP_LEFT: {
edge = LIBDECOR_RESIZE_EDGE_TOP_LEFT;
} break;
case DisplayServer::WINDOW_EDGE_TOP: {
case DisplayServerEnums::WINDOW_EDGE_TOP: {
edge = LIBDECOR_RESIZE_EDGE_TOP;
} break;
case DisplayServer::WINDOW_EDGE_TOP_RIGHT: {
case DisplayServerEnums::WINDOW_EDGE_TOP_RIGHT: {
edge = LIBDECOR_RESIZE_EDGE_TOP_RIGHT;
} break;
case DisplayServer::WINDOW_EDGE_LEFT: {
case DisplayServerEnums::WINDOW_EDGE_LEFT: {
edge = LIBDECOR_RESIZE_EDGE_LEFT;
} break;
case DisplayServer::WINDOW_EDGE_RIGHT: {
case DisplayServerEnums::WINDOW_EDGE_RIGHT: {
edge = LIBDECOR_RESIZE_EDGE_RIGHT;
} break;
case DisplayServer::WINDOW_EDGE_BOTTOM_LEFT: {
case DisplayServerEnums::WINDOW_EDGE_BOTTOM_LEFT: {
edge = LIBDECOR_RESIZE_EDGE_BOTTOM_LEFT;
} break;
case DisplayServer::WINDOW_EDGE_BOTTOM: {
case DisplayServerEnums::WINDOW_EDGE_BOTTOM: {
edge = LIBDECOR_RESIZE_EDGE_BOTTOM;
} break;
case DisplayServer::WINDOW_EDGE_BOTTOM_RIGHT: {
case DisplayServerEnums::WINDOW_EDGE_BOTTOM_RIGHT: {
edge = LIBDECOR_RESIZE_EDGE_BOTTOM_RIGHT;
} break;
default:
@ -4239,7 +4239,7 @@ void WaylandThread::window_start_resize(DisplayServer::WindowResizeEdge p_edge,
#endif
}
void WaylandThread::window_set_parent(DisplayServer::WindowID p_window_id, DisplayServer::WindowID p_parent_id) {
void WaylandThread::window_set_parent(DisplayServerEnums::WindowID p_window_id, DisplayServerEnums::WindowID p_parent_id) {
ERR_FAIL_COND(!windows.has(p_window_id));
ERR_FAIL_COND(!windows.has(p_parent_id));
@ -4264,7 +4264,7 @@ void WaylandThread::window_set_parent(DisplayServer::WindowID p_window_id, Displ
}
}
void WaylandThread::window_set_max_size(DisplayServer::WindowID p_window_id, const Size2i &p_size) {
void WaylandThread::window_set_max_size(DisplayServerEnums::WindowID p_window_id, const Size2i &p_size) {
ERR_FAIL_COND(!windows.has(p_window_id));
WindowState &ws = windows[p_window_id];
@ -4283,7 +4283,7 @@ void WaylandThread::window_set_max_size(DisplayServer::WindowID p_window_id, con
#endif
}
void WaylandThread::window_set_min_size(DisplayServer::WindowID p_window_id, const Size2i &p_size) {
void WaylandThread::window_set_min_size(DisplayServerEnums::WindowID p_window_id, const Size2i &p_size) {
ERR_FAIL_COND(!windows.has(p_window_id));
WindowState &ws = windows[p_window_id];
@ -4302,17 +4302,17 @@ void WaylandThread::window_set_min_size(DisplayServer::WindowID p_window_id, con
#endif
}
bool WaylandThread::window_can_set_mode(DisplayServer::WindowID p_window_id, DisplayServer::WindowMode p_window_mode) const {
bool WaylandThread::window_can_set_mode(DisplayServerEnums::WindowID p_window_id, DisplayServerEnums::WindowMode p_window_mode) const {
ERR_FAIL_COND_V(!windows.has(p_window_id), false);
const WindowState &ws = windows[p_window_id];
switch (p_window_mode) {
case DisplayServer::WINDOW_MODE_WINDOWED: {
case DisplayServerEnums::WINDOW_MODE_WINDOWED: {
// Looks like it's guaranteed.
return true;
};
case DisplayServer::WINDOW_MODE_MINIMIZED: {
case DisplayServerEnums::WINDOW_MODE_MINIMIZED: {
#ifdef LIBDECOR_ENABLED
if (ws.libdecor_frame) {
return libdecor_frame_has_capability(ws.libdecor_frame, LIBDECOR_ACTION_MINIMIZE);
@ -4322,7 +4322,7 @@ bool WaylandThread::window_can_set_mode(DisplayServer::WindowID p_window_id, Dis
return ws.can_minimize;
};
case DisplayServer::WINDOW_MODE_MAXIMIZED: {
case DisplayServerEnums::WINDOW_MODE_MAXIMIZED: {
if (ws.libdecor_frame) {
// NOTE: libdecor doesn't seem to have a maximize capability query?
// The fact that there's a fullscreen one makes me suspicious. Anyways,
@ -4332,8 +4332,8 @@ bool WaylandThread::window_can_set_mode(DisplayServer::WindowID p_window_id, Dis
return ws.can_maximize;
};
case DisplayServer::WINDOW_MODE_FULLSCREEN:
case DisplayServer::WINDOW_MODE_EXCLUSIVE_FULLSCREEN: {
case DisplayServerEnums::WINDOW_MODE_FULLSCREEN:
case DisplayServerEnums::WINDOW_MODE_EXCLUSIVE_FULLSCREEN: {
#ifdef LIBDECOR_ENABLED
if (ws.libdecor_frame) {
return libdecor_frame_has_capability(ws.libdecor_frame, LIBDECOR_ACTION_FULLSCREEN);
@ -4347,7 +4347,7 @@ bool WaylandThread::window_can_set_mode(DisplayServer::WindowID p_window_id, Dis
return false;
}
void WaylandThread::window_try_set_mode(DisplayServer::WindowID p_window_id, DisplayServer::WindowMode p_window_mode) {
void WaylandThread::window_try_set_mode(DisplayServerEnums::WindowID p_window_id, DisplayServerEnums::WindowMode p_window_mode) {
ERR_FAIL_COND(!windows.has(p_window_id));
WindowState &ws = windows[p_window_id];
@ -4367,18 +4367,18 @@ void WaylandThread::window_try_set_mode(DisplayServer::WindowID p_window_id, Dis
// Return back to a windowed state so that we can apply what the user asked.
switch (ws.mode) {
case DisplayServer::WINDOW_MODE_WINDOWED: {
case DisplayServerEnums::WINDOW_MODE_WINDOWED: {
// Do nothing.
} break;
case DisplayServer::WINDOW_MODE_MINIMIZED: {
case DisplayServerEnums::WINDOW_MODE_MINIMIZED: {
// We can't do much according to the xdg_shell protocol. I have no idea
// whether this implies that we should return or who knows what. For now
// we'll do nothing.
// TODO: Test this properly.
} break;
case DisplayServer::WINDOW_MODE_MAXIMIZED: {
case DisplayServerEnums::WINDOW_MODE_MAXIMIZED: {
// Try to unmaximize. This isn't garaunteed to work actually, so we'll have
// to check whether something changed.
if (ws.xdg_toplevel) {
@ -4392,8 +4392,8 @@ void WaylandThread::window_try_set_mode(DisplayServer::WindowID p_window_id, Dis
#endif // LIBDECOR_ENABLED
} break;
case DisplayServer::WINDOW_MODE_FULLSCREEN:
case DisplayServer::WINDOW_MODE_EXCLUSIVE_FULLSCREEN: {
case DisplayServerEnums::WINDOW_MODE_FULLSCREEN:
case DisplayServerEnums::WINDOW_MODE_EXCLUSIVE_FULLSCREEN: {
// Same thing as above, unset fullscreen and check later if it worked.
if (ws.xdg_toplevel) {
xdg_toplevel_unset_fullscreen(ws.xdg_toplevel);
@ -4410,7 +4410,7 @@ void WaylandThread::window_try_set_mode(DisplayServer::WindowID p_window_id, Dis
// Wait for a configure event and hope that something changed.
wl_display_roundtrip(wl_display);
if (ws.mode != DisplayServer::WINDOW_MODE_WINDOWED) {
if (ws.mode != DisplayServerEnums::WINDOW_MODE_WINDOWED) {
// The compositor refused our "normalization" request. It'd be useless or
// unpredictable to attempt setting a new state. We're done.
return;
@ -4418,11 +4418,11 @@ void WaylandThread::window_try_set_mode(DisplayServer::WindowID p_window_id, Dis
// Ask the compositor to set the state indicated by the new mode.
switch (p_window_mode) {
case DisplayServer::WINDOW_MODE_WINDOWED: {
case DisplayServerEnums::WINDOW_MODE_WINDOWED: {
// Do nothing. We're already windowed.
} break;
case DisplayServer::WINDOW_MODE_MINIMIZED: {
case DisplayServerEnums::WINDOW_MODE_MINIMIZED: {
if (!window_can_set_mode(p_window_id, p_window_mode)) {
// Minimization is special (read below). Better not mess with it if the
// compositor explicitly announces that it doesn't support it.
@ -4441,10 +4441,10 @@ void WaylandThread::window_try_set_mode(DisplayServer::WindowID p_window_id, Dis
// We have no way to actually detect this state, so we'll have to report it
// manually to the engine (hoping that it worked). In the worst case it'll
// get reset by the next configure event.
ws.mode = DisplayServer::WINDOW_MODE_MINIMIZED;
ws.mode = DisplayServerEnums::WINDOW_MODE_MINIMIZED;
} break;
case DisplayServer::WINDOW_MODE_MAXIMIZED: {
case DisplayServerEnums::WINDOW_MODE_MAXIMIZED: {
if (ws.xdg_toplevel) {
xdg_toplevel_set_maximized(ws.xdg_toplevel);
}
@ -4456,8 +4456,8 @@ void WaylandThread::window_try_set_mode(DisplayServer::WindowID p_window_id, Dis
#endif // LIBDECOR_ENABLED
} break;
case DisplayServer::WINDOW_MODE_FULLSCREEN:
case DisplayServer::WINDOW_MODE_EXCLUSIVE_FULLSCREEN: {
case DisplayServerEnums::WINDOW_MODE_FULLSCREEN:
case DisplayServerEnums::WINDOW_MODE_EXCLUSIVE_FULLSCREEN: {
if (ws.xdg_toplevel) {
xdg_toplevel_set_fullscreen(ws.xdg_toplevel, nullptr);
}
@ -4474,7 +4474,7 @@ void WaylandThread::window_try_set_mode(DisplayServer::WindowID p_window_id, Dis
}
}
void WaylandThread::window_set_borderless(DisplayServer::WindowID p_window_id, bool p_borderless) {
void WaylandThread::window_set_borderless(DisplayServerEnums::WindowID p_window_id, bool p_borderless) {
ERR_FAIL_COND(!windows.has(p_window_id));
WindowState &ws = windows[p_window_id];
@ -4504,7 +4504,7 @@ void WaylandThread::window_set_borderless(DisplayServer::WindowID p_window_id, b
#endif // LIBDECOR_ENABLED
}
void WaylandThread::window_set_title(DisplayServer::WindowID p_window_id, const String &p_title) {
void WaylandThread::window_set_title(DisplayServerEnums::WindowID p_window_id, const String &p_title) {
ERR_FAIL_COND(!windows.has(p_window_id));
WindowState &ws = windows[p_window_id];
@ -4519,7 +4519,7 @@ void WaylandThread::window_set_title(DisplayServer::WindowID p_window_id, const
}
}
void WaylandThread::window_set_app_id(DisplayServer::WindowID p_window_id, const String &p_app_id) {
void WaylandThread::window_set_app_id(DisplayServerEnums::WindowID p_window_id, const String &p_app_id) {
ERR_FAIL_COND(!windows.has(p_window_id));
WindowState &ws = windows[p_window_id];
@ -4596,7 +4596,7 @@ void WaylandThread::set_icon(const Ref<Image> &p_icon) {
xdg_toplevel_icon_v1_set_name(xdg_icon, "godot");
}
for (KeyValue<DisplayServer::WindowID, WindowState> &pair : windows) {
for (KeyValue<DisplayServerEnums::WindowID, WindowState> &pair : windows) {
WindowState &ws = pair.value;
#ifdef LIBDECOR_ENABLED
if (ws.libdecor_frame) {
@ -4611,14 +4611,14 @@ void WaylandThread::set_icon(const Ref<Image> &p_icon) {
}
}
DisplayServer::WindowMode WaylandThread::window_get_mode(DisplayServer::WindowID p_window_id) const {
ERR_FAIL_COND_V(!windows.has(p_window_id), DisplayServer::WINDOW_MODE_WINDOWED);
DisplayServerEnums::WindowMode WaylandThread::window_get_mode(DisplayServerEnums::WindowID p_window_id) const {
ERR_FAIL_COND_V(!windows.has(p_window_id), DisplayServerEnums::WINDOW_MODE_WINDOWED);
const WindowState &ws = windows[p_window_id];
return ws.mode;
}
void WaylandThread::window_request_attention(DisplayServer::WindowID p_window_id) {
void WaylandThread::window_request_attention(DisplayServerEnums::WindowID p_window_id) {
ERR_FAIL_COND(!windows.has(p_window_id));
WindowState &ws = windows[p_window_id];
@ -4630,7 +4630,7 @@ void WaylandThread::window_request_attention(DisplayServer::WindowID p_window_id
}
}
void WaylandThread::window_set_idle_inhibition(DisplayServer::WindowID p_window_id, bool p_enable) {
void WaylandThread::window_set_idle_inhibition(DisplayServerEnums::WindowID p_window_id, bool p_enable) {
ERR_FAIL_COND(!windows.has(p_window_id));
WindowState &ws = windows[p_window_id];
@ -4647,7 +4647,7 @@ void WaylandThread::window_set_idle_inhibition(DisplayServer::WindowID p_window_
}
}
bool WaylandThread::window_get_idle_inhibition(DisplayServer::WindowID p_window_id) const {
bool WaylandThread::window_get_idle_inhibition(DisplayServerEnums::WindowID p_window_id) const {
ERR_FAIL_COND_V(!windows.has(p_window_id), false);
const WindowState &ws = windows[p_window_id];
@ -4664,7 +4664,7 @@ int WaylandThread::get_screen_count() const {
return registry.wl_outputs.size();
}
DisplayServer::WindowID WaylandThread::pointer_get_pointed_window_id() const {
DisplayServerEnums::WindowID WaylandThread::pointer_get_pointed_window_id() const {
SeatState *ss = wl_seat_get_seat_state(wl_seat_current);
if (ss) {
@ -4698,9 +4698,9 @@ DisplayServer::WindowID WaylandThread::pointer_get_pointed_window_id() const {
return ss->pointer_data.pointed_id;
}
return DisplayServer::INVALID_WINDOW_ID;
return DisplayServerEnums::INVALID_WINDOW_ID;
}
DisplayServer::WindowID WaylandThread::pointer_get_last_pointed_window_id() const {
DisplayServerEnums::WindowID WaylandThread::pointer_get_last_pointed_window_id() const {
SeatState *ss = wl_seat_get_seat_state(wl_seat_current);
if (ss) {
@ -4734,7 +4734,7 @@ DisplayServer::WindowID WaylandThread::pointer_get_last_pointed_window_id() cons
return ss->pointer_data.last_pointed_id;
}
return DisplayServer::INVALID_WINDOW_ID;
return DisplayServerEnums::INVALID_WINDOW_ID;
}
void WaylandThread::pointer_set_constraint(PointerConstraint p_constraint) {
@ -4984,7 +4984,7 @@ Error WaylandThread::init() {
}
// Update the cursor.
cursor_set_shape(DisplayServer::CURSOR_ARROW);
cursor_set_shape(DisplayServerEnums::CURSOR_ARROW);
events_thread.start(_poll_events_thread, &thread_data);
@ -5003,7 +5003,7 @@ void WaylandThread::cursor_set_visible(bool p_visible) {
}
}
void WaylandThread::cursor_set_shape(DisplayServer::CursorShape p_cursor_shape) {
void WaylandThread::cursor_set_shape(DisplayServerEnums::CursorShape p_cursor_shape) {
cursor_shape = p_cursor_shape;
for (struct wl_seat *wl_seat : registry.wl_seats) {
@ -5014,7 +5014,7 @@ void WaylandThread::cursor_set_shape(DisplayServer::CursorShape p_cursor_shape)
}
}
void WaylandThread::cursor_shape_set_custom_image(DisplayServer::CursorShape p_cursor_shape, Ref<Image> p_image, const Point2i &p_hotspot) {
void WaylandThread::cursor_shape_set_custom_image(DisplayServerEnums::CursorShape p_cursor_shape, Ref<Image> p_image, const Point2i &p_hotspot) {
ERR_FAIL_COND(p_image.is_null());
Size2i image_size = p_image->get_size();
@ -5068,7 +5068,7 @@ void WaylandThread::cursor_shape_set_custom_image(DisplayServer::CursorShape p_c
}
}
void WaylandThread::cursor_shape_clear_custom_image(DisplayServer::CursorShape p_cursor_shape) {
void WaylandThread::cursor_shape_clear_custom_image(DisplayServerEnums::CursorShape p_cursor_shape) {
if (custom_cursors.has(p_cursor_shape)) {
CustomCursor cursor = custom_cursors[p_cursor_shape];
custom_cursors.erase(p_cursor_shape);
@ -5083,7 +5083,7 @@ void WaylandThread::cursor_shape_clear_custom_image(DisplayServer::CursorShape p
}
}
void WaylandThread::window_set_ime_active(const bool p_active, DisplayServer::WindowID p_window_id) {
void WaylandThread::window_set_ime_active(const bool p_active, DisplayServerEnums::WindowID p_window_id) {
SeatState *ss = wl_seat_get_seat_state(wl_seat_current);
if (ss && ss->wp_text_input && ss->ime_enabled) {
@ -5102,7 +5102,7 @@ void WaylandThread::window_set_ime_active(const bool p_active, DisplayServer::Wi
}
}
void WaylandThread::window_set_ime_position(const Point2i &p_pos, DisplayServer::WindowID p_window_id) {
void WaylandThread::window_set_ime_position(const Point2i &p_pos, DisplayServerEnums::WindowID p_window_id) {
SeatState *ss = wl_seat_get_seat_state(wl_seat_current);
if (ss && ss->wp_text_input && ss->ime_enabled) {
@ -5350,7 +5350,7 @@ void WaylandThread::primary_set_text(const String &p_text) {
}
void WaylandThread::commit_surfaces() {
for (KeyValue<DisplayServer::WindowID, WindowState> &pair : windows) {
for (KeyValue<DisplayServerEnums::WindowID, WindowState> &pair : windows) {
wl_surface_commit(pair.value.wl_surface);
}
}
@ -5468,12 +5468,12 @@ bool WaylandThread::wait_frame_suspend_ms(int p_timeout) {
return false;
}
uint64_t WaylandThread::window_get_last_frame_time(DisplayServer::WindowID p_window_id) const {
uint64_t WaylandThread::window_get_last_frame_time(DisplayServerEnums::WindowID p_window_id) const {
ERR_FAIL_COND_V(!windows.has(p_window_id), false);
return windows[p_window_id].last_frame_time;
}
bool WaylandThread::window_is_suspended(DisplayServer::WindowID p_window_id) const {
bool WaylandThread::window_is_suspended(DisplayServerEnums::WindowID p_window_id) const {
ERR_FAIL_COND_V(!windows.has(p_window_id), false);
return windows[p_window_id].suspended;
}
@ -5483,7 +5483,7 @@ bool WaylandThread::is_fifo_available() const {
}
bool WaylandThread::is_suspended() const {
for (const KeyValue<DisplayServer::WindowID, WindowState> &E : windows) {
for (const KeyValue<DisplayServerEnums::WindowID, WindowState> &E : windows) {
if (!E.value.suspended) {
return false;
}
@ -5518,7 +5518,7 @@ void WaylandThread::destroy() {
events_thread.wait_to_finish();
}
for (KeyValue<DisplayServer::WindowID, WindowState> &pair : windows) {
for (KeyValue<DisplayServerEnums::WindowID, WindowState> &pair : windows) {
WindowState &ws = pair.value;
if (ws.wp_fractional_scale) {
wp_fractional_scale_v1_destroy(ws.wp_fractional_scale);

132
platform/linuxbsd/wayland/wayland_thread.h
View file

@ -108,7 +108,7 @@ public:
GDSOFTCLASS(WindowMessage, Message);
public:
DisplayServer::WindowID id = DisplayServer::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID id = DisplayServerEnums::INVALID_WINDOW_ID;
};
// Message data for window rect changes.
@ -125,7 +125,7 @@ public:
GDSOFTCLASS(WindowEventMessage, WindowMessage);
public:
DisplayServer::WindowEvent event;
DisplayServerEnums::WindowEvent event;
};
class InputEventMessage : public Message {
@ -247,11 +247,11 @@ public:
// TODO: Make private?
struct WindowState {
DisplayServer::WindowID id = DisplayServer::INVALID_WINDOW_ID;
DisplayServer::WindowID parent_id = DisplayServer::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID id = DisplayServerEnums::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID parent_id = DisplayServerEnums::INVALID_WINDOW_ID;
Rect2i rect;
DisplayServer::WindowMode mode = DisplayServer::WINDOW_MODE_WINDOWED;
DisplayServerEnums::WindowMode mode = DisplayServerEnums::WINDOW_MODE_WINDOWED;
// Toplevel states.
bool maximized = false; // MUST obey configure size.
@ -384,8 +384,8 @@ public:
MouseButton last_button_pressed = MouseButton::NONE;
Point2 last_pressed_position;
DisplayServer::WindowID pointed_id = DisplayServer::INVALID_WINDOW_ID;
DisplayServer::WindowID last_pointed_id = DisplayServer::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID pointed_id = DisplayServerEnums::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID last_pointed_id = DisplayServerEnums::INVALID_WINDOW_ID;
// This is needed to check for a new double click every time.
bool double_click_begun = false;
@ -419,8 +419,8 @@ public:
uint64_t button_time = 0;
uint64_t motion_time = 0;
DisplayServer::WindowID proximal_id = DisplayServer::INVALID_WINDOW_ID;
DisplayServer::WindowID last_proximal_id = DisplayServer::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID proximal_id = DisplayServerEnums::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID last_proximal_id = DisplayServerEnums::INVALID_WINDOW_ID;
uint32_t proximity_serial = 0;
};
@ -483,7 +483,7 @@ public:
struct wl_keyboard *wl_keyboard = nullptr;
// For key events.
DisplayServer::WindowID focused_id = DisplayServer::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID focused_id = DisplayServerEnums::INVALID_WINDOW_ID;
struct xkb_context *xkb_context = nullptr;
struct xkb_keymap *xkb_keymap = nullptr;
@ -522,7 +522,7 @@ public:
struct wl_data_device *wl_data_device = nullptr;
// Drag and drop.
DisplayServer::WindowID dnd_id = DisplayServer::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID dnd_id = DisplayServerEnums::INVALID_WINDOW_ID;
struct wl_data_offer *wl_data_offer_dnd = nullptr;
uint32_t dnd_enter_serial = 0;
@ -547,7 +547,7 @@ public:
// IME.
struct zwp_text_input_v3 *wp_text_input = nullptr;
DisplayServer::WindowID ime_window_id = DisplayServer::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID ime_window_id = DisplayServerEnums::INVALID_WINDOW_ID;
bool ime_enabled = false;
bool ime_active = false;
String ime_text;
@ -594,7 +594,7 @@ private:
Thread events_thread;
ThreadData thread_data;
HashMap<DisplayServer::WindowID, WindowState> windows;
HashMap<DisplayServerEnums::WindowID, WindowState> windows;
List<Ref<Message>> messages;
@ -612,34 +612,34 @@ private:
int cursor_scale = 1;
// Use cursor-shape-v1 protocol if the compositor supports it.
wp_cursor_shape_device_v1_shape standard_cursors[DisplayServer::CURSOR_MAX] = {
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DEFAULT, //CURSOR_ARROW
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_TEXT, //CURSOR_IBEAM
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_POINTER, //CURSOR_POINTING_HAND
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_CROSSHAIR, //CURSOR_CROSS
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_WAIT, //CURSOR_WAIT
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_PROGRESS, //CURSOR_BUSY
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_GRAB, //CURSOR_DRAG
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_GRABBING, //CURSOR_CAN_DROP
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NO_DROP, //CURSOR_FORBIDDEN
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NS_RESIZE, //CURSOR_VSIZE
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_EW_RESIZE, //CURSOR_HSIZE
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NESW_RESIZE, //CURSOR_BDIAGSIZE
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NWSE_RESIZE, //CURSOR_FDIAGSIZE
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_MOVE, //CURSOR_MOVE
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ROW_RESIZE, //CURSOR_VSPLIT
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_COL_RESIZE, //CURSOR_HSPLIT
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_HELP, //CURSOR_HELP
wp_cursor_shape_device_v1_shape standard_cursors[DisplayServerEnums::CURSOR_MAX] = {
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DEFAULT, //DisplayServerEnums::CURSOR_ARROW
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_TEXT, //DisplayServerEnums::CURSOR_IBEAM
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_POINTER, //DisplayServerEnums::CURSOR_POINTING_HAND
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_CROSSHAIR, //DisplayServerEnums::CURSOR_CROSS
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_WAIT, //DisplayServerEnums::CURSOR_WAIT
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_PROGRESS, //DisplayServerEnums::CURSOR_BUSY
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_GRAB, //DisplayServerEnums::CURSOR_DRAG
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_GRABBING, //DisplayServerEnums::CURSOR_CAN_DROP
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NO_DROP, //DisplayServerEnums::CURSOR_FORBIDDEN
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NS_RESIZE, //DisplayServerEnums::CURSOR_VSIZE
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_EW_RESIZE, //DisplayServerEnums::CURSOR_HSIZE
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NESW_RESIZE, //DisplayServerEnums::CURSOR_BDIAGSIZE
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NWSE_RESIZE, //DisplayServerEnums::CURSOR_FDIAGSIZE
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_MOVE, //DisplayServerEnums::CURSOR_MOVE
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_ROW_RESIZE, //DisplayServerEnums::CURSOR_VSPLIT
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_COL_RESIZE, //DisplayServerEnums::CURSOR_HSPLIT
wp_cursor_shape_device_v1_shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_HELP, //DisplayServerEnums::CURSOR_HELP
};
// Fallback to reading $XCURSOR and system themes if the compositor does not.
struct wl_cursor_theme *wl_cursor_theme = nullptr;
struct wl_cursor *wl_cursors[DisplayServer::CURSOR_MAX] = {};
struct wl_cursor *wl_cursors[DisplayServerEnums::CURSOR_MAX] = {};
// User-defined cursor overrides. Take precedence over standard and wl cursors.
HashMap<DisplayServer::CursorShape, CustomCursor> custom_cursors;
HashMap<DisplayServerEnums::CursorShape, CustomCursor> custom_cursors;
DisplayServer::CursorShape cursor_shape = DisplayServer::CURSOR_ARROW;
DisplayServerEnums::CursorShape cursor_shape = DisplayServerEnums::CURSOR_ARROW;
bool cursor_visible = true;
PointerConstraint pointer_constraint = PointerConstraint::NONE;
@ -1111,40 +1111,40 @@ public:
void set_icon(const Ref<Image> &p_icon);
void window_create(DisplayServer::WindowID p_window_id, const Size2i &p_size, DisplayServer::WindowID p_parent_id = DisplayServer::INVALID_WINDOW_ID);
void window_create_popup(DisplayServer::WindowID p_window_id, DisplayServer::WindowID p_parent_id, Rect2i p_rect);
void window_destroy(DisplayServer::WindowID p_window_Id);
void window_create(DisplayServerEnums::WindowID p_window_id, const Size2i &p_size, DisplayServerEnums::WindowID p_parent_id = DisplayServerEnums::INVALID_WINDOW_ID);
void window_create_popup(DisplayServerEnums::WindowID p_window_id, DisplayServerEnums::WindowID p_parent_id, Rect2i p_rect);
void window_destroy(DisplayServerEnums::WindowID p_window_Id);
void window_set_parent(DisplayServer::WindowID p_window_id, DisplayServer::WindowID p_parent_id);
void window_set_parent(DisplayServerEnums::WindowID p_window_id, DisplayServerEnums::WindowID p_parent_id);
struct wl_surface *window_get_wl_surface(DisplayServer::WindowID p_window_id) const;
WindowState *window_get_state(DisplayServer::WindowID p_window_id);
const WindowState *window_get_state(DisplayServer::WindowID p_window_id) const;
Size2i window_set_size(DisplayServer::WindowID p_window_id, const Size2i &p_size);
struct wl_surface *window_get_wl_surface(DisplayServerEnums::WindowID p_window_id) const;
WindowState *window_get_state(DisplayServerEnums::WindowID p_window_id);
const WindowState *window_get_state(DisplayServerEnums::WindowID p_window_id) const;
Size2i window_set_size(DisplayServerEnums::WindowID p_window_id, const Size2i &p_size);
void window_start_resize(DisplayServer::WindowResizeEdge p_edge, DisplayServer::WindowID p_window);
void window_start_resize(DisplayServerEnums::WindowResizeEdge p_edge, DisplayServerEnums::WindowID p_window);
void window_set_max_size(DisplayServer::WindowID p_window_id, const Size2i &p_size);
void window_set_min_size(DisplayServer::WindowID p_window_id, const Size2i &p_size);
void window_set_max_size(DisplayServerEnums::WindowID p_window_id, const Size2i &p_size);
void window_set_min_size(DisplayServerEnums::WindowID p_window_id, const Size2i &p_size);
bool window_can_set_mode(DisplayServer::WindowID p_window_id, DisplayServer::WindowMode p_window_mode) const;
void window_try_set_mode(DisplayServer::WindowID p_window_id, DisplayServer::WindowMode p_window_mode);
DisplayServer::WindowMode window_get_mode(DisplayServer::WindowID p_window_id) const;
bool window_can_set_mode(DisplayServerEnums::WindowID p_window_id, DisplayServerEnums::WindowMode p_window_mode) const;
void window_try_set_mode(DisplayServerEnums::WindowID p_window_id, DisplayServerEnums::WindowMode p_window_mode);
DisplayServerEnums::WindowMode window_get_mode(DisplayServerEnums::WindowID p_window_id) const;
void window_set_borderless(DisplayServer::WindowID p_window_id, bool p_borderless);
void window_set_title(DisplayServer::WindowID p_window_id, const String &p_title);
void window_set_app_id(DisplayServer::WindowID p_window_id, const String &p_app_id);
void window_set_borderless(DisplayServerEnums::WindowID p_window_id, bool p_borderless);
void window_set_title(DisplayServerEnums::WindowID p_window_id, const String &p_title);
void window_set_app_id(DisplayServerEnums::WindowID p_window_id, const String &p_app_id);
bool window_is_focused(DisplayServer::WindowID p_window_id);
bool window_is_focused(DisplayServerEnums::WindowID p_window_id);
// Optional - requires xdg_activation_v1
void window_request_attention(DisplayServer::WindowID p_window_id);
void window_request_attention(DisplayServerEnums::WindowID p_window_id);
void window_start_drag(DisplayServer::WindowID p_window_id);
void window_start_drag(DisplayServerEnums::WindowID p_window_id);
// Optional - require idle_inhibit_unstable_v1
void window_set_idle_inhibition(DisplayServer::WindowID p_window_id, bool p_enable);
bool window_get_idle_inhibition(DisplayServer::WindowID p_window_id) const;
void window_set_idle_inhibition(DisplayServerEnums::WindowID p_window_id, bool p_enable);
bool window_get_idle_inhibition(DisplayServerEnums::WindowID p_window_id) const;
ScreenData screen_get_data(int p_screen) const;
int get_screen_count() const;
@ -1153,19 +1153,19 @@ public:
void pointer_set_hint(const Point2i &p_hint);
void pointer_warp(const Point2i &p_to);
PointerConstraint pointer_get_constraint() const;
DisplayServer::WindowID pointer_get_pointed_window_id() const;
DisplayServer::WindowID pointer_get_last_pointed_window_id() const;
DisplayServerEnums::WindowID pointer_get_pointed_window_id() const;
DisplayServerEnums::WindowID pointer_get_last_pointed_window_id() const;
BitField<MouseButtonMask> pointer_get_button_mask() const;
void cursor_set_visible(bool p_visible);
void cursor_set_shape(DisplayServer::CursorShape p_cursor_shape);
void cursor_set_shape(DisplayServerEnums::CursorShape p_cursor_shape);
void cursor_set_custom_shape(DisplayServer::CursorShape p_cursor_shape);
void cursor_shape_set_custom_image(DisplayServer::CursorShape p_cursor_shape, Ref<Image> p_image, const Point2i &p_hotspot);
void cursor_shape_clear_custom_image(DisplayServer::CursorShape p_cursor_shape);
void cursor_set_custom_shape(DisplayServerEnums::CursorShape p_cursor_shape);
void cursor_shape_set_custom_image(DisplayServerEnums::CursorShape p_cursor_shape, Ref<Image> p_image, const Point2i &p_hotspot);
void cursor_shape_clear_custom_image(DisplayServerEnums::CursorShape p_cursor_shape);
void window_set_ime_active(const bool p_active, DisplayServer::WindowID p_window_id);
void window_set_ime_position(const Point2i &p_pos, DisplayServer::WindowID p_window_id);
void window_set_ime_active(const bool p_active, DisplayServerEnums::WindowID p_window_id);
void window_set_ime_position(const Point2i &p_pos, DisplayServerEnums::WindowID p_window_id);
int keyboard_get_layout_count() const;
int keyboard_get_current_layout_index() const;
@ -1195,8 +1195,8 @@ public:
bool wait_frame_suspend_ms(int p_timeout);
bool is_fifo_available() const;
uint64_t window_get_last_frame_time(DisplayServer::WindowID p_window_id) const;
bool window_is_suspended(DisplayServer::WindowID p_window_id) const;
uint64_t window_get_last_frame_time(DisplayServerEnums::WindowID p_window_id) const;
bool window_is_suspended(DisplayServerEnums::WindowID p_window_id) const;
bool is_suspended() const;
struct godot_embedding_compositor *get_embedding_compositor();

719
platform/linuxbsd/x11/display_server_x11.cpp
View file

File diff suppressed because it is too large Load diff

204
platform/linuxbsd/x11/display_server_x11.h
View file

@ -165,15 +165,15 @@ class DisplayServerX11 : public DisplayServer {
Vector<Vector2> mpath;
WindowID transient_parent = INVALID_WINDOW_ID;
HashSet<WindowID> transient_children;
DisplayServerEnums::WindowID transient_parent = DisplayServerEnums::INVALID_WINDOW_ID;
HashSet<DisplayServerEnums::WindowID> transient_children;
ObjectID instance_id;
bool no_focus = false;
//better to guess on the fly, given WM can change it
//WindowMode mode;
//DisplayServerEnums::WindowMode mode;
bool fullscreen = false; //OS can't exit from this mode
bool exclusive_fullscreen = false;
bool on_top = false;
@ -205,19 +205,19 @@ class DisplayServerX11 : public DisplayServer {
xkb_compose_table *dead_tbl = nullptr;
#endif
HashMap<WindowID, WindowData> windows;
HashMap<DisplayServerEnums::WindowID, WindowData> windows;
unsigned int last_mouse_monitor_mask = 0;
uint64_t time_since_popup = 0;
List<WindowID> popup_list;
List<DisplayServerEnums::WindowID> popup_list;
WindowID window_mouseover_id = INVALID_WINDOW_ID;
WindowID last_focused_window = INVALID_WINDOW_ID;
DisplayServerEnums::WindowID window_mouseover_id = DisplayServerEnums::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID last_focused_window = DisplayServerEnums::INVALID_WINDOW_ID;
WindowID window_id_counter = MAIN_WINDOW_ID;
DisplayServerEnums::WindowID window_id_counter = DisplayServerEnums::MAIN_WINDOW_ID;
void _create_xic(WindowData &wd);
WindowID _create_window(WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Rect2i &p_rect, Window p_parent_window);
DisplayServerEnums::WindowID _create_window(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Rect2i &p_rect, Window p_parent_window);
String internal_clipboard;
String internal_clipboard_primary;
@ -279,19 +279,19 @@ class DisplayServerX11 : public DisplayServer {
void _get_key_modifier_state(unsigned int p_x11_state, Ref<InputEventWithModifiers> state);
void _flush_mouse_motion();
MouseMode mouse_mode = MOUSE_MODE_VISIBLE;
MouseMode mouse_mode_base = MOUSE_MODE_VISIBLE;
MouseMode mouse_mode_override = MOUSE_MODE_VISIBLE;
DisplayServerEnums::MouseMode mouse_mode = DisplayServerEnums::MOUSE_MODE_VISIBLE;
DisplayServerEnums::MouseMode mouse_mode_base = DisplayServerEnums::MOUSE_MODE_VISIBLE;
DisplayServerEnums::MouseMode mouse_mode_override = DisplayServerEnums::MOUSE_MODE_VISIBLE;
bool mouse_mode_override_enabled = false;
void _mouse_update_mode();
Point2i center;
void _handle_key_event(WindowID p_window, XKeyEvent *p_event, LocalVector<XEvent> &p_events, uint32_t &p_event_index, bool p_echo = false);
void _handle_key_event(DisplayServerEnums::WindowID p_window, XKeyEvent *p_event, LocalVector<XEvent> &p_events, uint32_t &p_event_index, bool p_echo = false);
Atom _process_selection_request_target(Atom p_target, Window p_requestor, Atom p_property, Atom p_selection) const;
void _handle_selection_request_event(XSelectionRequestEvent *p_event) const;
void _update_window_mouse_passthrough(WindowID p_window);
void _update_window_mouse_passthrough(DisplayServerEnums::WindowID p_window);
String _clipboard_get_impl(Atom p_source, Window x11_window, Atom target) const;
String _clipboard_get(Atom p_source, Window x11_window) const;
@ -302,11 +302,11 @@ class DisplayServerX11 : public DisplayServer {
const char *cursor_theme = nullptr;
int cursor_size = 0;
XcursorImage *cursor_img[CURSOR_MAX];
Cursor cursors[CURSOR_MAX];
XcursorImage *cursor_img[DisplayServerEnums::CURSOR_MAX];
Cursor cursors[DisplayServerEnums::CURSOR_MAX];
Cursor null_cursor;
CursorShape current_cursor = CURSOR_ARROW;
HashMap<CursorShape, Vector<Variant>> cursors_cache;
DisplayServerEnums::CursorShape current_cursor = DisplayServerEnums::CURSOR_ARROW;
HashMap<DisplayServerEnums::CursorShape, Vector<Variant>> cursors_cache;
String rendering_driver;
void set_wm_fullscreen(bool p_enabled);
@ -331,26 +331,26 @@ class DisplayServerX11 : public DisplayServer {
static Property _read_property(Display *p_display, Window p_window, Atom p_property);
void _update_real_mouse_position(const WindowData &wd);
bool _window_maximize_check(WindowID p_window, const char *p_atom_name) const;
bool _window_fullscreen_check(WindowID p_window) const;
bool _window_minimize_check(WindowID p_window) const;
void _validate_fullscreen_on_map(WindowID p_window);
void _update_size_hints(WindowID p_window);
void _update_motif_wm_hints(WindowID p_window);
void _update_wm_state_hints(WindowID p_window);
void _set_wm_fullscreen(WindowID p_window, bool p_enabled, bool p_exclusive);
void _set_wm_maximized(WindowID p_window, bool p_enabled);
void _set_wm_minimized(WindowID p_window, bool p_enabled);
bool _window_maximize_check(DisplayServerEnums::WindowID p_window, const char *p_atom_name) const;
bool _window_fullscreen_check(DisplayServerEnums::WindowID p_window) const;
bool _window_minimize_check(DisplayServerEnums::WindowID p_window) const;
void _validate_fullscreen_on_map(DisplayServerEnums::WindowID p_window);
void _update_size_hints(DisplayServerEnums::WindowID p_window);
void _update_motif_wm_hints(DisplayServerEnums::WindowID p_window);
void _update_wm_state_hints(DisplayServerEnums::WindowID p_window);
void _set_wm_fullscreen(DisplayServerEnums::WindowID p_window, bool p_enabled, bool p_exclusive);
void _set_wm_maximized(DisplayServerEnums::WindowID p_window, bool p_enabled);
void _set_wm_minimized(DisplayServerEnums::WindowID p_window, bool p_enabled);
void _update_context(WindowData &wd);
Context context = CONTEXT_ENGINE;
DisplayServerEnums::Context context = DisplayServerEnums::CONTEXT_ENGINE;
bool swap_cancel_ok = false;
WindowID _get_focused_window_or_popup() const;
DisplayServerEnums::WindowID _get_focused_window_or_popup() const;
bool _window_focus_check();
void _send_window_event(const WindowData &wd, WindowEvent p_event);
void _send_window_event(const WindowData &wd, DisplayServerEnums::WindowEvent p_event);
static void _dispatch_input_events(const Ref<InputEvent> &p_event);
void _dispatch_input_event(const Ref<InputEvent> &p_event);
void _set_input_focus(Window p_window, int p_revert_to);
@ -377,7 +377,7 @@ class DisplayServerX11 : public DisplayServer {
Point2i _get_window_position(Window p_window) const;
Rect2i _get_window_rect(Window p_window) const;
void _set_external_window_settings(Window p_window, Window p_parent_transient, WindowMode p_mode, uint32_t p_flags, const Rect2i &p_rect);
void _set_external_window_settings(Window p_window, Window p_parent_transient, DisplayServerEnums::WindowMode p_mode, uint32_t p_flags, const Rect2i &p_rect);
void _set_window_taskbar_pager_enabled(Window p_window, bool p_enabled);
Rect2i _screens_get_full_rect() const;
@ -388,10 +388,10 @@ protected:
public:
bool mouse_process_popups();
void popup_open(WindowID p_window);
void popup_close(WindowID p_window);
void popup_open(DisplayServerEnums::WindowID p_window);
void popup_close(DisplayServerEnums::WindowID p_window);
virtual bool has_feature(Feature p_feature) const override;
virtual bool has_feature(DisplayServerEnums::Feature p_feature) const override;
virtual String get_name() const override;
#ifdef SPEECHD_ENABLED
@ -411,16 +411,16 @@ public:
virtual Color get_accent_color() const override;
virtual void set_system_theme_change_callback(const Callable &p_callable) override;
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, WindowID p_window_id) override;
virtual Error file_dialog_with_options_show(const String &p_title, const String &p_current_directory, const String &p_root, const String &p_filename, bool p_show_hidden, FileDialogMode p_mode, const Vector<String> &p_filters, const TypedArray<Dictionary> &p_options, const Callable &p_callback, WindowID p_window_id) override;
virtual Error file_dialog_show(const String &p_title, const String &p_current_directory, const String &p_filename, bool p_show_hidden, DisplayServerEnums::FileDialogMode p_mode, const Vector<String> &p_filters, const Callable &p_callback, DisplayServerEnums::WindowID p_window_id) override;
virtual Error file_dialog_with_options_show(const String &p_title, const String &p_current_directory, const String &p_root, const String &p_filename, bool p_show_hidden, DisplayServerEnums::FileDialogMode p_mode, const Vector<String> &p_filters, const TypedArray<Dictionary> &p_options, const Callable &p_callback, DisplayServerEnums::WindowID p_window_id) override;
#endif
virtual void beep() const override;
virtual void mouse_set_mode(MouseMode p_mode) override;
virtual MouseMode mouse_get_mode() const override;
virtual void mouse_set_mode_override(MouseMode p_mode) override;
virtual MouseMode mouse_get_mode_override() const override;
virtual void mouse_set_mode(DisplayServerEnums::MouseMode p_mode) override;
virtual DisplayServerEnums::MouseMode mouse_get_mode() const override;
virtual void mouse_set_mode_override(DisplayServerEnums::MouseMode p_mode) override;
virtual DisplayServerEnums::MouseMode mouse_get_mode_override() const override;
virtual void mouse_set_mode_override_enabled(bool p_override_enabled) override;
virtual bool mouse_is_mode_override_enabled() const override;
@ -438,86 +438,86 @@ public:
virtual int get_screen_count() const override;
virtual int get_primary_screen() const override;
virtual int get_keyboard_focus_screen() const override;
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;
virtual float screen_get_refresh_rate(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual Point2i screen_get_position(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Size2i screen_get_size(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Rect2i screen_get_usable_rect(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual int screen_get_dpi(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_refresh_rate(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Color screen_get_pixel(const Point2i &p_position) const override;
virtual Ref<Image> screen_get_image(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual Ref<Image> screen_get_image(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
#if defined(DBUS_ENABLED)
virtual void screen_set_keep_on(bool p_enable) override;
virtual bool screen_is_kept_on() const override;
#endif
virtual Vector<DisplayServer::WindowID> get_window_list() const override;
virtual Vector<DisplayServerEnums::WindowID> get_window_list() const override;
virtual WindowID create_sub_window(WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Rect2i &p_rect = Rect2i(), bool p_exclusive = false, WindowID p_transient_parent = INVALID_WINDOW_ID) override;
virtual void show_window(WindowID p_id) override;
virtual void delete_sub_window(WindowID p_id) override;
virtual DisplayServerEnums::WindowID create_sub_window(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Rect2i &p_rect = Rect2i(), bool p_exclusive = false, DisplayServerEnums::WindowID p_transient_parent = DisplayServerEnums::INVALID_WINDOW_ID) override;
virtual void show_window(DisplayServerEnums::WindowID p_id) override;
virtual void delete_sub_window(DisplayServerEnums::WindowID p_id) override;
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;
virtual DisplayServerEnums::WindowID window_get_active_popup() const override;
virtual void window_set_popup_safe_rect(DisplayServerEnums::WindowID p_window, const Rect2i &p_rect) override;
virtual Rect2i window_get_popup_safe_rect(DisplayServerEnums::WindowID p_window) const override;
virtual WindowID get_window_at_screen_position(const Point2i &p_position) const override;
virtual DisplayServerEnums::WindowID get_window_at_screen_position(const Point2i &p_position) const override;
virtual int64_t window_get_native_handle(HandleType p_handle_type, WindowID p_window = MAIN_WINDOW_ID) const override;
virtual int64_t window_get_native_handle(DisplayServerEnums::HandleType p_handle_type, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_attach_instance_id(ObjectID p_instance, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual ObjectID window_get_attached_instance_id(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_title(const String &p_title, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_mouse_passthrough(const Vector<Vector2> &p_region, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
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;
virtual void window_set_rect_changed_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_window_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_input_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_input_text_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_drop_files_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
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;
virtual int window_get_current_screen(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_current_screen(int p_screen, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Point2i window_get_position(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual Point2i window_get_position_with_decorations(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_position(const Point2i &p_position, WindowID p_window = MAIN_WINDOW_ID) override;
virtual Point2i window_get_position(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual Point2i window_get_position_with_decorations(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_position(const Point2i &p_position, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
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;
virtual void gl_window_make_current(DisplayServer::WindowID p_window_id) override;
virtual void window_set_max_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_max_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void gl_window_make_current(DisplayServerEnums::WindowID p_window_id) override;
virtual void window_set_transient(WindowID p_window, WindowID p_parent) override;
virtual void window_set_transient(DisplayServerEnums::WindowID p_window, DisplayServerEnums::WindowID p_parent) override;
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;
virtual void window_set_min_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_min_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual Size2i window_get_size_with_decorations(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual Size2i window_get_size_with_decorations(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_mode(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual DisplayServerEnums::WindowMode window_get_mode(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool window_is_maximize_allowed(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual bool window_is_maximize_allowed(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_flag(DisplayServerEnums::WindowFlags p_flag, bool p_enabled, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_get_flag(DisplayServerEnums::WindowFlags p_flag, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_request_attention(WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_request_attention(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_move_to_foreground(WindowID p_window = MAIN_WINDOW_ID) override;
virtual bool window_is_focused(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_move_to_foreground(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_is_focused(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual WindowID get_focused_window() const override;
virtual DisplayServerEnums::WindowID get_focused_window() const override;
virtual bool window_can_draw(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual bool window_can_draw(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool can_any_window_draw() const override;
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;
virtual void window_set_ime_active(const bool p_active, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_ime_position(const Point2i &p_pos, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual int accessibility_should_increase_contrast() const override;
virtual int accessibility_screen_reader_active() const override;
@ -525,20 +525,20 @@ public:
virtual Point2i ime_get_selection() const override;
virtual String ime_get_text() const override;
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;
virtual void window_set_vsync_mode(DisplayServerEnums::VSyncMode p_vsync_mode, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual DisplayServerEnums::VSyncMode window_get_vsync_mode(DisplayServerEnums::WindowID p_vsync_mode) const override;
virtual void window_start_drag(WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_start_resize(WindowResizeEdge p_edge, WindowID p_window) override;
virtual void window_start_drag(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_start_resize(DisplayServerEnums::WindowResizeEdge p_edge, DisplayServerEnums::WindowID p_window) override;
virtual Error embed_process(WindowID p_window, OS::ProcessID p_pid, const Rect2i &p_rect, bool p_visible, bool p_grab_focus) override;
virtual Error embed_process(DisplayServerEnums::WindowID p_window, OS::ProcessID p_pid, const Rect2i &p_rect, bool p_visible, bool p_grab_focus) override;
virtual Error request_close_embedded_process(OS::ProcessID p_pid) override;
virtual Error remove_embedded_process(OS::ProcessID p_pid) override;
virtual OS::ProcessID get_focused_process_id() override;
virtual void cursor_set_shape(CursorShape p_shape) override;
virtual CursorShape cursor_get_shape() const override;
virtual void cursor_set_custom_image(const Ref<Resource> &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) override;
virtual void cursor_set_shape(DisplayServerEnums::CursorShape p_shape) override;
virtual DisplayServerEnums::CursorShape cursor_get_shape() const override;
virtual void cursor_set_custom_image(const Ref<Resource> &p_cursor, DisplayServerEnums::CursorShape p_shape, const Vector2 &p_hotspot) override;
virtual bool get_swap_cancel_ok() override;
@ -557,19 +557,19 @@ public:
virtual void release_rendering_thread() override;
virtual void swap_buffers() override;
virtual void set_context(Context p_context) override;
virtual void set_context(DisplayServerEnums::Context p_context) override;
virtual bool is_window_transparency_available() const override;
virtual void set_native_icon(const String &p_filename) override;
virtual void set_icon(const Ref<Image> &p_icon) override;
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, Context p_context, int64_t p_parent_window, Error &r_error);
static DisplayServer *create_func(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
static Vector<String> get_rendering_drivers_func();
static void register_x11_driver();
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, Context p_context, int64_t p_parent_window, Error &r_error);
DisplayServerX11(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
~DisplayServerX11();
};

16
platform/linuxbsd/x11/gl_manager_x11.cpp
View file

@ -222,7 +222,7 @@ Error GLManager_X11::open_display(Display *p_display) {
}
}
Error GLManager_X11::window_create(DisplayServer::WindowID p_window_id, ::Window p_window, Display *p_display, int p_width, int p_height) {
Error GLManager_X11::window_create(DisplayServerEnums::WindowID p_window_id, ::Window p_window, Display *p_display, int p_width, int p_height) {
// make sure vector is big enough...
// we can mirror the external vector, it is simpler
// to keep the IDs identical for fast lookup
@ -265,12 +265,12 @@ void GLManager_X11::_internal_set_current_window(GLWindow *p_win) {
_x_windisp.x11_display = disp.x11_display;
}
void GLManager_X11::window_resize(DisplayServer::WindowID p_window_id, int p_width, int p_height) {
void GLManager_X11::window_resize(DisplayServerEnums::WindowID p_window_id, int p_width, int p_height) {
get_window(p_window_id).width = p_width;
get_window(p_window_id).height = p_height;
}
void GLManager_X11::window_destroy(DisplayServer::WindowID p_window_id) {
void GLManager_X11::window_destroy(DisplayServerEnums::WindowID p_window_id) {
GLWindow &win = get_window(p_window_id);
win.in_use = false;
@ -292,7 +292,7 @@ void GLManager_X11::release_current() {
_current_window = nullptr;
}
void GLManager_X11::window_make_current(DisplayServer::WindowID p_window_id) {
void GLManager_X11::window_make_current(DisplayServerEnums::WindowID p_window_id) {
if (p_window_id == -1) {
return;
}
@ -327,7 +327,7 @@ void GLManager_X11::swap_buffers() {
// On X11, when enabled, transparency is always active, so clear alpha manually.
if (OS::get_singleton()->is_layered_allowed()) {
if (!DisplayServer::get_singleton()->window_get_flag(DisplayServer::WINDOW_FLAG_TRANSPARENT, _current_window->window_id)) {
if (!DisplayServer::get_singleton()->window_get_flag(DisplayServerEnums::WINDOW_FLAG_TRANSPARENT, _current_window->window_id)) {
glColorMask(false, false, false, true);
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
@ -372,7 +372,7 @@ bool GLManager_X11::is_using_vsync() const {
return use_vsync;
}
void *GLManager_X11::get_glx_context(DisplayServer::WindowID p_window_id) {
void *GLManager_X11::get_glx_context(DisplayServerEnums::WindowID p_window_id) {
if (p_window_id == -1) {
return nullptr;
}
@ -383,7 +383,7 @@ void *GLManager_X11::get_glx_context(DisplayServer::WindowID p_window_id) {
return (void *)disp.context->glx_context;
}
VisualID GLManager_X11::get_glx_visualid(DisplayServer::WindowID p_window_id) {
VisualID GLManager_X11::get_glx_visualid(DisplayServerEnums::WindowID p_window_id) {
if (p_window_id == -1) {
return (VisualID)0;
}
@ -394,7 +394,7 @@ VisualID GLManager_X11::get_glx_visualid(DisplayServer::WindowID p_window_id) {
return disp.x_vi.visualid;
}
void *GLManager_X11::get_glx_fbconfig(DisplayServer::WindowID p_window_id) {
void *GLManager_X11::get_glx_fbconfig(DisplayServerEnums::WindowID p_window_id) {
if (p_window_id == -1) {
return nullptr;
}

16
platform/linuxbsd/x11/gl_manager_x11.h
View file

@ -65,7 +65,7 @@ private:
bool in_use = false;
// the external ID .. should match the GL window number .. unused I think
DisplayServer::WindowID window_id = DisplayServer::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID window_id = DisplayServerEnums::INVALID_WINDOW_ID;
int width = 0;
int height = 0;
::Window x11_window;
@ -112,23 +112,23 @@ private:
public:
XVisualInfo get_vi(Display *p_display, Error &r_error);
Error window_create(DisplayServer::WindowID p_window_id, ::Window p_window, Display *p_display, int p_width, int p_height);
void window_destroy(DisplayServer::WindowID p_window_id);
void window_resize(DisplayServer::WindowID p_window_id, int p_width, int p_height);
Error window_create(DisplayServerEnums::WindowID p_window_id, ::Window p_window, Display *p_display, int p_width, int p_height);
void window_destroy(DisplayServerEnums::WindowID p_window_id);
void window_resize(DisplayServerEnums::WindowID p_window_id, int p_width, int p_height);
void release_current();
void swap_buffers();
void window_make_current(DisplayServer::WindowID p_window_id);
void window_make_current(DisplayServerEnums::WindowID p_window_id);
Error initialize(Display *p_display);
void set_use_vsync(bool p_use);
bool is_using_vsync() const;
void *get_glx_context(DisplayServer::WindowID p_window_id);
void *get_glx_fbconfig(DisplayServer::WindowID p_window_id);
VisualID get_glx_visualid(DisplayServer::WindowID p_window_id);
void *get_glx_context(DisplayServerEnums::WindowID p_window_id);
void *get_glx_fbconfig(DisplayServerEnums::WindowID p_window_id);
VisualID get_glx_visualid(DisplayServerEnums::WindowID p_window_id);
Error open_display(Display *p_display);
GLManager_X11(const Vector2i &p_size, ContextType p_context_type);

2
platform/linuxbsd/x11/gl_manager_x11_egl.h
View file

@ -48,7 +48,7 @@ private:
virtual Vector<EGLint> _get_platform_context_attribs() const override;
public:
void window_resize(DisplayServer::WindowID p_window_id, int p_width, int p_height) {}
void window_resize(DisplayServerEnums::WindowID p_window_id, int p_width, int p_height) {}
GLManagerEGL_X11() {}
~GLManagerEGL_X11() {}

219
platform/macos/display_server_macos.h
View file

@ -69,7 +69,6 @@
#endif
#undef BitMap
#undef CursorShape
#undef FontVariation
#ifdef TOOLS_ENABLED
@ -85,7 +84,7 @@ class DisplayServerMacOS : public DisplayServerMacOSBase {
public:
struct KeyEvent {
WindowID window_id = INVALID_WINDOW_ID;
DisplayServerEnums::WindowID window_id = DisplayServerEnums::INVALID_WINDOW_ID;
unsigned int macos_state = false;
bool pressed = false;
bool echo = false;
@ -108,7 +107,7 @@ public:
CGDirectDisplayID display_id = -1;
Point2i mouse_pos;
WindowResizeEdge edge = WINDOW_EDGE_MAX;
DisplayServerEnums::WindowResizeEdge edge = DisplayServerEnums::WINDOW_EDGE_MAX;
Size2i min_size;
Size2i max_size;
@ -131,9 +130,9 @@ public:
bool fs_transition = false;
bool initial_size = true;
WindowID transient_parent = INVALID_WINDOW_ID;
DisplayServerEnums::WindowID transient_parent = DisplayServerEnums::INVALID_WINDOW_ID;
bool exclusive = false;
HashSet<WindowID> transient_children;
HashSet<DisplayServerEnums::WindowID> transient_children;
bool layered_window = false;
bool fullscreen = false;
@ -156,7 +155,7 @@ public:
Rect2i parent_safe_rect;
};
List<WindowID> popup_list;
List<DisplayServerEnums::WindowID> popup_list;
uint64_t time_since_popup = 0;
GodotProgressView *dock_progress = nullptr;
@ -185,34 +184,34 @@ private:
NativeMenuMacOS *native_menu = nullptr;
CGEventSourceRef event_source;
void _mouse_apply_mode(MouseMode p_prev_mode, MouseMode p_new_mode) override;
void _mouse_apply_mode(DisplayServerEnums::MouseMode p_prev_mode, DisplayServerEnums::MouseMode p_new_mode) override;
HDROutput &_get_hdr_output(WindowID p_window) override;
const HDROutput &_get_hdr_output(WindowID p_window) const override;
HDROutput &_get_hdr_output(DisplayServerEnums::WindowID p_window) override;
const HDROutput &_get_hdr_output(DisplayServerEnums::WindowID p_window) const override;
bool drop_events = false;
bool in_dispatch_input_event = false;
WindowID window_mouseover_id = INVALID_WINDOW_ID;
WindowID last_focused_window = INVALID_WINDOW_ID;
WindowID window_id_counter = MAIN_WINDOW_ID;
DisplayServerEnums::WindowID window_mouseover_id = DisplayServerEnums::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID last_focused_window = DisplayServerEnums::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID window_id_counter = DisplayServerEnums::MAIN_WINDOW_ID;
float display_max_scale = 1.f;
mutable Point2i origin;
mutable bool displays_arrangement_dirty = true;
bool is_resizing = false;
NSCursor *cursors[CURSOR_MAX];
HashMap<CursorShape, Vector<Variant>> cursors_cache;
NSCursor *cursors[DisplayServerEnums::CURSOR_MAX];
HashMap<DisplayServerEnums::CursorShape, Vector<Variant>> cursors_cache;
HashMap<WindowID, WindowData> windows;
HashMap<DisplayServerEnums::WindowID, WindowData> windows;
struct IndicatorData {
id delegate;
id item;
};
IndicatorID indicator_id_counter = 0;
HashMap<IndicatorID, IndicatorData> indicators;
DisplayServerEnums::IndicatorID indicator_id_counter = 0;
HashMap<DisplayServerEnums::IndicatorID, IndicatorData> indicators;
Callable help_search_callback;
Callable help_action_callback;
@ -223,8 +222,8 @@ private:
};
List<MenuCall> deferred_menu_calls;
WindowID _create_window(WindowMode p_mode, VSyncMode p_vsync_mode, const Rect2i &p_rect);
void _update_window_style(WindowData p_wd, WindowID p_window);
DisplayServerEnums::WindowID _create_window(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, const Rect2i &p_rect);
void _update_window_style(WindowData p_wd, DisplayServerEnums::WindowID p_window);
void _update_displays_arrangement() const;
Point2i _get_native_screen_position(int p_screen) const;
@ -237,7 +236,7 @@ private:
static NSCursor *_cursor_from_selector(SEL p_selector, SEL p_fallback = nil);
Error _file_dialog_with_options_show(const String &p_title, const String &p_current_directory, const String &p_root, const String &p_filename, bool p_show_hidden, FileDialogMode p_mode, const Vector<String> &p_filters, const TypedArray<Dictionary> &p_options, const Callable &p_callback, bool p_options_in_cb, WindowID p_window_id);
Error _file_dialog_with_options_show(const String &p_title, const String &p_current_directory, const String &p_root, const String &p_filename, bool p_show_hidden, DisplayServerEnums::FileDialogMode p_mode, const Vector<String> &p_filters, const TypedArray<Dictionary> &p_options, const Callable &p_callback, bool p_options_in_cb, DisplayServerEnums::WindowID p_window_id);
#ifdef TOOLS_ENABLED
struct EmbeddedProcessData {
@ -252,8 +251,8 @@ private:
public:
void menu_callback(id p_sender);
bool has_window(WindowID p_window) const;
WindowData &get_window(WindowID p_window);
bool has_window(DisplayServerEnums::WindowID p_window) const;
WindowData &get_window(DisplayServerEnums::WindowID p_window);
NSImage *_convert_to_nsimg(Ref<Image> &p_image) const;
Point2i _get_screens_origin() const;
@ -261,37 +260,37 @@ public:
void set_menu_delegate(NSMenu *p_menu);
void send_event(NSEvent *p_event);
void send_window_event(const WindowData &p_wd, WindowEvent p_event);
void send_window_event(const WindowData &p_wd, DisplayServerEnums::WindowEvent p_event);
void release_pressed_events();
void sync_mouse_state();
void get_key_modifier_state(unsigned int p_macos_state, Ref<InputEventWithModifiers> r_state) const;
void update_mouse_pos(WindowData &p_wd, NSPoint p_location_in_window);
void push_to_key_event_buffer(const KeyEvent &p_event);
void pop_last_key_event();
void set_last_focused_window(WindowID p_window);
void set_last_focused_window(DisplayServerEnums::WindowID p_window);
bool mouse_process_popups(bool p_close = false);
void popup_open(WindowID p_window);
void popup_close(WindowID p_window);
void popup_open(DisplayServerEnums::WindowID p_window);
void popup_close(DisplayServerEnums::WindowID p_window);
void set_is_resizing(bool p_is_resizing);
bool get_is_resizing() const;
void reparent_check(WindowID p_window);
WindowID _get_focused_window_or_popup() const;
void mouse_enter_window(WindowID p_window);
void mouse_exit_window(WindowID p_window);
void reparent_check(DisplayServerEnums::WindowID p_window);
DisplayServerEnums::WindowID _get_focused_window_or_popup() const;
void mouse_enter_window(DisplayServerEnums::WindowID p_window);
void mouse_exit_window(DisplayServerEnums::WindowID p_window);
void update_presentation_mode();
bool is_always_on_top_recursive(WindowID p_window) const;
bool is_always_on_top_recursive(DisplayServerEnums::WindowID p_window) const;
/**
* Get the display ID of a window.
*/
uint32_t window_get_display_id(WindowID p_window) const;
void window_destroy(WindowID p_window);
void window_resize(WindowID p_window, int p_width, int p_height);
uint32_t window_get_display_id(DisplayServerEnums::WindowID p_window) const;
void window_destroy(DisplayServerEnums::WindowID p_window);
void window_resize(DisplayServerEnums::WindowID p_window, int p_width, int p_height);
void window_set_custom_window_buttons(WindowData &p_wd, bool p_enabled);
void set_window_per_pixel_transparency_enabled(bool p_enabled, WindowID p_window);
void set_window_per_pixel_transparency_enabled(bool p_enabled, DisplayServerEnums::WindowID p_window);
virtual bool has_feature(Feature p_feature) const override;
virtual bool has_feature(DisplayServerEnums::Feature p_feature) const override;
virtual String get_name() const override;
virtual void help_set_search_callbacks(const Callable &p_search_callback = Callable(), const Callable &p_action_callback = Callable()) override;
@ -301,8 +300,8 @@ public:
virtual Error dialog_show(String p_title, String p_description, Vector<String> p_buttons, const Callable &p_callback) override;
virtual Error dialog_input_text(String p_title, String p_description, String p_partial, const Callable &p_callback) override;
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, WindowID p_window_id) override;
virtual Error file_dialog_with_options_show(const String &p_title, const String &p_current_directory, const String &p_root, const String &p_filename, bool p_show_hidden, FileDialogMode p_mode, const Vector<String> &p_filters, const TypedArray<Dictionary> &p_options, const Callable &p_callback, WindowID p_window_id) override;
virtual Error file_dialog_show(const String &p_title, const String &p_current_directory, const String &p_filename, bool p_show_hidden, DisplayServerEnums::FileDialogMode p_mode, const Vector<String> &p_filters, const Callable &p_callback, DisplayServerEnums::WindowID p_window_id) override;
virtual Error file_dialog_with_options_show(const String &p_title, const String &p_current_directory, const String &p_root, const String &p_filename, bool p_show_hidden, DisplayServerEnums::FileDialogMode p_mode, const Vector<String> &p_filters, const TypedArray<Dictionary> &p_options, const Callable &p_callback, DisplayServerEnums::WindowID p_window_id) override;
bool update_mouse_wrap(WindowData &p_wd, NSPoint &r_delta, NSPoint &r_mpos, NSTimeInterval p_timestamp);
virtual void warp_mouse(const Point2i &p_position) override;
@ -311,88 +310,88 @@ public:
virtual int get_screen_count() const override;
virtual int get_keyboard_focus_screen() const override;
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 int screen_get_dpi(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_scale(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual Point2i screen_get_position(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Size2i screen_get_size(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual int screen_get_dpi(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_scale(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_max_scale() const override;
virtual Rect2i screen_get_usable_rect(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual Rect2i screen_get_usable_rect(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Color screen_get_pixel(const Point2i &p_position) const override;
virtual Ref<Image> screen_get_image(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual Ref<Image> screen_get_image(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Ref<Image> screen_get_image_rect(const Rect2i &p_rect) const override;
virtual Vector<int> get_window_list() const override;
virtual WindowID create_sub_window(WindowMode p_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Rect2i &p_rect = Rect2i(), bool p_exclusive = false, WindowID p_transient_parent = INVALID_WINDOW_ID) override;
virtual void show_window(WindowID p_id) override;
virtual void delete_sub_window(WindowID p_id) override;
virtual DisplayServerEnums::WindowID create_sub_window(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Rect2i &p_rect = Rect2i(), bool p_exclusive = false, DisplayServerEnums::WindowID p_transient_parent = DisplayServerEnums::INVALID_WINDOW_ID) override;
virtual void show_window(DisplayServerEnums::WindowID p_id) override;
virtual void delete_sub_window(DisplayServerEnums::WindowID p_id) override;
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;
virtual DisplayServerEnums::WindowID window_get_active_popup() const override;
virtual void window_set_popup_safe_rect(DisplayServerEnums::WindowID p_window, const Rect2i &p_rect) override;
virtual Rect2i window_get_popup_safe_rect(DisplayServerEnums::WindowID p_window) const override;
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;
virtual void window_set_rect_changed_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_window_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_input_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_input_text_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_drop_files_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_title(const String &p_title, WindowID p_window = MAIN_WINDOW_ID) override;
virtual Size2i window_get_title_size(const String &p_title, WindowID p_window) const override;
virtual void window_set_mouse_passthrough(const Vector<Vector2> &p_region, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_title(const String &p_title, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_title_size(const String &p_title, DisplayServerEnums::WindowID p_window) const override;
virtual void window_set_mouse_passthrough(const Vector<Vector2> &p_region, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
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;
virtual int window_get_current_screen(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_current_screen(int p_screen, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Point2i window_get_position(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual Point2i window_get_position_with_decorations(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_position(const Point2i &p_position, WindowID p_window = MAIN_WINDOW_ID) override;
virtual Point2i window_get_position(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual Point2i window_get_position_with_decorations(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_position(const Point2i &p_position, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_transient(WindowID p_window, WindowID p_parent) override;
virtual void window_set_exclusive(WindowID p_window, bool p_exclusive) override;
virtual void window_set_transient(DisplayServerEnums::WindowID p_window, DisplayServerEnums::WindowID p_parent) override;
virtual void window_set_exclusive(DisplayServerEnums::WindowID p_window, bool p_exclusive) override;
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;
virtual void window_set_max_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_max_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_min_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_min_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual Size2i window_get_size_with_decorations(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual Size2i window_get_size_with_decorations(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_mode(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual DisplayServerEnums::WindowMode window_get_mode(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool window_is_maximize_allowed(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual bool window_is_maximize_allowed(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_flag(DisplayServerEnums::WindowFlags p_flag, bool p_enabled, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_get_flag(DisplayServerEnums::WindowFlags p_flag, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_request_attention(WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_taskbar_progress_value(float p_value, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_taskbar_progress_state(ProgressState p_state, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_move_to_foreground(WindowID p_window = MAIN_WINDOW_ID) override;
virtual bool window_is_focused(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_request_attention(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_taskbar_progress_value(float p_value, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_taskbar_progress_state(DisplayServerEnums::ProgressState p_state, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_move_to_foreground(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_is_focused(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual WindowID get_focused_window() const override;
virtual DisplayServerEnums::WindowID get_focused_window() const override;
virtual bool window_can_draw(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual bool window_can_draw(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool can_any_window_draw() const override;
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;
virtual void window_set_ime_active(const bool p_active, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_ime_position(const Point2i &p_pos, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual WindowID get_window_at_screen_position(const Point2i &p_position) const override;
virtual DisplayServerEnums::WindowID get_window_at_screen_position(const Point2i &p_position) const override;
virtual int64_t window_get_native_handle(HandleType p_handle_type, WindowID p_window = MAIN_WINDOW_ID) const override;
virtual int64_t window_get_native_handle(DisplayServerEnums::HandleType p_handle_type, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void gl_window_make_current(DisplayServer::WindowID p_window_id) override;
virtual void window_attach_instance_id(ObjectID p_instance, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual ObjectID window_get_attached_instance_id(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void gl_window_make_current(DisplayServerEnums::WindowID p_window_id) override;
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;
virtual void window_set_vsync_mode(DisplayServerEnums::VSyncMode p_vsync_mode, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual DisplayServerEnums::VSyncMode window_get_vsync_mode(DisplayServerEnums::WindowID p_vsync_mode) const override;
public:
void update_screen_parameters();
@ -400,21 +399,21 @@ public:
virtual bool window_maximize_on_title_dbl_click() const override;
virtual bool window_minimize_on_title_dbl_click() const override;
virtual void window_start_drag(WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_start_resize(WindowResizeEdge p_edge, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_start_drag(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_start_resize(DisplayServerEnums::WindowResizeEdge p_edge, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_window_buttons_offset(const Vector2i &p_offset, WindowID p_window = MAIN_WINDOW_ID) override;
virtual Vector3i window_get_safe_title_margins(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_window_buttons_offset(const Vector2i &p_offset, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Vector3i window_get_safe_title_margins(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
void cursor_update_shape();
virtual void cursor_set_shape(CursorShape p_shape) override;
virtual void cursor_set_custom_image(const Ref<Resource> &p_cursor, CursorShape p_shape = CURSOR_ARROW, const Vector2 &p_hotspot = Vector2()) override;
virtual void cursor_set_shape(DisplayServerEnums::CursorShape p_shape) override;
virtual void cursor_set_custom_image(const Ref<Resource> &p_cursor, DisplayServerEnums::CursorShape p_shape = DisplayServerEnums::CURSOR_ARROW, const Vector2 &p_hotspot = Vector2()) override;
virtual bool get_swap_cancel_ok() override;
virtual void enable_for_stealing_focus(OS::ProcessID pid) override;
#ifdef TOOLS_ENABLED
Error embed_process_update(WindowID p_window, EmbeddedProcessMacOS *p_process);
Error embed_process_update(DisplayServerEnums::WindowID p_window, EmbeddedProcessMacOS *p_process);
virtual Error request_close_embedded_process(OS::ProcessID p_pid) override;
virtual Error remove_embedded_process(OS::ProcessID p_pid) override;
#endif
@ -429,23 +428,23 @@ public:
virtual void set_native_icon(const String &p_filename) override;
virtual void set_icon(const Ref<Image> &p_icon) override;
virtual IndicatorID create_status_indicator(const Ref<Texture2D> &p_icon, const String &p_tooltip, const Callable &p_callback) override;
virtual void status_indicator_set_icon(IndicatorID p_id, const Ref<Texture2D> &p_icon) override;
virtual void status_indicator_set_tooltip(IndicatorID p_id, const String &p_tooltip) override;
virtual void status_indicator_set_menu(IndicatorID p_id, const RID &p_menu_rid) override;
virtual void status_indicator_set_callback(IndicatorID p_id, const Callable &p_callback) override;
virtual Rect2 status_indicator_get_rect(IndicatorID p_id) const override;
virtual void delete_status_indicator(IndicatorID p_id) override;
virtual DisplayServerEnums::IndicatorID create_status_indicator(const Ref<Texture2D> &p_icon, const String &p_tooltip, const Callable &p_callback) override;
virtual void status_indicator_set_icon(DisplayServerEnums::IndicatorID p_id, const Ref<Texture2D> &p_icon) override;
virtual void status_indicator_set_tooltip(DisplayServerEnums::IndicatorID p_id, const String &p_tooltip) override;
virtual void status_indicator_set_menu(DisplayServerEnums::IndicatorID p_id, const RID &p_menu_rid) override;
virtual void status_indicator_set_callback(DisplayServerEnums::IndicatorID p_id, const Callable &p_callback) override;
virtual Rect2 status_indicator_get_rect(DisplayServerEnums::IndicatorID p_id) const override;
virtual void delete_status_indicator(DisplayServerEnums::IndicatorID p_id) override;
virtual bool is_window_transparency_available() const override;
void window_get_edr_values(WindowID p_window, CGFloat *r_max_potential_edr_value, CGFloat *r_max_edr_value) const override;
void window_get_edr_values(DisplayServerEnums::WindowID p_window, CGFloat *r_max_potential_edr_value, CGFloat *r_max_edr_value) const override;
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, Context p_context, int64_t p_parent_window, Error &r_error);
static DisplayServer *create_func(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
static Vector<String> get_rendering_drivers_func();
static void register_macos_driver();
DisplayServerMacOS(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, Context p_context, int64_t p_parent_window, Error &r_error);
DisplayServerMacOS(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
~DisplayServerMacOS();
};

622
platform/macos/display_server_macos.mm
View file

File diff suppressed because it is too large Load diff

52
platform/macos/display_server_macos_base.h
View file

@ -73,18 +73,18 @@ public:
protected:
_THREAD_SAFE_CLASS_
MouseMode mouse_mode = MOUSE_MODE_VISIBLE;
MouseMode mouse_mode_base = MOUSE_MODE_VISIBLE;
MouseMode mouse_mode_override = MOUSE_MODE_VISIBLE;
DisplayServerEnums::MouseMode mouse_mode = DisplayServerEnums::MOUSE_MODE_VISIBLE;
DisplayServerEnums::MouseMode mouse_mode_base = DisplayServerEnums::MOUSE_MODE_VISIBLE;
DisplayServerEnums::MouseMode mouse_mode_override = DisplayServerEnums::MOUSE_MODE_VISIBLE;
bool mouse_mode_override_enabled = false;
void _mouse_update_mode();
virtual void _mouse_apply_mode(MouseMode p_prev_mode, MouseMode p_new_mode) = 0;
virtual void _mouse_apply_mode(DisplayServerEnums::MouseMode p_prev_mode, DisplayServerEnums::MouseMode p_new_mode) = 0;
String im_text;
Point2i im_selection;
CursorShape cursor_shape = CURSOR_ARROW;
DisplayServerEnums::CursorShape cursor_shape = DisplayServerEnums::CURSOR_ARROW;
void initialize_tts() const;
@ -98,11 +98,11 @@ protected:
RenderingDevice *rendering_device = nullptr;
#endif
virtual HDROutput &_get_hdr_output(WindowID p_window) = 0;
virtual const HDROutput &_get_hdr_output(WindowID p_window) const = 0;
virtual HDROutput &_get_hdr_output(DisplayServerEnums::WindowID p_window) = 0;
virtual const HDROutput &_get_hdr_output(DisplayServerEnums::WindowID p_window) const = 0;
constexpr float _calculate_current_reference_luminance(CGFloat p_max_potential_edr_value, CGFloat p_max_edr_value) const;
void _update_hdr_output(WindowID p_window, const HDROutput &p_hdr);
void _update_hdr_output(DisplayServerEnums::WindowID p_window, const HDROutput &p_hdr);
public:
virtual bool tts_is_speaking() const override;
@ -121,10 +121,10 @@ public:
virtual Color get_base_color() const override;
virtual void set_system_theme_change_callback(const Callable &p_callable) override;
virtual void mouse_set_mode(MouseMode p_mode) override;
virtual MouseMode mouse_get_mode() const override;
virtual void mouse_set_mode_override(MouseMode p_mode) override;
virtual MouseMode mouse_get_mode_override() const override;
virtual void mouse_set_mode(DisplayServerEnums::MouseMode p_mode) override;
virtual DisplayServerEnums::MouseMode mouse_get_mode() const override;
virtual void mouse_set_mode_override(DisplayServerEnums::MouseMode p_mode) override;
virtual DisplayServerEnums::MouseMode mouse_get_mode_override() const override;
virtual void mouse_set_mode_override_enabled(bool p_override_enabled) override;
virtual bool mouse_is_mode_override_enabled() const override;
@ -135,7 +135,7 @@ public:
virtual bool clipboard_has_image() const override;
virtual int get_primary_screen() const override;
virtual float screen_get_refresh_rate(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_refresh_rate(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual void screen_set_keep_on(bool p_enable) override;
virtual bool screen_is_kept_on() const override;
@ -148,7 +148,7 @@ public:
virtual Point2i ime_get_selection() const override;
virtual String ime_get_text() const override;
virtual CursorShape cursor_get_shape() const override;
virtual DisplayServerEnums::CursorShape cursor_get_shape() const override;
virtual void beep() const override;
@ -161,21 +161,21 @@ public:
virtual Key keyboard_get_label_from_physical(Key p_keycode) const override;
virtual void show_emoji_and_symbol_picker() const override;
virtual void window_get_edr_values(WindowID p_window, CGFloat *r_max_potential_edr_value = nullptr, CGFloat *r_max_edr_value = nullptr) const = 0;
virtual bool window_is_hdr_output_supported(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_request_hdr_output(const bool p_enable, WindowID p_window = MAIN_WINDOW_ID) override;
virtual bool window_is_hdr_output_requested(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual bool window_is_hdr_output_enabled(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_get_edr_values(DisplayServerEnums::WindowID p_window, CGFloat *r_max_potential_edr_value = nullptr, CGFloat *r_max_edr_value = nullptr) const = 0;
virtual bool window_is_hdr_output_supported(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_request_hdr_output(const bool p_enable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_is_hdr_output_requested(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool window_is_hdr_output_enabled(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_hdr_output_reference_luminance(const float p_reference_luminance, WindowID p_window = MAIN_WINDOW_ID) override;
virtual float window_get_hdr_output_reference_luminance(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual float window_get_hdr_output_current_reference_luminance(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_hdr_output_reference_luminance(const float p_reference_luminance, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual float window_get_hdr_output_reference_luminance(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual float window_get_hdr_output_current_reference_luminance(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_hdr_output_max_luminance(const float p_max_luminance, WindowID p_window = MAIN_WINDOW_ID) override;
virtual float window_get_hdr_output_max_luminance(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual float window_get_hdr_output_current_max_luminance(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_hdr_output_max_luminance(const float p_max_luminance, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual float window_get_hdr_output_max_luminance(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual float window_get_hdr_output_current_max_luminance(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual float window_get_output_max_linear_value(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual float window_get_output_max_linear_value(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
DisplayServerMacOSBase();
~DisplayServerMacOSBase();

42
platform/macos/display_server_macos_base.mm
View file

@ -45,7 +45,7 @@
#import <Carbon/Carbon.h>
void DisplayServerMacOSBase::_mouse_update_mode() {
MouseMode wanted_mouse_mode = mouse_mode_override_enabled
DisplayServerEnums::MouseMode wanted_mouse_mode = mouse_mode_override_enabled
? mouse_mode_override
: mouse_mode_base;
@ -53,13 +53,13 @@ void DisplayServerMacOSBase::_mouse_update_mode() {
return;
}
MouseMode prev_mode = mouse_mode;
DisplayServerEnums::MouseMode prev_mode = mouse_mode;
mouse_mode = wanted_mouse_mode;
_mouse_apply_mode(prev_mode, wanted_mouse_mode);
}
void DisplayServerMacOSBase::mouse_set_mode(MouseMode p_mode) {
ERR_FAIL_INDEX(p_mode, MouseMode::MOUSE_MODE_MAX);
void DisplayServerMacOSBase::mouse_set_mode(DisplayServerEnums::MouseMode p_mode) {
ERR_FAIL_INDEX(p_mode, DisplayServerEnums::MouseMode::MOUSE_MODE_MAX);
if (p_mode == mouse_mode_base) {
return;
}
@ -67,12 +67,12 @@ void DisplayServerMacOSBase::mouse_set_mode(MouseMode p_mode) {
_mouse_update_mode();
}
DisplayServer::MouseMode DisplayServerMacOSBase::mouse_get_mode() const {
DisplayServerEnums::MouseMode DisplayServerMacOSBase::mouse_get_mode() const {
return mouse_mode;
}
void DisplayServerMacOSBase::mouse_set_mode_override(MouseMode p_mode) {
ERR_FAIL_INDEX(p_mode, MouseMode::MOUSE_MODE_MAX);
void DisplayServerMacOSBase::mouse_set_mode_override(DisplayServerEnums::MouseMode p_mode) {
ERR_FAIL_INDEX(p_mode, DisplayServerEnums::MouseMode::MOUSE_MODE_MAX);
if (p_mode == mouse_mode_override) {
return;
}
@ -80,7 +80,7 @@ void DisplayServerMacOSBase::mouse_set_mode_override(MouseMode p_mode) {
_mouse_update_mode();
}
DisplayServer::MouseMode DisplayServerMacOSBase::mouse_get_mode_override() const {
DisplayServerEnums::MouseMode DisplayServerMacOSBase::mouse_get_mode_override() const {
return mouse_mode_override;
}
@ -500,7 +500,7 @@ String DisplayServerMacOSBase::ime_get_text() const {
return im_text;
}
DisplayServer::CursorShape DisplayServerMacOSBase::cursor_get_shape() const {
DisplayServerEnums::CursorShape DisplayServerMacOSBase::cursor_get_shape() const {
return cursor_shape;
}
@ -543,7 +543,7 @@ void DisplayServerMacOSBase::emit_system_theme_changed() {
// MARK: - HDR / EDR
void DisplayServerMacOSBase::_update_hdr_output(WindowID p_window, const HDROutput &p_hdr) {
void DisplayServerMacOSBase::_update_hdr_output(DisplayServerEnums::WindowID p_window, const HDROutput &p_hdr) {
#ifdef RD_ENABLED
if (!rendering_context) {
return;
@ -565,7 +565,7 @@ void DisplayServerMacOSBase::_update_hdr_output(WindowID p_window, const HDROutp
#endif
}
bool DisplayServerMacOSBase::window_is_hdr_output_supported(WindowID p_window) const {
bool DisplayServerMacOSBase::window_is_hdr_output_supported(DisplayServerEnums::WindowID p_window) const {
_THREAD_SAFE_METHOD_
#if defined(RD_ENABLED)
@ -578,7 +578,7 @@ bool DisplayServerMacOSBase::window_is_hdr_output_supported(WindowID p_window) c
return max_potential_edr > 1.0f;
}
void DisplayServerMacOSBase::window_request_hdr_output(const bool p_enabled, WindowID p_window) {
void DisplayServerMacOSBase::window_request_hdr_output(const bool p_enabled, DisplayServerEnums::WindowID p_window) {
_THREAD_SAFE_METHOD_
#if defined(RD_ENABLED)
@ -590,13 +590,13 @@ void DisplayServerMacOSBase::window_request_hdr_output(const bool p_enabled, Win
_update_hdr_output(p_window, hdr);
}
bool DisplayServerMacOSBase::window_is_hdr_output_requested(WindowID p_window) const {
bool DisplayServerMacOSBase::window_is_hdr_output_requested(DisplayServerEnums::WindowID p_window) const {
_THREAD_SAFE_METHOD_
return _get_hdr_output(p_window).requested;
}
bool DisplayServerMacOSBase::window_is_hdr_output_enabled(WindowID p_window) const {
bool DisplayServerMacOSBase::window_is_hdr_output_enabled(DisplayServerEnums::WindowID p_window) const {
_THREAD_SAFE_METHOD_
#if defined(RD_ENABLED)
@ -608,11 +608,11 @@ bool DisplayServerMacOSBase::window_is_hdr_output_enabled(WindowID p_window) con
return false;
}
void DisplayServerMacOSBase::window_set_hdr_output_reference_luminance(const float p_reference_luminance, WindowID p_window) {
void DisplayServerMacOSBase::window_set_hdr_output_reference_luminance(const float p_reference_luminance, DisplayServerEnums::WindowID p_window) {
ERR_PRINT_ONCE("Manually setting reference white luminance is not supported on Apple devices, as they provide a user-facing brightness setting that directly controls reference white luminance.");
}
float DisplayServerMacOSBase::window_get_hdr_output_reference_luminance(WindowID p_window) const {
float DisplayServerMacOSBase::window_get_hdr_output_reference_luminance(DisplayServerEnums::WindowID p_window) const {
return -1.0f; // Always auto-adjusted by the OS on Apple platforms.
}
@ -620,7 +620,7 @@ constexpr float DisplayServerMacOSBase::_calculate_current_reference_luminance(C
return (p_max_potential_edr_value * HARDWARE_REFERENCE_LUMINANCE_NITS) / p_max_edr_value;
}
float DisplayServerMacOSBase::window_get_hdr_output_current_reference_luminance(WindowID p_window) const {
float DisplayServerMacOSBase::window_get_hdr_output_current_reference_luminance(DisplayServerEnums::WindowID p_window) const {
_THREAD_SAFE_METHOD_
#if defined(RD_ENABLED)
@ -631,7 +631,7 @@ float DisplayServerMacOSBase::window_get_hdr_output_current_reference_luminance(
return 200.0f;
}
void DisplayServerMacOSBase::window_set_hdr_output_max_luminance(const float p_max_luminance, WindowID p_window) {
void DisplayServerMacOSBase::window_set_hdr_output_max_luminance(const float p_max_luminance, DisplayServerEnums::WindowID p_window) {
_THREAD_SAFE_METHOD_
HDROutput &hdr = _get_hdr_output(p_window);
@ -643,13 +643,13 @@ void DisplayServerMacOSBase::window_set_hdr_output_max_luminance(const float p_m
_update_hdr_output(p_window, hdr);
}
float DisplayServerMacOSBase::window_get_hdr_output_max_luminance(WindowID p_window) const {
float DisplayServerMacOSBase::window_get_hdr_output_max_luminance(DisplayServerEnums::WindowID p_window) const {
_THREAD_SAFE_METHOD_
return _get_hdr_output(p_window).max_luminance;
}
float DisplayServerMacOSBase::window_get_hdr_output_current_max_luminance(WindowID p_window) const {
float DisplayServerMacOSBase::window_get_hdr_output_current_max_luminance(DisplayServerEnums::WindowID p_window) const {
_THREAD_SAFE_METHOD_
const HDROutput &hdr = _get_hdr_output(p_window);
@ -661,7 +661,7 @@ float DisplayServerMacOSBase::window_get_hdr_output_current_max_luminance(Window
return hdr.max_luminance;
}
float DisplayServerMacOSBase::window_get_output_max_linear_value(WindowID p_window) const {
float DisplayServerMacOSBase::window_get_output_max_linear_value(DisplayServerEnums::WindowID p_window) const {
_THREAD_SAFE_METHOD_
#if defined(RD_ENABLED)

124
platform/macos/display_server_macos_embedded.h
View file

@ -70,14 +70,14 @@ class DisplayServerMacOSEmbedded : public DisplayServerMacOSBase {
NativeMenu *native_menu = nullptr;
HashMap<WindowID, ObjectID> window_attached_instance_id;
HashMap<DisplayServerEnums::WindowID, ObjectID> window_attached_instance_id;
HashMap<WindowID, Callable> window_event_callbacks;
HashMap<WindowID, Callable> window_resize_callbacks;
HashMap<WindowID, Callable> input_event_callbacks;
HashMap<WindowID, Callable> input_text_callbacks;
HashMap<DisplayServerEnums::WindowID, Callable> window_event_callbacks;
HashMap<DisplayServerEnums::WindowID, Callable> window_resize_callbacks;
HashMap<DisplayServerEnums::WindowID, Callable> input_event_callbacks;
HashMap<DisplayServerEnums::WindowID, Callable> input_text_callbacks;
WindowID window_id_counter = MAIN_WINDOW_ID;
DisplayServerEnums::WindowID window_id_counter = DisplayServerEnums::MAIN_WINDOW_ID;
bool transparent = false;
@ -92,12 +92,12 @@ class DisplayServerMacOSEmbedded : public DisplayServerMacOSBase {
HDROutput hdr_output;
HDROutput &_get_hdr_output(WindowID p_window) override;
const HDROutput &_get_hdr_output(WindowID p_window) const override;
HDROutput &_get_hdr_output(DisplayServerEnums::WindowID p_window) override;
const HDROutput &_get_hdr_output(DisplayServerEnums::WindowID p_window) const override;
Point2i ime_last_position;
void _mouse_apply_mode(MouseMode p_prev_mode, MouseMode p_new_mode) override;
void _mouse_apply_mode(DisplayServerEnums::MouseMode p_prev_mode, DisplayServerEnums::MouseMode p_new_mode) override;
struct Joy {
String name;
@ -111,25 +111,25 @@ class DisplayServerMacOSEmbedded : public DisplayServerMacOSBase {
public:
static void register_embedded_driver();
static DisplayServer *create_func(const String &p_rendering_driver, WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error);
static DisplayServer *create_func(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
static Vector<String> get_rendering_drivers_func();
void _window_set_size(const Size2i p_size, WindowID p_window = MAIN_WINDOW_ID);
void _window_set_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID);
// MARK: - Events
virtual void process_events() override;
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;
virtual void window_set_rect_changed_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_window_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_input_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_input_text_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_drop_files_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
static void _dispatch_input_events(const Ref<InputEvent> &p_event);
void send_input_event(const Ref<InputEvent> &p_event, DisplayServer::WindowID p_id = MAIN_WINDOW_ID) const;
void send_input_text(const String &p_text, DisplayServer::WindowID p_id = MAIN_WINDOW_ID) const;
void send_window_event(DisplayServer::WindowEvent p_event, DisplayServer::WindowID p_id = MAIN_WINDOW_ID) const;
void send_input_event(const Ref<InputEvent> &p_event, DisplayServerEnums::WindowID p_id = DisplayServerEnums::MAIN_WINDOW_ID) const;
void send_input_text(const String &p_text, DisplayServerEnums::WindowID p_id = DisplayServerEnums::MAIN_WINDOW_ID) const;
void send_window_event(DisplayServerEnums::WindowEvent p_event, DisplayServerEnums::WindowID p_id = DisplayServerEnums::MAIN_WINDOW_ID) const;
void _window_callback(const Callable &p_callable, const Variant &p_arg) const;
// MARK: - Mouse
@ -139,78 +139,78 @@ public:
// MARK: - Window
virtual bool has_feature(Feature p_feature) const override;
virtual bool has_feature(DisplayServerEnums::Feature p_feature) const override;
virtual String get_name() const override;
virtual int get_screen_count() const override;
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;
virtual float screen_get_scale(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual Vector<DisplayServer::WindowID> get_window_list() const override;
virtual Point2i screen_get_position(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Size2i screen_get_size(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Rect2i screen_get_usable_rect(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual int screen_get_dpi(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_scale(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Vector<DisplayServerEnums::WindowID> get_window_list() const override;
virtual WindowID get_window_at_screen_position(const Point2i &p_position) const override;
virtual DisplayServerEnums::WindowID get_window_at_screen_position(const Point2i &p_position) const override;
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;
virtual void window_attach_instance_id(ObjectID p_instance, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual ObjectID window_get_attached_instance_id(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_title(const String &p_title, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_title(const String &p_title, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
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;
virtual int window_get_current_screen(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_current_screen(int p_screen, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Point2i window_get_position(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual Point2i window_get_position_with_decorations(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_position(const Point2i &p_position, WindowID p_window = MAIN_WINDOW_ID) override;
virtual Point2i window_get_position(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual Point2i window_get_position_with_decorations(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_position(const Point2i &p_position, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_transient(WindowID p_window, WindowID p_parent) override;
virtual void window_set_transient(DisplayServerEnums::WindowID p_window, DisplayServerEnums::WindowID p_parent) override;
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;
virtual void window_set_max_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_max_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_min_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_min_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual Size2i window_get_size_with_decorations(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual Size2i window_get_size_with_decorations(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_mode(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual DisplayServerEnums::WindowMode window_get_mode(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool window_is_maximize_allowed(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual bool window_is_maximize_allowed(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_flag(DisplayServerEnums::WindowFlags p_flag, bool p_enabled, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_get_flag(DisplayServerEnums::WindowFlags p_flag, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_request_attention(WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_taskbar_progress_value(float p_value, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_taskbar_progress_state(ProgressState p_state, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_move_to_foreground(WindowID p_window = MAIN_WINDOW_ID) override;
virtual bool window_is_focused(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_request_attention(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_taskbar_progress_value(float p_value, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_taskbar_progress_state(DisplayServerEnums::ProgressState p_state, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_move_to_foreground(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_is_focused(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual float screen_get_max_scale() const override;
virtual bool window_can_draw(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual bool window_can_draw(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool can_any_window_draw() const override;
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;
virtual void window_set_ime_active(const bool p_active, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_ime_position(const Point2i &p_pos, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
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;
virtual void window_set_vsync_mode(DisplayServerEnums::VSyncMode p_vsync_mode, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual DisplayServerEnums::VSyncMode window_get_vsync_mode(DisplayServerEnums::WindowID p_vsync_mode) const override;
virtual void cursor_set_shape(CursorShape p_shape) override;
virtual void cursor_set_custom_image(const Ref<Resource> &p_cursor, CursorShape p_shape = CURSOR_ARROW, const Vector2 &p_hotspot = Vector2()) override;
virtual void cursor_set_shape(DisplayServerEnums::CursorShape p_shape) override;
virtual void cursor_set_custom_image(const Ref<Resource> &p_cursor, DisplayServerEnums::CursorShape p_shape = DisplayServerEnums::CURSOR_ARROW, const Vector2 &p_hotspot = Vector2()) override;
void window_get_edr_values(WindowID p_window, CGFloat *r_max_potential_edr_value, CGFloat *r_max_edr_value) const override;
void window_get_edr_values(DisplayServerEnums::WindowID p_window, CGFloat *r_max_potential_edr_value, CGFloat *r_max_edr_value) const override;
void update_screen_parameters();
void set_state(const DisplayServerMacOSEmbeddedState &p_state);
virtual void swap_buffers() override;
DisplayServerMacOSEmbedded(const String &p_rendering_driver, DisplayServer::WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, Error &r_error);
DisplayServerMacOSEmbedded(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, Error &r_error);
~DisplayServerMacOSEmbedded();
};

186
platform/macos/display_server_macos_embedded.mm
View file

@ -60,7 +60,7 @@
#import "core/os/main_loop.h"
#import "servers/display/native_menu.h"
DisplayServerMacOSEmbedded::DisplayServerMacOSEmbedded(const String &p_rendering_driver, WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, Error &r_error) {
DisplayServerMacOSEmbedded::DisplayServerMacOSEmbedded(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, Error &r_error) {
EmbeddedDebugger::initialize(this);
r_error = OK; // default to OK
@ -139,7 +139,7 @@ DisplayServerMacOSEmbedded::DisplayServerMacOSEmbedded(const String &p_rendering
if (err != OK) {
ERR_FAIL_MSG("Could not create OpenGL context.");
}
gl_manager->set_vsync_enabled(p_vsync_mode != DisplayServer::VSYNC_DISABLED);
gl_manager->set_vsync_enabled(p_vsync_mode != DisplayServerEnums::VSYNC_DISABLED);
}
#endif
@ -186,8 +186,8 @@ DisplayServerMacOSEmbedded::DisplayServerMacOSEmbedded(const String &p_rendering
#if defined(RD_ENABLED)
if (rendering_context) {
rendering_device = memnew(RenderingDevice);
rendering_device->initialize(rendering_context, MAIN_WINDOW_ID);
rendering_device->screen_create(MAIN_WINDOW_ID);
rendering_device->initialize(rendering_context, DisplayServerEnums::MAIN_WINDOW_ID);
rendering_device->screen_create(DisplayServerEnums::MAIN_WINDOW_ID);
RendererCompositorRD::make_current();
}
@ -197,7 +197,7 @@ DisplayServerMacOSEmbedded::DisplayServerMacOSEmbedded(const String &p_rendering
layer.contentsScale = scale;
layer.magnificationFilter = kCAFilterNearest;
layer.minificationFilter = kCAFilterNearest;
transparent = ((p_flags & WINDOW_FLAG_TRANSPARENT_BIT) == WINDOW_FLAG_TRANSPARENT_BIT);
transparent = ((p_flags & DisplayServerEnums::WINDOW_FLAG_TRANSPARENT_BIT) == DisplayServerEnums::WINDOW_FLAG_TRANSPARENT_BIT);
layer.opaque = !(OS::get_singleton()->is_layered_allowed() && transparent);
layer.actions = @{ @"contents" : [NSNull null] }; // Disable implicit animations for contents.
// AppKit frames, bounds and positions are always in points.
@ -243,7 +243,7 @@ DisplayServerMacOSEmbedded::~DisplayServerMacOSEmbedded() {
#endif
}
DisplayServer *DisplayServerMacOSEmbedded::create_func(const String &p_rendering_driver, WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t /* p_parent_window */, Error &r_error) {
DisplayServer *DisplayServerMacOSEmbedded::create_func(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t /* p_parent_window */, Error &r_error) {
return memnew(DisplayServerMacOSEmbedded(p_rendering_driver, p_mode, p_vsync_mode, p_flags, p_position, p_resolution, p_screen, p_context, r_error));
}
@ -269,7 +269,7 @@ void DisplayServerMacOSEmbedded::register_embedded_driver() {
// MARK: - Mouse
void DisplayServerMacOSEmbedded::_mouse_apply_mode(MouseMode p_prev_mode, MouseMode p_new_mode) {
void DisplayServerMacOSEmbedded::_mouse_apply_mode(DisplayServerEnums::MouseMode p_prev_mode, DisplayServerEnums::MouseMode p_new_mode) {
EngineDebugger::get_singleton()->send_message("game_view:mouse_set_mode", { p_new_mode });
}
@ -323,22 +323,22 @@ BitField<MouseButtonMask> DisplayServerMacOSEmbedded::mouse_get_button_state() c
// MARK: Events
void DisplayServerMacOSEmbedded::window_set_rect_changed_callback(const Callable &p_callable, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_rect_changed_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
window_resize_callbacks[p_window] = p_callable;
}
void DisplayServerMacOSEmbedded::window_set_window_event_callback(const Callable &p_callable, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_window_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
window_event_callbacks[p_window] = p_callable;
}
void DisplayServerMacOSEmbedded::window_set_input_event_callback(const Callable &p_callable, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_input_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
input_event_callbacks[p_window] = p_callable;
}
void DisplayServerMacOSEmbedded::window_set_input_text_callback(const Callable &p_callable, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_input_text_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
input_text_callbacks[p_window] = p_callable;
}
void DisplayServerMacOSEmbedded::window_set_drop_files_callback(const Callable &p_callable, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_drop_files_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
// Not supported
}
@ -349,7 +349,7 @@ void DisplayServerMacOSEmbedded::process_events() {
void DisplayServerMacOSEmbedded::_dispatch_input_events(const Ref<InputEvent> &p_event) {
Ref<InputEventFromWindow> event_from_window = p_event;
WindowID window_id = INVALID_WINDOW_ID;
DisplayServerEnums::WindowID window_id = DisplayServerEnums::INVALID_WINDOW_ID;
if (event_from_window.is_valid()) {
window_id = event_from_window->get_window_id();
}
@ -357,27 +357,27 @@ void DisplayServerMacOSEmbedded::_dispatch_input_events(const Ref<InputEvent> &p
ds->send_input_event(p_event, window_id);
}
void DisplayServerMacOSEmbedded::send_input_event(const Ref<InputEvent> &p_event, WindowID p_id) const {
if (p_id != INVALID_WINDOW_ID) {
void DisplayServerMacOSEmbedded::send_input_event(const Ref<InputEvent> &p_event, DisplayServerEnums::WindowID p_id) const {
if (p_id != DisplayServerEnums::INVALID_WINDOW_ID) {
const Callable *cb = input_event_callbacks.getptr(p_id);
if (cb) {
_window_callback(*cb, p_event);
}
} else {
for (const KeyValue<WindowID, Callable> &E : input_event_callbacks) {
for (const KeyValue<DisplayServerEnums::WindowID, Callable> &E : input_event_callbacks) {
_window_callback(E.value, p_event);
}
}
}
void DisplayServerMacOSEmbedded::send_input_text(const String &p_text, WindowID p_id) const {
void DisplayServerMacOSEmbedded::send_input_text(const String &p_text, DisplayServerEnums::WindowID p_id) const {
const Callable *cb = input_text_callbacks.getptr(p_id);
if (cb) {
_window_callback(*cb, p_text);
}
}
void DisplayServerMacOSEmbedded::send_window_event(DisplayServer::WindowEvent p_event, WindowID p_id) const {
void DisplayServerMacOSEmbedded::send_window_event(DisplayServerEnums::WindowEvent p_event, DisplayServerEnums::WindowID p_id) const {
const Callable *cb = window_event_callbacks.getptr(p_id);
if (cb) {
_window_callback(*cb, int(p_event));
@ -392,30 +392,30 @@ void DisplayServerMacOSEmbedded::_window_callback(const Callable &p_callable, co
// MARK: -
bool DisplayServerMacOSEmbedded::has_feature(Feature p_feature) const {
bool DisplayServerMacOSEmbedded::has_feature(DisplayServerEnums::Feature p_feature) const {
switch (p_feature) {
#ifndef DISABLE_DEPRECATED
case FEATURE_GLOBAL_MENU: {
case DisplayServerEnums::FEATURE_GLOBAL_MENU: {
return (native_menu && native_menu->has_feature(NativeMenu::FEATURE_GLOBAL_MENU));
} break;
#endif
case FEATURE_CURSOR_SHAPE:
case FEATURE_IME:
case FEATURE_CUSTOM_CURSOR_SHAPE:
// case FEATURE_HIDPI:
// case FEATURE_ICON:
// case FEATURE_MOUSE:
case FEATURE_HDR_OUTPUT:
case FEATURE_MOUSE_WARP:
// case FEATURE_NATIVE_DIALOG:
// case FEATURE_NATIVE_ICON:
// case FEATURE_WINDOW_TRANSPARENCY:
case FEATURE_CLIPBOARD:
// case FEATURE_KEEP_SCREEN_ON:
// case FEATURE_ORIENTATION:
// case FEATURE_VIRTUAL_KEYBOARD:
case FEATURE_TEXT_TO_SPEECH:
// case FEATURE_TOUCHSCREEN:
case DisplayServerEnums::FEATURE_CURSOR_SHAPE:
case DisplayServerEnums::FEATURE_IME:
case DisplayServerEnums::FEATURE_CUSTOM_CURSOR_SHAPE:
// case DisplayServerEnums::FEATURE_HIDPI:
// case DisplayServerEnums::FEATURE_ICON:
// case DisplayServerEnums::FEATURE_MOUSE:
case DisplayServerEnums::FEATURE_HDR_OUTPUT:
case DisplayServerEnums::FEATURE_MOUSE_WARP:
// case DisplayServerEnums::FEATURE_NATIVE_DIALOG:
// case DisplayServerEnums::FEATURE_NATIVE_ICON:
// case DisplayServerEnums::FEATURE_WINDOW_TRANSPARENCY:
case DisplayServerEnums::FEATURE_CLIPBOARD:
// case DisplayServerEnums::FEATURE_KEEP_SCREEN_ON:
// case DisplayServerEnums::FEATURE_ORIENTATION:
// case DisplayServerEnums::FEATURE_VIRTUAL_KEYBOARD:
case DisplayServerEnums::FEATURE_TEXT_TO_SPEECH:
// case DisplayServerEnums::FEATURE_TOUCHSCREEN:
return true;
default:
return false;
@ -447,7 +447,7 @@ Size2i DisplayServerMacOSEmbedded::screen_get_size(int p_screen) const {
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Size2i());
return window_get_size(MAIN_WINDOW_ID);
return window_get_size(DisplayServerEnums::MAIN_WINDOW_ID);
}
Rect2i DisplayServerMacOSEmbedded::screen_get_usable_rect(int p_screen) const {
@ -474,10 +474,10 @@ float DisplayServerMacOSEmbedded::screen_get_scale(int p_screen) const {
_THREAD_SAFE_METHOD_
switch (p_screen) {
case SCREEN_WITH_MOUSE_FOCUS:
case SCREEN_WITH_KEYBOARD_FOCUS:
case SCREEN_PRIMARY:
case SCREEN_OF_MAIN_WINDOW:
case DisplayServerEnums::SCREEN_WITH_MOUSE_FOCUS:
case DisplayServerEnums::SCREEN_WITH_KEYBOARD_FOCUS:
case DisplayServerEnums::SCREEN_PRIMARY:
case DisplayServerEnums::SCREEN_OF_MAIN_WINDOW:
case 0:
return state.screen_window_scale;
default:
@ -485,76 +485,76 @@ float DisplayServerMacOSEmbedded::screen_get_scale(int p_screen) const {
}
}
Vector<DisplayServer::WindowID> DisplayServerMacOSEmbedded::get_window_list() const {
Vector<DisplayServer::WindowID> list;
list.push_back(MAIN_WINDOW_ID);
Vector<DisplayServerEnums::WindowID> DisplayServerMacOSEmbedded::get_window_list() const {
Vector<DisplayServerEnums::WindowID> list;
list.push_back(DisplayServerEnums::MAIN_WINDOW_ID);
return list;
}
DisplayServer::WindowID DisplayServerMacOSEmbedded::get_window_at_screen_position(const Point2i &p_position) const {
return MAIN_WINDOW_ID;
DisplayServerEnums::WindowID DisplayServerMacOSEmbedded::get_window_at_screen_position(const Point2i &p_position) const {
return DisplayServerEnums::MAIN_WINDOW_ID;
}
void DisplayServerMacOSEmbedded::window_attach_instance_id(ObjectID p_instance, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_attach_instance_id(ObjectID p_instance, DisplayServerEnums::WindowID p_window) {
window_attached_instance_id[p_window] = p_instance;
}
ObjectID DisplayServerMacOSEmbedded::window_get_attached_instance_id(WindowID p_window) const {
ObjectID DisplayServerMacOSEmbedded::window_get_attached_instance_id(DisplayServerEnums::WindowID p_window) const {
return window_attached_instance_id[p_window];
}
void DisplayServerMacOSEmbedded::window_set_title(const String &p_title, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_title(const String &p_title, DisplayServerEnums::WindowID p_window) {
// Not supported
}
int DisplayServerMacOSEmbedded::window_get_current_screen(WindowID p_window) const {
int DisplayServerMacOSEmbedded::window_get_current_screen(DisplayServerEnums::WindowID p_window) const {
_THREAD_SAFE_METHOD_
ERR_FAIL_COND_V(p_window != MAIN_WINDOW_ID, INVALID_SCREEN);
ERR_FAIL_COND_V(p_window != DisplayServerEnums::MAIN_WINDOW_ID, DisplayServerEnums::INVALID_SCREEN);
return 0;
}
void DisplayServerMacOSEmbedded::window_set_current_screen(int p_screen, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_current_screen(int p_screen, DisplayServerEnums::WindowID p_window) {
// Not supported
}
Point2i DisplayServerMacOSEmbedded::window_get_position(WindowID p_window) const {
Point2i DisplayServerMacOSEmbedded::window_get_position(DisplayServerEnums::WindowID p_window) const {
return Point2i();
}
Point2i DisplayServerMacOSEmbedded::window_get_position_with_decorations(WindowID p_window) const {
Point2i DisplayServerMacOSEmbedded::window_get_position_with_decorations(DisplayServerEnums::WindowID p_window) const {
return Point2i();
}
void DisplayServerMacOSEmbedded::window_set_position(const Point2i &p_position, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_position(const Point2i &p_position, DisplayServerEnums::WindowID p_window) {
// Probably not supported for single window iOS app
}
void DisplayServerMacOSEmbedded::window_set_transient(WindowID p_window, WindowID p_parent) {
void DisplayServerMacOSEmbedded::window_set_transient(DisplayServerEnums::WindowID p_window, DisplayServerEnums::WindowID p_parent) {
// Not supported
}
void DisplayServerMacOSEmbedded::window_set_max_size(const Size2i p_size, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_max_size(const Size2i p_size, DisplayServerEnums::WindowID p_window) {
// Not supported
}
Size2i DisplayServerMacOSEmbedded::window_get_max_size(WindowID p_window) const {
Size2i DisplayServerMacOSEmbedded::window_get_max_size(DisplayServerEnums::WindowID p_window) const {
return Size2i();
}
void DisplayServerMacOSEmbedded::window_set_min_size(const Size2i p_size, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_min_size(const Size2i p_size, DisplayServerEnums::WindowID p_window) {
// Not supported
}
Size2i DisplayServerMacOSEmbedded::window_get_min_size(WindowID p_window) const {
Size2i DisplayServerMacOSEmbedded::window_get_min_size(DisplayServerEnums::WindowID p_window) const {
return Size2i();
}
void DisplayServerMacOSEmbedded::window_set_size(const Size2i p_size, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_size(const Size2i p_size, DisplayServerEnums::WindowID p_window) {
print_line("Embedded window can't be resized.");
}
void DisplayServerMacOSEmbedded::_window_set_size(const Size2i p_size, WindowID p_window) {
void DisplayServerMacOSEmbedded::_window_set_size(const Size2i p_size, DisplayServerEnums::WindowID p_window) {
[CATransaction begin];
[CATransaction setDisableActions:YES];
@ -583,7 +583,7 @@ void DisplayServerMacOSEmbedded::_window_set_size(const Size2i p_size, WindowID
}
}
Size2i DisplayServerMacOSEmbedded::window_get_size(WindowID p_window) const {
Size2i DisplayServerMacOSEmbedded::window_get_size(DisplayServerEnums::WindowID p_window) const {
#if defined(RD_ENABLED)
if (rendering_context) {
RenderingContextDriver::SurfaceID surface = rendering_context->surface_get_from_window(p_window);
@ -601,53 +601,53 @@ Size2i DisplayServerMacOSEmbedded::window_get_size(WindowID p_window) const {
return Size2i();
}
Size2i DisplayServerMacOSEmbedded::window_get_size_with_decorations(WindowID p_window) const {
Size2i DisplayServerMacOSEmbedded::window_get_size_with_decorations(DisplayServerEnums::WindowID p_window) const {
return window_get_size(p_window);
}
void DisplayServerMacOSEmbedded::window_set_mode(WindowMode p_mode, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_mode(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::WindowID p_window) {
// Not supported
}
DisplayServer::WindowMode DisplayServerMacOSEmbedded::window_get_mode(WindowID p_window) const {
return WindowMode::WINDOW_MODE_WINDOWED;
DisplayServerEnums::WindowMode DisplayServerMacOSEmbedded::window_get_mode(DisplayServerEnums::WindowID p_window) const {
return DisplayServerEnums::WindowMode::WINDOW_MODE_WINDOWED;
}
bool DisplayServerMacOSEmbedded::window_is_maximize_allowed(WindowID p_window) const {
bool DisplayServerMacOSEmbedded::window_is_maximize_allowed(DisplayServerEnums::WindowID p_window) const {
return false;
}
void DisplayServerMacOSEmbedded::window_set_flag(WindowFlags p_flag, bool p_enabled, WindowID p_window) {
if (p_flag == WINDOW_FLAG_TRANSPARENT && p_window == MAIN_WINDOW_ID) {
void DisplayServerMacOSEmbedded::window_set_flag(DisplayServerEnums::WindowFlags p_flag, bool p_enabled, DisplayServerEnums::WindowID p_window) {
if (p_flag == DisplayServerEnums::WINDOW_FLAG_TRANSPARENT && p_window == DisplayServerEnums::MAIN_WINDOW_ID) {
transparent = p_enabled;
layer.opaque = !(OS::get_singleton()->is_layered_allowed() && transparent);
}
}
bool DisplayServerMacOSEmbedded::window_get_flag(WindowFlags p_flag, WindowID p_window) const {
if (p_flag == WINDOW_FLAG_TRANSPARENT && p_window == MAIN_WINDOW_ID) {
bool DisplayServerMacOSEmbedded::window_get_flag(DisplayServerEnums::WindowFlags p_flag, DisplayServerEnums::WindowID p_window) const {
if (p_flag == DisplayServerEnums::WINDOW_FLAG_TRANSPARENT && p_window == DisplayServerEnums::MAIN_WINDOW_ID) {
return transparent;
}
return false;
}
void DisplayServerMacOSEmbedded::window_request_attention(WindowID p_window) {
void DisplayServerMacOSEmbedded::window_request_attention(DisplayServerEnums::WindowID p_window) {
// Not supported
}
void DisplayServerMacOSEmbedded::window_set_taskbar_progress_value(float p_value, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_taskbar_progress_value(float p_value, DisplayServerEnums::WindowID p_window) {
// Not supported.
}
void DisplayServerMacOSEmbedded::window_set_taskbar_progress_state(ProgressState p_state, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_taskbar_progress_state(DisplayServerEnums::ProgressState p_state, DisplayServerEnums::WindowID p_window) {
// Not supported.
}
void DisplayServerMacOSEmbedded::window_move_to_foreground(WindowID p_window) {
void DisplayServerMacOSEmbedded::window_move_to_foreground(DisplayServerEnums::WindowID p_window) {
// Not supported
}
bool DisplayServerMacOSEmbedded::window_is_focused(WindowID p_window) const {
bool DisplayServerMacOSEmbedded::window_is_focused(DisplayServerEnums::WindowID p_window) const {
return true;
}
@ -655,7 +655,7 @@ float DisplayServerMacOSEmbedded::screen_get_max_scale() const {
return state.screen_max_scale;
}
bool DisplayServerMacOSEmbedded::window_can_draw(WindowID p_window) const {
bool DisplayServerMacOSEmbedded::window_can_draw(DisplayServerEnums::WindowID p_window) const {
return true;
}
@ -663,11 +663,11 @@ bool DisplayServerMacOSEmbedded::can_any_window_draw() const {
return true;
}
void DisplayServerMacOSEmbedded::window_set_ime_active(const bool p_active, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_ime_active(const bool p_active, DisplayServerEnums::WindowID p_window) {
EngineDebugger::get_singleton()->send_message("game_view:window_set_ime_active", { p_active });
}
void DisplayServerMacOSEmbedded::window_set_ime_position(const Point2i &p_pos, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_ime_position(const Point2i &p_pos, DisplayServerEnums::WindowID p_window) {
if (p_pos == ime_last_position) {
return;
}
@ -675,15 +675,15 @@ void DisplayServerMacOSEmbedded::window_set_ime_position(const Point2i &p_pos, W
ime_last_position = p_pos;
}
DisplayServerMacOSBase::HDROutput &DisplayServerMacOSEmbedded::_get_hdr_output(WindowID p_window) {
DisplayServerMacOSBase::HDROutput &DisplayServerMacOSEmbedded::_get_hdr_output(DisplayServerEnums::WindowID p_window) {
return hdr_output;
}
const DisplayServerMacOSBase::HDROutput &DisplayServerMacOSEmbedded::_get_hdr_output(WindowID p_window) const {
const DisplayServerMacOSBase::HDROutput &DisplayServerMacOSEmbedded::_get_hdr_output(DisplayServerEnums::WindowID p_window) const {
return hdr_output;
}
void DisplayServerMacOSEmbedded::window_get_edr_values(WindowID p_window, CGFloat *r_max_potential_edr_value, CGFloat *r_max_edr_value) const {
void DisplayServerMacOSEmbedded::window_get_edr_values(DisplayServerEnums::WindowID p_window, CGFloat *r_max_potential_edr_value, CGFloat *r_max_edr_value) const {
_THREAD_SAFE_METHOD_
#define SET_VAL(v, val) \
@ -704,7 +704,7 @@ void DisplayServerMacOSEmbedded::window_get_edr_values(WindowID p_window, CGFloa
void DisplayServerMacOSEmbedded::update_screen_parameters() {
if (hdr_output.requested) {
_update_hdr_output(MAIN_WINDOW_ID, hdr_output);
_update_hdr_output(DisplayServerEnums::MAIN_WINDOW_ID, hdr_output);
}
}
@ -725,14 +725,14 @@ void DisplayServerMacOSEmbedded::set_state(const DisplayServerMacOSEmbeddedState
#endif
}
if (hdr_output.requested) {
_update_hdr_output(MAIN_WINDOW_ID, hdr_output);
_update_hdr_output(DisplayServerEnums::MAIN_WINDOW_ID, hdr_output);
}
}
void DisplayServerMacOSEmbedded::window_set_vsync_mode(DisplayServer::VSyncMode p_vsync_mode, WindowID p_window) {
void DisplayServerMacOSEmbedded::window_set_vsync_mode(DisplayServerEnums::VSyncMode p_vsync_mode, DisplayServerEnums::WindowID p_window) {
#if defined(GLES3_ENABLED)
if (gl_manager) {
gl_manager->set_vsync_enabled(p_vsync_mode != DisplayServer::VSYNC_DISABLED);
gl_manager->set_vsync_enabled(p_vsync_mode != DisplayServerEnums::VSYNC_DISABLED);
}
#endif
@ -743,11 +743,11 @@ void DisplayServerMacOSEmbedded::window_set_vsync_mode(DisplayServer::VSyncMode
#endif
}
DisplayServer::VSyncMode DisplayServerMacOSEmbedded::window_get_vsync_mode(WindowID p_window) const {
DisplayServerEnums::VSyncMode DisplayServerMacOSEmbedded::window_get_vsync_mode(DisplayServerEnums::WindowID p_window) const {
_THREAD_SAFE_METHOD_
#if defined(GLES3_ENABLED)
if (gl_manager) {
return (gl_manager->is_vsync_enabled() ? DisplayServer::VSyncMode::VSYNC_ENABLED : DisplayServer::VSyncMode::VSYNC_DISABLED);
return (gl_manager->is_vsync_enabled() ? DisplayServerEnums::VSyncMode::VSYNC_ENABLED : DisplayServerEnums::VSyncMode::VSYNC_DISABLED);
}
#endif
#if defined(RD_ENABLED)
@ -755,15 +755,15 @@ DisplayServer::VSyncMode DisplayServerMacOSEmbedded::window_get_vsync_mode(Windo
return rendering_context->window_get_vsync_mode(p_window);
}
#endif
return DisplayServer::VSYNC_ENABLED;
return DisplayServerEnums::VSYNC_ENABLED;
}
void DisplayServerMacOSEmbedded::cursor_set_shape(CursorShape p_shape) {
void DisplayServerMacOSEmbedded::cursor_set_shape(DisplayServerEnums::CursorShape p_shape) {
cursor_shape = p_shape;
EngineDebugger::get_singleton()->send_message("game_view:cursor_set_shape", { p_shape });
}
void DisplayServerMacOSEmbedded::cursor_set_custom_image(const Ref<Resource> &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
void DisplayServerMacOSEmbedded::cursor_set_custom_image(const Ref<Resource> &p_cursor, DisplayServerEnums::CursorShape p_shape, const Vector2 &p_hotspot) {
PackedByteArray data;
if (p_cursor.is_valid()) {
Ref<Image> image = _get_cursor_image_from_resource(p_cursor, p_hotspot);

8
platform/macos/editor/embedded_game_view_plugin.mm
View file

@ -63,7 +63,7 @@ bool GameViewDebuggerMacOS::_msg_cursor_set_custom_image(const Array &p_args) {
if (!cursor_data.is_empty()) {
image->load_png_from_buffer(cursor_data);
}
DisplayServer::CursorShape shape = DisplayServer::CursorShape(p_args[1]);
DisplayServerEnums::CursorShape shape = DisplayServerEnums::CursorShape(p_args[1]);
Vector2 hotspot = p_args[2];
embedded_process->get_layer_host()->cursor_set_custom_image(image, shape, hotspot);
@ -74,7 +74,7 @@ bool GameViewDebuggerMacOS::_msg_cursor_set_custom_image(const Array &p_args) {
bool GameViewDebuggerMacOS::_msg_mouse_set_mode(const Array &p_args) {
ERR_FAIL_COND_V_MSG(p_args.size() != 1, false, "mouse_set_mode: invalid number of arguments.");
DisplayServer::MouseMode mode = DisplayServer::MouseMode(p_args[0]);
DisplayServerEnums::MouseMode mode = DisplayServerEnums::MouseMode(p_args[0]);
embedded_process->mouse_set_mode(mode);
return true;
@ -84,7 +84,7 @@ bool GameViewDebuggerMacOS::_msg_window_set_ime_active(const Array &p_args) {
ERR_FAIL_COND_V_MSG(p_args.size() != 1, false, "window_set_ime_active: invalid number of arguments.");
bool active = p_args[0];
DisplayServer::WindowID wid = embedded_process->get_window()->get_window_id();
DisplayServerEnums::WindowID wid = embedded_process->get_window()->get_window_id();
DisplayServer::get_singleton()->window_set_ime_active(active, wid);
return true;
}
@ -94,7 +94,7 @@ bool GameViewDebuggerMacOS::_msg_window_set_ime_position(const Array &p_args) {
Point2i pos = p_args[0];
Point2i xpos = embedded_process->get_layer_host()->get_global_transform_with_canvas().xform(pos);
DisplayServer::WindowID wid = embedded_process->get_window()->get_window_id();
DisplayServerEnums::WindowID wid = embedded_process->get_window()->get_window_id();
DisplayServer::get_singleton()->window_set_ime_position(xpos, wid);
return true;
}

10
platform/macos/editor/embedded_process_macos.h
View file

@ -52,7 +52,7 @@ class LayerHost final : public Control {
hotspot = p_hotspot;
}
};
HashMap<DisplayServer::CursorShape, CustomCursor> custom_cursors;
HashMap<DisplayServerEnums::CursorShape, CustomCursor> custom_cursors;
virtual void gui_input(const Ref<InputEvent> &p_event) override;
@ -60,7 +60,7 @@ protected:
void _notification(int p_what);
public:
void cursor_set_custom_image(const Ref<Image> &p_image, DisplayServer::CursorShape p_shape, const Vector2 &p_hotspot);
void cursor_set_custom_image(const Ref<Image> &p_image, DisplayServerEnums::CursorShape p_shape, const Vector2 &p_hotspot);
void set_script_debugger(ScriptEditorDebugger *p_debugger) {
script_debugger = p_debugger;
}
@ -88,7 +88,7 @@ class EmbeddedProcessMacOS final : public EmbeddedProcessBase {
// Embedded process state.
// The last mouse mode sent by the embedded process.
DisplayServer::MouseMode mouse_mode = DisplayServer::MOUSE_MODE_VISIBLE;
DisplayServerEnums::MouseMode mouse_mode = DisplayServerEnums::MOUSE_MODE_VISIBLE;
// Helper functions.
@ -102,7 +102,7 @@ public:
// MARK: - Message Handlers
void set_context_id(uint32_t p_context_id);
void mouse_set_mode(DisplayServer::MouseMode p_mode);
void mouse_set_mode(DisplayServerEnums::MouseMode p_mode);
uint32_t get_context_id() const { return context_id; }
void set_script_debugger(ScriptEditorDebugger *p_debugger) override;
@ -130,7 +130,7 @@ public:
void display_state_changed();
// MARK: - Embedded process state
_FORCE_INLINE_ DisplayServer::MouseMode get_mouse_mode() const { return mouse_mode; }
_FORCE_INLINE_ DisplayServerEnums::MouseMode get_mouse_mode() const { return mouse_mode; }
EmbeddedProcessMacOS();
~EmbeddedProcessMacOS() override;

62
platform/macos/editor/embedded_process_macos.mm
View file

@ -106,11 +106,11 @@ void EmbeddedProcessMacOS::reset() {
ds->remove_embedded_process(current_process_id);
}
DisplayServer *ds = DisplayServer::get_singleton();
for (int i = 0; i < DisplayServer::CURSOR_MAX; i++) {
ds->cursor_set_custom_image(Ref<Resource>(), (DisplayServer::CursorShape)i, Vector2());
for (int i = 0; i < DisplayServerEnums::CURSOR_MAX; i++) {
ds->cursor_set_custom_image(Ref<Resource>(), (DisplayServerEnums::CursorShape)i, Vector2());
}
if (ds->mouse_get_mode() != DisplayServer::MOUSE_MODE_VISIBLE) {
ds->mouse_set_mode(DisplayServer::MOUSE_MODE_VISIBLE);
if (ds->mouse_get_mode() != DisplayServerEnums::MOUSE_MODE_VISIBLE) {
ds->mouse_set_mode(DisplayServerEnums::MOUSE_MODE_VISIBLE);
}
current_process_id = 0;
embedding_state = EmbeddingState::IDLE;
@ -121,7 +121,7 @@ void EmbeddedProcessMacOS::reset() {
void EmbeddedProcessMacOS::request_close() {
if (current_process_id != 0 && is_embedding_completed()) {
script_debugger->send_message("embed:win_event", { DisplayServer::WINDOW_EVENT_CLOSE_REQUEST });
script_debugger->send_message("embed:win_event", { DisplayServerEnums::WINDOW_EVENT_CLOSE_REQUEST });
}
reset();
}
@ -130,7 +130,7 @@ void EmbeddedProcessMacOS::display_state_changed() {
DisplayServerMacOSEmbeddedState state;
state.screen_max_scale = ds->screen_get_max_scale();
state.screen_dpi = ds->screen_get_dpi();
DisplayServer::WindowID wid = window->get_window_id();
DisplayServerEnums::WindowID wid = window->get_window_id();
state.screen_window_scale = ds->screen_get_scale(ds->window_get_current_screen(wid));
state.display_id = ds->window_get_display_id(wid);
@ -149,7 +149,7 @@ void EmbeddedProcessMacOS::_try_embed_process() {
return;
}
DisplayServer::WindowID wid = window->get_window_id();
DisplayServerEnums::WindowID wid = window->get_window_id();
Error err = ds->embed_process_update(wid, this);
if (err == OK) {
layer_host->set_rect(get_adjusted_embedded_window_rect(get_rect()));
@ -190,10 +190,10 @@ Rect2i EmbeddedProcessMacOS::get_adjusted_embedded_window_rect(const Rect2i &p_r
}
}
void EmbeddedProcessMacOS::mouse_set_mode(DisplayServer::MouseMode p_mode) {
void EmbeddedProcessMacOS::mouse_set_mode(DisplayServerEnums::MouseMode p_mode) {
mouse_mode = p_mode;
// If the mouse is anything other than visible, we must ensure the Game view is active and the layer focused.
if (mouse_mode != DisplayServer::MOUSE_MODE_VISIBLE) {
if (mouse_mode != DisplayServerEnums::MOUSE_MODE_VISIBLE) {
EditorNode::get_singleton()->get_editor_main_screen()->select(EditorMainScreen::EDITOR_GAME);
layer_host->grab_focus();
}
@ -226,11 +226,11 @@ void LayerHost::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_MOUSE_ENTER: {
DisplayServer *ds = DisplayServer::get_singleton();
for (const KeyValue<DisplayServer::CursorShape, CustomCursor> &E : custom_cursors) {
for (const KeyValue<DisplayServerEnums::CursorShape, CustomCursor> &E : custom_cursors) {
ds->cursor_set_custom_image(E.value.image, E.key, E.value.hotspot);
}
if (script_debugger) {
script_debugger->send_message("embed:win_event", { DisplayServer::WINDOW_EVENT_MOUSE_ENTER });
script_debugger->send_message("embed:win_event", { DisplayServerEnums::WINDOW_EVENT_MOUSE_ENTER });
}
if (get_window()->has_focus()) {
grab_focus();
@ -245,28 +245,28 @@ void LayerHost::_notification(int p_what) {
ds->mouse_set_mode(process->get_mouse_mode());
}
script_debugger->send_message("embed:notification", { NOTIFICATION_APPLICATION_FOCUS_IN });
script_debugger->send_message("embed:win_event", { DisplayServer::WINDOW_EVENT_FOCUS_IN });
script_debugger->send_message("embed:win_event", { DisplayServerEnums::WINDOW_EVENT_FOCUS_IN });
window_focused = true;
}
process->queue_redraw();
} break;
case NOTIFICATION_MOUSE_EXIT: {
DisplayServer *ds = DisplayServer::get_singleton();
for (int i = 0; i < DisplayServer::CURSOR_MAX; i++) {
ds->cursor_set_custom_image(Ref<Resource>(), (DisplayServer::CursorShape)i, Vector2());
for (int i = 0; i < DisplayServerEnums::CURSOR_MAX; i++) {
ds->cursor_set_custom_image(Ref<Resource>(), (DisplayServerEnums::CursorShape)i, Vector2());
}
if (script_debugger) {
script_debugger->send_message("embed:win_event", { DisplayServer::WINDOW_EVENT_MOUSE_EXIT });
script_debugger->send_message("embed:win_event", { DisplayServerEnums::WINDOW_EVENT_MOUSE_EXIT });
}
} break;
case NOTIFICATION_FOCUS_EXIT: {
// Temporarily set mouse state back to visible, so the user can interact with the editor.
if (window_focused && script_debugger) {
DisplayServer *ds = DisplayServer::get_singleton();
if (ds->mouse_get_mode() != DisplayServer::MOUSE_MODE_VISIBLE) {
ds->mouse_set_mode(DisplayServer::MOUSE_MODE_VISIBLE);
if (ds->mouse_get_mode() != DisplayServerEnums::MOUSE_MODE_VISIBLE) {
ds->mouse_set_mode(DisplayServerEnums::MOUSE_MODE_VISIBLE);
}
script_debugger->send_message("embed:win_event", { DisplayServer::WINDOW_EVENT_FOCUS_OUT });
script_debugger->send_message("embed:win_event", { DisplayServerEnums::WINDOW_EVENT_FOCUS_OUT });
script_debugger->send_message("embed:notification", { NOTIFICATION_APPLICATION_FOCUS_OUT });
window_focused = false;
}
@ -283,11 +283,11 @@ void LayerHost::_notification(int p_what) {
case NOTIFICATION_VISIBILITY_CHANGED: {
if (!is_visible_in_tree()) {
DisplayServer *ds = DisplayServer::get_singleton();
for (int i = 0; i < DisplayServer::CURSOR_MAX; i++) {
ds->cursor_set_custom_image(Ref<Resource>(), (DisplayServer::CursorShape)i, Vector2());
for (int i = 0; i < DisplayServerEnums::CURSOR_MAX; i++) {
ds->cursor_set_custom_image(Ref<Resource>(), (DisplayServerEnums::CursorShape)i, Vector2());
}
if (ds->mouse_get_mode() != DisplayServer::MOUSE_MODE_VISIBLE) {
ds->mouse_set_mode(DisplayServer::MOUSE_MODE_VISIBLE);
if (ds->mouse_get_mode() != DisplayServerEnums::MOUSE_MODE_VISIBLE) {
ds->mouse_set_mode(DisplayServerEnums::MOUSE_MODE_VISIBLE);
}
}
} break;
@ -298,12 +298,12 @@ void LayerHost::_notification(int p_what) {
if (process->get_mouse_mode() != ds->mouse_get_mode()) {
// Restore embedded process mouse mode.
ds->mouse_set_mode(process->get_mouse_mode());
if (process->get_mouse_mode() != DisplayServer::MOUSE_MODE_VISIBLE) {
if (process->get_mouse_mode() != DisplayServerEnums::MOUSE_MODE_VISIBLE) {
get_window()->grab_focus();
}
}
script_debugger->send_message("embed:notification", { NOTIFICATION_APPLICATION_FOCUS_IN });
script_debugger->send_message("embed:win_event", { DisplayServer::WINDOW_EVENT_FOCUS_IN });
script_debugger->send_message("embed:win_event", { DisplayServerEnums::WINDOW_EVENT_FOCUS_IN });
window_focused = true;
}
} break;
@ -311,10 +311,10 @@ void LayerHost::_notification(int p_what) {
case NOTIFICATION_WM_WINDOW_FOCUS_OUT: {
if (has_focus() && window_focused && script_debugger) {
DisplayServer *ds = DisplayServer::get_singleton();
if (ds->mouse_get_mode() != DisplayServer::MOUSE_MODE_VISIBLE) {
ds->mouse_set_mode(DisplayServer::MOUSE_MODE_VISIBLE);
if (ds->mouse_get_mode() != DisplayServerEnums::MOUSE_MODE_VISIBLE) {
ds->mouse_set_mode(DisplayServerEnums::MOUSE_MODE_VISIBLE);
}
script_debugger->send_message("embed:win_event", { DisplayServer::WINDOW_EVENT_FOCUS_OUT });
script_debugger->send_message("embed:win_event", { DisplayServerEnums::WINDOW_EVENT_FOCUS_OUT });
script_debugger->send_message("embed:notification", { NOTIFICATION_APPLICATION_FOCUS_OUT });
window_focused = false;
}
@ -322,7 +322,7 @@ void LayerHost::_notification(int p_what) {
}
}
void LayerHost::cursor_set_custom_image(const Ref<Image> &p_image, DisplayServer::CursorShape p_shape, const Vector2 &p_hotspot) {
void LayerHost::cursor_set_custom_image(const Ref<Image> &p_image, DisplayServerEnums::CursorShape p_shape, const Vector2 &p_hotspot) {
custom_cursors[p_shape] = CustomCursor(p_image, p_hotspot);
}
@ -334,10 +334,10 @@ void LayerHost::gui_input(const Ref<InputEvent> &p_event) {
if (p_event->is_pressed()) {
if (ED_IS_SHORTCUT("game_view/release_mouse", p_event)) {
DisplayServer *ds = DisplayServer::get_singleton();
if (ds->mouse_get_mode() != DisplayServer::MOUSE_MODE_VISIBLE) {
ds->mouse_set_mode(DisplayServer::MOUSE_MODE_VISIBLE);
if (ds->mouse_get_mode() != DisplayServerEnums::MOUSE_MODE_VISIBLE) {
ds->mouse_set_mode(DisplayServerEnums::MOUSE_MODE_VISIBLE);
if (script_debugger != nullptr) {
script_debugger->send_message("embed:mouse_set_mode", { DisplayServer::MOUSE_MODE_VISIBLE });
script_debugger->send_message("embed:mouse_set_mode", { DisplayServerEnums::MOUSE_MODE_VISIBLE });
}
}
accept_event();

8
platform/macos/embedded_debugger.mm
View file

@ -90,7 +90,7 @@ Error EmbeddedDebugger::_msg_window_size(const Array &p_args) {
Error EmbeddedDebugger::_msg_mouse_set_mode(const Array &p_args) {
ERR_FAIL_COND_V_MSG(p_args.size() != 1, ERR_INVALID_PARAMETER, "Invalid number of arguments for 'mouse_set_mode' message.");
DisplayServer::MouseMode mode = p_args[0];
DisplayServerEnums::MouseMode mode = p_args[0];
ds->mouse_set_mode(mode);
return OK;
}
@ -137,9 +137,9 @@ Error EmbeddedDebugger::_msg_event(const Array &p_args) {
Error EmbeddedDebugger::_msg_win_event(const Array &p_args) {
ERR_FAIL_COND_V_MSG(p_args.size() != 1, ERR_INVALID_PARAMETER, "Invalid number of arguments for 'win_event' message.");
DisplayServer::WindowEvent win_event = p_args[0];
ds->send_window_event(win_event, DisplayServer::MAIN_WINDOW_ID);
if (win_event == DisplayServer::WindowEvent::WINDOW_EVENT_MOUSE_EXIT) {
DisplayServerEnums::WindowEvent win_event = p_args[0];
ds->send_window_event(win_event, DisplayServerEnums::MAIN_WINDOW_ID);
if (win_event == DisplayServerEnums::WindowEvent::WINDOW_EVENT_MOUSE_EXIT) {
Input::get_singleton()->release_pressed_events();
}
return OK;

16
platform/macos/embedded_gl_manager.h
View file

@ -75,11 +75,11 @@ class GLManagerEmbedded {
~GLWindow() { destroy_framebuffers(); }
};
RBMap<DisplayServer::WindowID, GLWindow> windows;
typedef RBMap<DisplayServer::WindowID, GLWindow>::Element GLWindowElement;
RBMap<DisplayServerEnums::WindowID, GLWindow> windows;
typedef RBMap<DisplayServerEnums::WindowID, GLWindow>::Element GLWindowElement;
NSOpenGLContext *shared_context = nullptr;
DisplayServer::WindowID current_window = DisplayServer::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID current_window = DisplayServerEnums::INVALID_WINDOW_ID;
Error create_context(GLWindow &p_win);
@ -98,10 +98,10 @@ class GLManagerEmbedded {
void release_display_link();
public:
Error window_create(DisplayServer::WindowID p_window_id, CALayer *p_layer, int p_width, int p_height);
void window_destroy(DisplayServer::WindowID p_window_id);
void window_resize(DisplayServer::WindowID p_window_id, int p_width, int p_height);
Size2i window_get_size(DisplayServer::WindowID p_window_id) const;
Error window_create(DisplayServerEnums::WindowID p_window_id, CALayer *p_layer, int p_width, int p_height);
void window_destroy(DisplayServerEnums::WindowID p_window_id);
void window_resize(DisplayServerEnums::WindowID p_window_id, int p_width, int p_height);
Size2i window_get_size(DisplayServerEnums::WindowID p_window_id) const;
void set_display_id(uint32_t p_display_id);
void set_vsync_enabled(bool p_enabled);
@ -110,7 +110,7 @@ public:
void release_current();
void swap_buffers();
void window_make_current(DisplayServer::WindowID p_window_id);
void window_make_current(DisplayServerEnums::WindowID p_window_id);
Error initialize();

16
platform/macos/embedded_gl_manager.mm
View file

@ -65,7 +65,7 @@ Error GLManagerEmbedded::create_context(GLWindow &p_win) {
return OK;
}
Error GLManagerEmbedded::window_create(DisplayServer::WindowID p_window_id, CALayer *p_layer, int p_width, int p_height) {
Error GLManagerEmbedded::window_create(DisplayServerEnums::WindowID p_window_id, CALayer *p_layer, int p_width, int p_height) {
GLWindow win;
win.layer = p_layer;
win.width = 0;
@ -81,7 +81,7 @@ Error GLManagerEmbedded::window_create(DisplayServer::WindowID p_window_id, CALa
return OK;
}
void GLManagerEmbedded::window_resize(DisplayServer::WindowID p_window_id, int p_width, int p_height) {
void GLManagerEmbedded::window_resize(DisplayServerEnums::WindowID p_window_id, int p_width, int p_height) {
GLWindowElement *el = windows.find(p_window_id);
ERR_FAIL_NULL_MSG(el, "Window resize failed: window does not exist.");
@ -175,7 +175,7 @@ void GLManagerEmbedded::GLWindow::destroy_framebuffers() {
}
}
Size2i GLManagerEmbedded::window_get_size(DisplayServer::WindowID p_window_id) const {
Size2i GLManagerEmbedded::window_get_size(DisplayServerEnums::WindowID p_window_id) const {
const GLWindowElement *el = windows.find(p_window_id);
if (el == nullptr) {
return Size2i();
@ -185,29 +185,29 @@ Size2i GLManagerEmbedded::window_get_size(DisplayServer::WindowID p_window_id) c
return Size2i(win.width, win.height);
}
void GLManagerEmbedded::window_destroy(DisplayServer::WindowID p_window_id) {
void GLManagerEmbedded::window_destroy(DisplayServerEnums::WindowID p_window_id) {
GLWindowElement *el = windows.find(p_window_id);
if (el == nullptr) {
return;
}
if (current_window == p_window_id) {
current_window = DisplayServer::INVALID_WINDOW_ID;
current_window = DisplayServerEnums::INVALID_WINDOW_ID;
}
windows.erase(el);
}
void GLManagerEmbedded::release_current() {
if (current_window == DisplayServer::INVALID_WINDOW_ID) {
if (current_window == DisplayServerEnums::INVALID_WINDOW_ID) {
return;
}
[NSOpenGLContext clearCurrentContext];
current_window = DisplayServer::INVALID_WINDOW_ID;
current_window = DisplayServerEnums::INVALID_WINDOW_ID;
}
void GLManagerEmbedded::window_make_current(DisplayServer::WindowID p_window_id) {
void GLManagerEmbedded::window_make_current(DisplayServerEnums::WindowID p_window_id) {
if (current_window == p_window_id) {
return;
}

2
platform/macos/gl_manager_macos_angle.h
View file

@ -57,7 +57,7 @@ private:
virtual Vector<EGLint> _get_platform_context_attribs() const override;
public:
void window_resize(DisplayServer::WindowID p_window_id, int p_width, int p_height) {}
void window_resize(DisplayServerEnums::WindowID p_window_id, int p_width, int p_height) {}
GLManagerANGLE_MacOS() {}
~GLManagerANGLE_MacOS() {}

16
platform/macos/gl_manager_macos_legacy.h
View file

@ -51,10 +51,10 @@ class GLManagerLegacy_MacOS {
NSOpenGLContext *context = nullptr;
};
RBMap<DisplayServer::WindowID, GLWindow> windows;
RBMap<DisplayServerEnums::WindowID, GLWindow> windows;
NSOpenGLContext *shared_context = nullptr;
DisplayServer::WindowID current_window = DisplayServer::INVALID_WINDOW_ID;
DisplayServerEnums::WindowID current_window = DisplayServerEnums::INVALID_WINDOW_ID;
Error create_context(GLWindow &win);
@ -65,23 +65,23 @@ class GLManagerLegacy_MacOS {
CGLGetCurrentContextPtr CGLGetCurrentContext = nullptr;
public:
Error window_create(DisplayServer::WindowID p_window_id, id p_view, int p_width, int p_height);
void window_destroy(DisplayServer::WindowID p_window_id);
void window_resize(DisplayServer::WindowID p_window_id, int p_width, int p_height);
Error window_create(DisplayServerEnums::WindowID p_window_id, id p_view, int p_width, int p_height);
void window_destroy(DisplayServerEnums::WindowID p_window_id);
void window_resize(DisplayServerEnums::WindowID p_window_id, int p_width, int p_height);
void release_current();
void swap_buffers();
void window_make_current(DisplayServer::WindowID p_window_id);
void window_make_current(DisplayServerEnums::WindowID p_window_id);
void window_set_per_pixel_transparency_enabled(DisplayServer::WindowID p_window_id, bool p_enabled);
void window_set_per_pixel_transparency_enabled(DisplayServerEnums::WindowID p_window_id, bool p_enabled);
Error initialize();
void set_use_vsync(bool p_use);
bool is_using_vsync() const;
NSOpenGLContext *get_context(DisplayServer::WindowID p_window_id);
NSOpenGLContext *get_context(DisplayServerEnums::WindowID p_window_id);
GLManagerLegacy_MacOS();
~GLManagerLegacy_MacOS();

18
platform/macos/gl_manager_macos_legacy.mm
View file

@ -64,7 +64,7 @@ Error GLManagerLegacy_MacOS::create_context(GLWindow &win) {
return OK;
}
Error GLManagerLegacy_MacOS::window_create(DisplayServer::WindowID p_window_id, id p_view, int p_width, int p_height) {
Error GLManagerLegacy_MacOS::window_create(DisplayServerEnums::WindowID p_window_id, id p_view, int p_width, int p_height) {
GLWindow win;
win.window_view = p_view;
@ -78,7 +78,7 @@ Error GLManagerLegacy_MacOS::window_create(DisplayServer::WindowID p_window_id,
return OK;
}
void GLManagerLegacy_MacOS::window_resize(DisplayServer::WindowID p_window_id, int p_width, int p_height) {
void GLManagerLegacy_MacOS::window_resize(DisplayServerEnums::WindowID p_window_id, int p_width, int p_height) {
if (!windows.has(p_window_id)) {
return;
}
@ -99,28 +99,28 @@ void GLManagerLegacy_MacOS::window_resize(DisplayServer::WindowID p_window_id, i
[win.context update];
}
void GLManagerLegacy_MacOS::window_destroy(DisplayServer::WindowID p_window_id) {
void GLManagerLegacy_MacOS::window_destroy(DisplayServerEnums::WindowID p_window_id) {
if (!windows.has(p_window_id)) {
return;
}
if (current_window == p_window_id) {
current_window = DisplayServer::INVALID_WINDOW_ID;
current_window = DisplayServerEnums::INVALID_WINDOW_ID;
}
windows.erase(p_window_id);
}
void GLManagerLegacy_MacOS::release_current() {
if (current_window == DisplayServer::INVALID_WINDOW_ID) {
if (current_window == DisplayServerEnums::INVALID_WINDOW_ID) {
return;
}
[NSOpenGLContext clearCurrentContext];
current_window = DisplayServer::INVALID_WINDOW_ID;
current_window = DisplayServerEnums::INVALID_WINDOW_ID;
}
void GLManagerLegacy_MacOS::window_make_current(DisplayServer::WindowID p_window_id) {
void GLManagerLegacy_MacOS::window_make_current(DisplayServerEnums::WindowID p_window_id) {
if (current_window == p_window_id) {
return;
}
@ -139,7 +139,7 @@ void GLManagerLegacy_MacOS::swap_buffers() {
[win.context flushBuffer];
}
void GLManagerLegacy_MacOS::window_set_per_pixel_transparency_enabled(DisplayServer::WindowID p_window_id, bool p_enabled) {
void GLManagerLegacy_MacOS::window_set_per_pixel_transparency_enabled(DisplayServerEnums::WindowID p_window_id, bool p_enabled) {
if (!windows.has(p_window_id)) {
return;
}
@ -176,7 +176,7 @@ bool GLManagerLegacy_MacOS::is_using_vsync() const {
return use_vsync;
}
NSOpenGLContext *GLManagerLegacy_MacOS::get_context(DisplayServer::WindowID p_window_id) {
NSOpenGLContext *GLManagerLegacy_MacOS::get_context(DisplayServerEnums::WindowID p_window_id) {
if (!windows.has(p_window_id)) {
return nullptr;
}

6
platform/macos/godot_application_delegate.mm
View file

@ -262,7 +262,7 @@ constexpr static NSEventModifierFlags FLAGS = NSEventModifierFlagCommand | NSEve
return;
}
DisplayServer::WindowID window_id = ds->get_focused_window();
DisplayServerEnums::WindowID window_id = ds->get_focused_window();
NSEventModifierFlags flags = static_cast<NSEventModifierFlags>(mod);
for (const CGKeyCode key : modifiers) {
@ -322,8 +322,8 @@ constexpr static NSEventModifierFlags FLAGS = NSEventModifierFlagCommand | NSEve
}
DisplayServerMacOS *ds = Object::cast_to<DisplayServerMacOS>(DisplayServer::get_singleton());
if (ds && ds->has_window(DisplayServerMacOS::MAIN_WINDOW_ID)) {
ds->send_window_event(ds->get_window(DisplayServerMacOS::MAIN_WINDOW_ID), DisplayServerMacOS::WINDOW_EVENT_CLOSE_REQUEST);
if (ds && ds->has_window(DisplayServerEnums::MAIN_WINDOW_ID)) {
ds->send_window_event(ds->get_window(DisplayServerEnums::MAIN_WINDOW_ID), DisplayServerEnums::WINDOW_EVENT_CLOSE_REQUEST);
}
return NSTerminateCancel;

8
platform/macos/godot_content_view.h
View file

@ -45,11 +45,11 @@
#import <QuartzCore/CAMetalLayer.h>
@interface GodotContentLayerDelegate : NSObject <CALayerDelegate> {
DisplayServer::WindowID window_id;
DisplayServerEnums::WindowID window_id;
bool need_redraw;
}
- (void)setWindowID:(DisplayServer::WindowID)wid;
- (void)setWindowID:(DisplayServerEnums::WindowID)wid;
- (void)setNeedRedraw:(bool)redraw;
@end
@ -57,7 +57,7 @@
GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wdeprecated-declarations") // OpenGL is deprecated in macOS 10.14.
@interface GodotContentView : RootView <NSTextInputClient> {
DisplayServer::WindowID window_id;
DisplayServerEnums::WindowID window_id;
NSTrackingArea *tracking_area;
NSMutableAttributedString *marked_text;
bool ime_input_event_in_progress;
@ -72,7 +72,7 @@ GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wdeprecated-declarations") // OpenGL is de
- (void)processScrollEvent:(NSEvent *)event button:(MouseButton)button factor:(double)factor;
- (void)processPanEvent:(NSEvent *)event dx:(double)dx dy:(double)dy;
- (void)processMouseEvent:(NSEvent *)event index:(MouseButton)index pressed:(bool)pressed outofstream:(bool)outofstream;
- (void)setWindowID:(DisplayServer::WindowID)wid;
- (void)setWindowID:(DisplayServerEnums::WindowID)wid;
- (void)updateLayerDelegate;
- (void)cancelComposition;

34
platform/macos/godot_content_view.mm
View file

@ -44,12 +44,12 @@
- (id)init {
self = [super init];
window_id = DisplayServer::INVALID_WINDOW_ID;
window_id = DisplayServerEnums::INVALID_WINDOW_ID;
need_redraw = false;
return self;
}
- (void)setWindowID:(DisplayServerMacOS::WindowID)wid {
- (void)setWindowID:(DisplayServerEnums::WindowID)wid {
window_id = wid;
}
@ -140,7 +140,7 @@
- (id)init {
self = [super init];
layer_delegate = [[GodotContentLayerDelegate alloc] init];
window_id = DisplayServer::INVALID_WINDOW_ID;
window_id = DisplayServerEnums::INVALID_WINDOW_ID;
tracking_area = nil;
ime_input_event_in_progress = false;
mouse_down_control = false;
@ -157,7 +157,7 @@
return self;
}
- (void)setWindowID:(DisplayServerMacOS::WindowID)wid {
- (void)setWindowID:(DisplayServerEnums::WindowID)wid {
window_id = wid;
[layer_delegate setWindowID:window_id];
}
@ -434,7 +434,7 @@
DisplayServerMacOS *ds = (DisplayServerMacOS *)DisplayServer::get_singleton();
if (ds && ds->has_window(window_id)) {
DisplayServerMacOS::WindowData &wd = ds->get_window(window_id);
wd.edge = DisplayServer::WINDOW_EDGE_MAX;
wd.edge = DisplayServerEnums::WINDOW_EDGE_MAX;
}
if (([event modifierFlags] & NSEventModifierFlagControl)) {
mouse_down_control = true;
@ -449,43 +449,43 @@
DisplayServerMacOS *ds = (DisplayServerMacOS *)DisplayServer::get_singleton();
if (ds && ds->has_window(window_id)) {
DisplayServerMacOS::WindowData &wd = ds->get_window(window_id);
if (wd.edge != DisplayServer::WINDOW_EDGE_MAX) {
if (wd.edge != DisplayServerEnums::WINDOW_EDGE_MAX) {
Size2i max_size = wd.max_size / ds->screen_get_max_scale();
Size2i min_size = wd.min_size / ds->screen_get_max_scale();
NSRect frame = [wd.window_object frame];
switch (wd.edge) {
case DisplayServer::WINDOW_EDGE_TOP_LEFT: {
case DisplayServerEnums::WINDOW_EDGE_TOP_LEFT: {
int clamped_dx = CLAMP(frame.size.width - event.deltaX, min_size.x, max_size.x) - frame.size.width;
int clamped_dy = CLAMP(frame.size.height - event.deltaY, min_size.y, max_size.y) - frame.size.height;
[wd.window_object setFrame:NSMakeRect(frame.origin.x - clamped_dx, frame.origin.y, frame.size.width + clamped_dx, frame.size.height + clamped_dy) display:YES];
} break;
case DisplayServer::WINDOW_EDGE_TOP: {
case DisplayServerEnums::WINDOW_EDGE_TOP: {
int clamped_dy = CLAMP(frame.size.height - event.deltaY, min_size.y, max_size.y) - frame.size.height;
[wd.window_object setFrame:NSMakeRect(frame.origin.x, frame.origin.y, frame.size.width, frame.size.height + clamped_dy) display:YES];
} break;
case DisplayServer::WINDOW_EDGE_TOP_RIGHT: {
case DisplayServerEnums::WINDOW_EDGE_TOP_RIGHT: {
int clamped_dx = CLAMP(frame.size.width + event.deltaX, min_size.x, max_size.x) - frame.size.width;
int clamped_dy = CLAMP(frame.size.height - event.deltaY, min_size.y, max_size.y) - frame.size.height;
[wd.window_object setFrame:NSMakeRect(frame.origin.x, frame.origin.y, frame.size.width + clamped_dx, frame.size.height + clamped_dy) display:YES];
} break;
case DisplayServer::WINDOW_EDGE_LEFT: {
case DisplayServerEnums::WINDOW_EDGE_LEFT: {
int clamped_dx = CLAMP(frame.size.width - event.deltaX, min_size.x, max_size.x) - frame.size.width;
[wd.window_object setFrame:NSMakeRect(frame.origin.x - clamped_dx, frame.origin.y, frame.size.width + clamped_dx, frame.size.height) display:YES];
} break;
case DisplayServer::WINDOW_EDGE_RIGHT: {
case DisplayServerEnums::WINDOW_EDGE_RIGHT: {
int clamped_dx = CLAMP(frame.size.width + event.deltaX, min_size.x, max_size.x) - frame.size.width;
[wd.window_object setFrame:NSMakeRect(frame.origin.x, frame.origin.y, frame.size.width + clamped_dx, frame.size.height) display:YES];
} break;
case DisplayServer::WINDOW_EDGE_BOTTOM_LEFT: {
case DisplayServerEnums::WINDOW_EDGE_BOTTOM_LEFT: {
int clamped_dx = CLAMP(frame.size.width - event.deltaX, min_size.x, max_size.x) - frame.size.width;
int clamped_dy = CLAMP(frame.size.height + event.deltaY, min_size.y, max_size.y) - frame.size.height;
[wd.window_object setFrame:NSMakeRect(frame.origin.x - clamped_dx, frame.origin.y - clamped_dy, frame.size.width + clamped_dx, frame.size.height + clamped_dy) display:YES];
} break;
case DisplayServer::WINDOW_EDGE_BOTTOM: {
case DisplayServerEnums::WINDOW_EDGE_BOTTOM: {
int clamped_dy = CLAMP(frame.size.height + event.deltaY, min_size.y, max_size.y) - frame.size.height;
[wd.window_object setFrame:NSMakeRect(frame.origin.x, frame.origin.y - clamped_dy, frame.size.width, frame.size.height + clamped_dy) display:YES];
} break;
case DisplayServer::WINDOW_EDGE_BOTTOM_RIGHT: {
case DisplayServerEnums::WINDOW_EDGE_BOTTOM_RIGHT: {
int clamped_dx = CLAMP(frame.size.width + event.deltaX, min_size.x, max_size.x) - frame.size.width;
int clamped_dy = CLAMP(frame.size.height + event.deltaY, min_size.y, max_size.y) - frame.size.height;
[wd.window_object setFrame:NSMakeRect(frame.origin.x, frame.origin.y - clamped_dy, frame.size.width + clamped_dx, frame.size.height + clamped_dy) display:YES];
@ -503,7 +503,7 @@
DisplayServerMacOS *ds = (DisplayServerMacOS *)DisplayServer::get_singleton();
if (ds && ds->has_window(window_id)) {
DisplayServerMacOS::WindowData &wd = ds->get_window(window_id);
wd.edge = DisplayServer::WINDOW_EDGE_MAX;
wd.edge = DisplayServerEnums::WINDOW_EDGE_MAX;
}
if (mouse_down_control) {
[self processMouseEvent:event index:MouseButton::RIGHT pressed:false outofstream:false];
@ -622,7 +622,7 @@
return;
}
if (ds->mouse_get_mode() != DisplayServer::MOUSE_MODE_CAPTURED) {
if (ds->mouse_get_mode() != DisplayServerEnums::MOUSE_MODE_CAPTURED) {
ds->mouse_exit_window(window_id);
}
}
@ -633,7 +633,7 @@
return;
}
if (ds->mouse_get_mode() != DisplayServer::MOUSE_MODE_CAPTURED) {
if (ds->mouse_get_mode() != DisplayServerEnums::MOUSE_MODE_CAPTURED) {
ds->mouse_enter_window(window_id);
}

4
platform/macos/godot_progress_view.h
View file

@ -36,10 +36,10 @@
#import <Foundation/Foundation.h>
@interface GodotProgressView : NSView {
DisplayServer::ProgressState pr_state;
DisplayServerEnums::ProgressState pr_state;
float pr_value;
float pr_offset;
}
- (void)setValue:(float)value;
- (void)setState:(DisplayServer::ProgressState)state;
- (void)setState:(DisplayServerEnums::ProgressState)state;
@end

12
platform/macos/godot_progress_view.mm
View file

@ -34,7 +34,7 @@
- (id)init {
self = [super init];
pr_state = DisplayServer::PROGRESS_STATE_NOPROGRESS;
pr_state = DisplayServerEnums::PROGRESS_STATE_NOPROGRESS;
pr_value = 0.f;
pr_offset = 0.f;
return self;
@ -44,7 +44,7 @@
pr_value = value;
}
- (void)setState:(DisplayServer::ProgressState)state {
- (void)setState:(DisplayServerEnums::ProgressState)state {
pr_state = state;
}
@ -53,7 +53,7 @@
[[NSGraphicsContext currentContext] setImageInterpolation:NSImageInterpolationHigh];
[[NSApp applicationIconImage] drawInRect:self.bounds];
if (pr_state == DisplayServer::PROGRESS_STATE_NOPROGRESS) {
if (pr_state == DisplayServerEnums::PROGRESS_STATE_NOPROGRESS) {
return;
}
@ -71,7 +71,7 @@
[bezier_path addClip];
// Fill draw.
if (pr_state == DisplayServer::PROGRESS_STATE_INDETERMINATE) {
if (pr_state == DisplayServerEnums::PROGRESS_STATE_INDETERMINATE) {
rect.size.width /= 5.0;
pr_offset += rect.size.width / 10.0;
if (pr_offset > self.bounds.size.width - rect.size.width) {
@ -81,9 +81,9 @@
} else {
rect.size.width = Math::floor(rect.size.width * pr_value);
}
if (pr_state == DisplayServer::PROGRESS_STATE_ERROR) {
if (pr_state == DisplayServerEnums::PROGRESS_STATE_ERROR) {
[[NSColor colorWithSRGBRed:1.0 green:0.2 blue:0.2 alpha:1.0] set];
} else if (pr_state == DisplayServer::PROGRESS_STATE_PAUSED) {
} else if (pr_state == DisplayServerEnums::PROGRESS_STATE_PAUSED) {
[[NSColor colorWithSRGBRed:1.0 green:1.0 blue:0.2 alpha:1.0] set];
} else {
[[NSColor colorWithSRGBRed:0.2 green:0.6 blue:1.0 alpha:1.0] set];

4
platform/macos/godot_window.h
View file

@ -36,11 +36,11 @@
#import <Foundation/Foundation.h>
@interface GodotWindow : NSWindow {
DisplayServer::WindowID window_id;
DisplayServerEnums::WindowID window_id;
NSTimeInterval anim_duration;
}
- (void)setWindowID:(DisplayServer::WindowID)wid;
- (void)setWindowID:(DisplayServerEnums::WindowID)wid;
- (void)setAnimDuration:(NSTimeInterval)duration;
@end

4
platform/macos/godot_window.mm
View file

@ -36,7 +36,7 @@
- (id)init {
self = [super init];
window_id = DisplayServer::INVALID_WINDOW_ID;
window_id = DisplayServerEnums::INVALID_WINDOW_ID;
anim_duration = -1.0f;
return self;
}
@ -53,7 +53,7 @@
}
}
- (void)setWindowID:(DisplayServerMacOS::WindowID)wid {
- (void)setWindowID:(DisplayServerEnums::WindowID)wid {
window_id = wid;
}

2
platform/macos/godot_window_delegate.h
View file

@ -39,7 +39,7 @@ class DisplayServerMacOS;
@interface GodotWindowDelegate : NSObject <NSWindowDelegate>
- (void)setWindowID:(DisplayServer::WindowID)wid;
- (void)setWindowID:(DisplayServerEnums::WindowID)wid;
- (instancetype)initWithDisplayServer:(DisplayServerMacOS *)p_ds;

32
platform/macos/godot_window_delegate.mm
View file

@ -38,19 +38,19 @@
#include "servers/display/accessibility_server.h"
@implementation GodotWindowDelegate {
DisplayServer::WindowID window_id;
DisplayServerEnums::WindowID window_id;
DisplayServerMacOS *ds;
}
- (instancetype)initWithDisplayServer:(DisplayServerMacOS *)p_ds {
if (self = [super init]) {
ds = p_ds;
window_id = DisplayServerMacOS::INVALID_WINDOW_ID;
window_id = DisplayServerEnums::INVALID_WINDOW_ID;
}
return self;
}
- (void)setWindowID:(DisplayServer::WindowID)wid {
- (void)setWindowID:(DisplayServerEnums::WindowID)wid {
window_id = wid;
}
@ -59,7 +59,7 @@
return YES;
}
ds->send_window_event(ds->get_window(window_id), DisplayServerMacOS::WINDOW_EVENT_CLOSE_REQUEST);
ds->send_window_event(ds->get_window(window_id), DisplayServerEnums::WINDOW_EVENT_CLOSE_REQUEST);
return NO;
}
@ -72,11 +72,11 @@
DisplayServerMacOS::WindowData &wd = ds->get_window(window_id);
while (wd.transient_children.size()) {
ds->window_set_transient(*wd.transient_children.begin(), DisplayServerMacOS::INVALID_WINDOW_ID);
ds->window_set_transient(*wd.transient_children.begin(), DisplayServerEnums::INVALID_WINDOW_ID);
}
if (wd.transient_parent != DisplayServerMacOS::INVALID_WINDOW_ID) {
ds->window_set_transient(window_id, DisplayServerMacOS::INVALID_WINDOW_ID);
if (wd.transient_parent != DisplayServerEnums::INVALID_WINDOW_ID) {
ds->window_set_transient(window_id, DisplayServerEnums::INVALID_WINDOW_ID);
}
ds->mouse_exit_window(window_id);
@ -127,7 +127,7 @@
ds->window_set_custom_window_buttons(wd, false);
}
ds->send_window_event(wd, DisplayServerMacOS::WINDOW_EVENT_TITLEBAR_CHANGE);
ds->send_window_event(wd, DisplayServerEnums::WINDOW_EVENT_TITLEBAR_CHANGE);
// Force window resize event and redraw.
[self windowDidResize:notification];
@ -146,7 +146,7 @@
ds->window_set_custom_window_buttons(wd, true);
}
ds->send_window_event(wd, DisplayServerMacOS::WINDOW_EVENT_TITLEBAR_CHANGE);
ds->send_window_event(wd, DisplayServerEnums::WINDOW_EVENT_TITLEBAR_CHANGE);
}
- (void)windowDidFailToExitFullScreen:(NSWindow *)window {
@ -161,7 +161,7 @@
ds->window_set_custom_window_buttons(wd, false);
}
ds->send_window_event(wd, DisplayServerMacOS::WINDOW_EVENT_TITLEBAR_CHANGE);
ds->send_window_event(wd, DisplayServerEnums::WINDOW_EVENT_TITLEBAR_CHANGE);
}
- (void)windowDidExitFullScreen:(NSNotification *)notification {
@ -238,7 +238,7 @@
wd.size.width = content_rect.size.width * scale;
wd.size.height = content_rect.size.height * scale;
ds->send_window_event(wd, DisplayServerMacOS::WINDOW_EVENT_DPI_CHANGE);
ds->send_window_event(wd, DisplayServerEnums::WINDOW_EVENT_DPI_CHANGE);
CALayer *layer = [wd.window_view layer];
if (layer) {
@ -317,7 +317,7 @@
[wd.window_button_view displayButtons];
}
if (ds->mouse_get_mode() == DisplayServer::MOUSE_MODE_CAPTURED) {
if (ds->mouse_get_mode() == DisplayServerEnums::MOUSE_MODE_CAPTURED) {
const NSRect content_rect = [wd.window_view frame];
NSRect point_in_window_rect = NSMakeRect(content_rect.size.width / 2, content_rect.size.height / 2, 0, 0);
NSPoint point_on_screen = [[wd.window_view window] convertRectToScreen:point_in_window_rect].origin;
@ -333,7 +333,7 @@
ds->set_last_focused_window(window_id);
AccessibilityServer::get_singleton()->set_window_focused(window_id, true);
ds->send_window_event(wd, DisplayServerMacOS::WINDOW_EVENT_FOCUS_IN);
ds->send_window_event(wd, DisplayServerEnums::WINDOW_EVENT_FOCUS_IN);
}
- (void)windowDidResignKey:(NSNotification *)notification {
@ -351,7 +351,7 @@
ds->release_pressed_events();
AccessibilityServer::get_singleton()->set_window_focused(window_id, false);
ds->send_window_event(wd, DisplayServerMacOS::WINDOW_EVENT_FOCUS_OUT);
ds->send_window_event(wd, DisplayServerEnums::WINDOW_EVENT_FOCUS_OUT);
}
- (void)windowDidMiniaturize:(NSNotification *)notification {
@ -365,7 +365,7 @@
ds->release_pressed_events();
AccessibilityServer::get_singleton()->set_window_focused(window_id, false);
ds->send_window_event(wd, DisplayServerMacOS::WINDOW_EVENT_FOCUS_OUT);
ds->send_window_event(wd, DisplayServerEnums::WINDOW_EVENT_FOCUS_OUT);
}
- (void)windowDidDeminiaturize:(NSNotification *)notification {
@ -380,7 +380,7 @@
ds->set_last_focused_window(window_id);
AccessibilityServer::get_singleton()->set_window_focused(window_id, true);
ds->send_window_event(wd, DisplayServerMacOS::WINDOW_EVENT_FOCUS_IN);
ds->send_window_event(wd, DisplayServerEnums::WINDOW_EVENT_FOCUS_IN);
}
}

5
platform/macos/tts_macos.h
View file

@ -34,7 +34,6 @@
#include "core/templates/hash_map.h"
#include "core/templates/list.h"
#include "core/variant/array.h"
#include "servers/display/display_server.h"
#import <AppKit/AppKit.h>
@ -44,6 +43,8 @@
#import <AVFoundation/AVFoundation.h>
#endif
struct TTSUtterance;
@interface TTS_MacOS : NSObject <AVSpeechSynthesizerDelegate> {
// AVSpeechSynthesizer
bool speaking;
@ -55,7 +56,7 @@
int64_t last_utterance;
id synth; // NSSpeechSynthesizer or AVSpeechSynthesizer
List<DisplayServer::TTSUtterance> queue;
List<TTSUtterance> queue;
}
- (void)pauseSpeaking;

28
platform/macos/tts_macos.mm
View file

@ -30,6 +30,8 @@
#import "tts_macos.h"
#include "servers/display/display_server.h"
@implementation TTS_MacOS
- (id)init {
@ -65,13 +67,13 @@
pos++;
}
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_BOUNDARY, ids[utterance], pos);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_BOUNDARY, ids[utterance], pos);
}
// AVSpeechSynthesizer callback (macOS 10.14+)
- (void)speechSynthesizer:(AVSpeechSynthesizer *)av_synth didCancelSpeechUtterance:(AVSpeechUtterance *)utterance API_AVAILABLE(macosx(10.14)) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, ids[utterance]);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, ids[utterance]);
ids.erase(utterance);
speaking = false;
[self update];
@ -80,7 +82,7 @@
// AVSpeechSynthesizer callback (macOS 10.14+)
- (void)speechSynthesizer:(AVSpeechSynthesizer *)av_synth didFinishSpeechUtterance:(AVSpeechUtterance *)utterance API_AVAILABLE(macosx(10.14)) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_ENDED, ids[utterance]);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_ENDED, ids[utterance]);
ids.erase(utterance);
speaking = false;
[self update];
@ -100,16 +102,16 @@
pos++;
}
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_BOUNDARY, last_utterance, pos);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_BOUNDARY, last_utterance, pos);
}
}
- (void)speechSynthesizer:(NSSpeechSynthesizer *)ns_synth didFinishSpeaking:(BOOL)success {
if (!paused && have_utterance) {
if (success) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_ENDED, last_utterance);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_ENDED, last_utterance);
} else {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, last_utterance);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, last_utterance);
}
have_utterance = false;
}
@ -119,7 +121,7 @@
- (void)update {
if (!speaking && queue.size() > 0) {
DisplayServer::TTSUtterance &message = queue.front()->get();
TTSUtterance &message = queue.front()->get();
if (@available(macOS 10.14, *)) {
AVSpeechSynthesizer *av_synth = synth;
@ -148,7 +150,7 @@
have_utterance = true;
[ns_synth startSpeakingString:[NSString stringWithUTF8String:message.text.utf8().get_data()]];
}
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_STARTED, message.id);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_STARTED, message.id);
queue.pop_front();
speaking = true;
@ -178,8 +180,8 @@
}
- (void)stopSpeaking {
for (DisplayServer::TTSUtterance &message : queue) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, message.id);
for (TTSUtterance &message : queue) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, message.id);
}
queue.clear();
if (@available(macOS 10.14, *)) {
@ -188,7 +190,7 @@
} else {
NSSpeechSynthesizer *ns_synth = synth;
if (have_utterance) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, last_utterance);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, last_utterance);
}
[ns_synth stopSpeaking];
}
@ -216,11 +218,11 @@
}
if (text.is_empty()) {
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, utterance_id);
DisplayServer::get_singleton()->tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, utterance_id);
return;
}
DisplayServer::TTSUtterance message;
TTSUtterance message;
message.text = text;
message.voice = voice;
message.volume = CLAMP(volume, 0, 100);

10
platform/visionos/display_server_visionos.h
View file

@ -37,20 +37,20 @@ class DisplayServerVisionOS : public DisplayServerAppleEmbedded {
_THREAD_SAFE_CLASS_
DisplayServerVisionOS(const String &p_rendering_driver, DisplayServer::WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error);
DisplayServerVisionOS(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
~DisplayServerVisionOS();
public:
static DisplayServerVisionOS *get_singleton();
static void register_visionos_driver();
static DisplayServer *create_func(const String &p_rendering_driver, WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error);
static DisplayServer *create_func(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
virtual String get_name() const override;
virtual int screen_get_dpi(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_scale(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_refresh_rate(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual int screen_get_dpi(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_scale(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_refresh_rate(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
protected:
virtual bool _screen_hdr_is_supported() const override;

4
platform/visionos/display_server_visionos.mm
View file

@ -34,14 +34,14 @@ DisplayServerVisionOS *DisplayServerVisionOS::get_singleton() {
return (DisplayServerVisionOS *)DisplayServerAppleEmbedded::get_singleton();
}
DisplayServerVisionOS::DisplayServerVisionOS(const String &p_rendering_driver, WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error) :
DisplayServerVisionOS::DisplayServerVisionOS(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error) :
DisplayServerAppleEmbedded(p_rendering_driver, p_mode, p_vsync_mode, p_flags, p_position, p_resolution, p_screen, p_context, p_parent_window, r_error) {
}
DisplayServerVisionOS::~DisplayServerVisionOS() {
}
DisplayServer *DisplayServerVisionOS::create_func(const String &p_rendering_driver, WindowMode p_mode, DisplayServer::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error) {
DisplayServer *DisplayServerVisionOS::create_func(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error) {
return memnew(DisplayServerVisionOS(p_rendering_driver, p_mode, p_vsync_mode, p_flags, p_position, p_resolution, p_screen, p_context, p_parent_window, r_error));
}

252
platform/web/display_server_web.cpp
View file

@ -89,9 +89,9 @@ void DisplayServerWeb::fullscreen_change_callback(int p_fullscreen) {
void DisplayServerWeb::_fullscreen_change_callback(int p_fullscreen) {
DisplayServerWeb *display = get_singleton();
if (p_fullscreen) {
display->window_mode = WINDOW_MODE_FULLSCREEN;
display->window_mode = DisplayServerEnums::WINDOW_MODE_FULLSCREEN;
} else {
display->window_mode = WINDOW_MODE_WINDOWED;
display->window_mode = DisplayServerEnums::WINDOW_MODE_WINDOWED;
}
}
@ -145,7 +145,7 @@ void DisplayServerWeb::request_quit_callback() {
void DisplayServerWeb::_request_quit_callback() {
DisplayServerWeb *ds = get_singleton();
if (ds && ds->window_event_callback.is_valid()) {
Variant event = int(DisplayServer::WINDOW_EVENT_CLOSE_REQUEST);
Variant event = int(DisplayServerEnums::WINDOW_EVENT_CLOSE_REQUEST);
ds->window_event_callback.call(event);
}
}
@ -351,41 +351,41 @@ void DisplayServerWeb::_mouse_move_callback(double p_x, double p_y, double p_rel
}
// Cursor
const char *DisplayServerWeb::godot2dom_cursor(DisplayServer::CursorShape p_shape) {
const char *DisplayServerWeb::godot2dom_cursor(DisplayServerEnums::CursorShape p_shape) {
switch (p_shape) {
case DisplayServer::CURSOR_ARROW:
case DisplayServerEnums::CURSOR_ARROW:
return "default";
case DisplayServer::CURSOR_IBEAM:
case DisplayServerEnums::CURSOR_IBEAM:
return "text";
case DisplayServer::CURSOR_POINTING_HAND:
case DisplayServerEnums::CURSOR_POINTING_HAND:
return "pointer";
case DisplayServer::CURSOR_CROSS:
case DisplayServerEnums::CURSOR_CROSS:
return "crosshair";
case DisplayServer::CURSOR_WAIT:
case DisplayServerEnums::CURSOR_WAIT:
return "wait";
case DisplayServer::CURSOR_BUSY:
case DisplayServerEnums::CURSOR_BUSY:
return "progress";
case DisplayServer::CURSOR_DRAG:
case DisplayServerEnums::CURSOR_DRAG:
return "grab";
case DisplayServer::CURSOR_CAN_DROP:
case DisplayServerEnums::CURSOR_CAN_DROP:
return "grabbing";
case DisplayServer::CURSOR_FORBIDDEN:
case DisplayServerEnums::CURSOR_FORBIDDEN:
return "no-drop";
case DisplayServer::CURSOR_VSIZE:
case DisplayServerEnums::CURSOR_VSIZE:
return "ns-resize";
case DisplayServer::CURSOR_HSIZE:
case DisplayServerEnums::CURSOR_HSIZE:
return "ew-resize";
case DisplayServer::CURSOR_BDIAGSIZE:
case DisplayServerEnums::CURSOR_BDIAGSIZE:
return "nesw-resize";
case DisplayServer::CURSOR_FDIAGSIZE:
case DisplayServerEnums::CURSOR_FDIAGSIZE:
return "nwse-resize";
case DisplayServer::CURSOR_MOVE:
case DisplayServerEnums::CURSOR_MOVE:
return "move";
case DisplayServer::CURSOR_VSPLIT:
case DisplayServerEnums::CURSOR_VSPLIT:
return "row-resize";
case DisplayServer::CURSOR_HSPLIT:
case DisplayServerEnums::CURSOR_HSPLIT:
return "col-resize";
case DisplayServer::CURSOR_HELP:
case DisplayServerEnums::CURSOR_HELP:
return "help";
default:
return "default";
@ -441,7 +441,7 @@ void DisplayServerWeb::tts_speak(const String &p_text, const String &p_voice, in
}
if (p_text.is_empty()) {
tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, p_utterance_id);
tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, p_utterance_id);
return;
}
@ -461,7 +461,7 @@ void DisplayServerWeb::tts_resume() {
void DisplayServerWeb::tts_stop() {
for (const KeyValue<int64_t, CharString> &E : utterance_ids) {
tts_post_utterance_event(DisplayServer::TTS_UTTERANCE_CANCELED, E.key);
tts_post_utterance_event(DisplayServerEnums::TTS_UTTERANCE_CANCELED, E.key);
}
utterance_ids.clear();
godot_js_tts_stop();
@ -482,7 +482,7 @@ void DisplayServerWeb::_js_utterance_callback(int p_event, int64_t p_id, int p_p
DisplayServerWeb *ds = (DisplayServerWeb *)DisplayServer::get_singleton();
if (ds->utterance_ids.has(p_id)) {
int pos = 0;
if ((TTSUtteranceEvent)p_event == DisplayServer::TTS_UTTERANCE_BOUNDARY) {
if ((DisplayServerEnums::TTSUtteranceEvent)p_event == DisplayServerEnums::TTS_UTTERANCE_BOUNDARY) {
// Convert position from UTF-8 to UTF-32.
const CharString &string = ds->utterance_ids[p_id];
for (int i = 0; i < MIN(p_pos, string.length()); i++) {
@ -496,15 +496,15 @@ void DisplayServerWeb::_js_utterance_callback(int p_event, int64_t p_id, int p_p
}
pos++;
}
} else if ((TTSUtteranceEvent)p_event != DisplayServer::TTS_UTTERANCE_STARTED) {
} else if ((DisplayServerEnums::TTSUtteranceEvent)p_event != DisplayServerEnums::TTS_UTTERANCE_STARTED) {
ds->utterance_ids.erase(p_id);
}
ds->tts_post_utterance_event((TTSUtteranceEvent)p_event, p_id, pos);
ds->tts_post_utterance_event((DisplayServerEnums::TTSUtteranceEvent)p_event, p_id, pos);
}
}
void DisplayServerWeb::cursor_set_shape(CursorShape p_shape) {
ERR_FAIL_INDEX(p_shape, CURSOR_MAX);
void DisplayServerWeb::cursor_set_shape(DisplayServerEnums::CursorShape p_shape) {
ERR_FAIL_INDEX(p_shape, DisplayServerEnums::CURSOR_MAX);
if (cursor_shape == p_shape) {
return;
}
@ -512,12 +512,12 @@ void DisplayServerWeb::cursor_set_shape(CursorShape p_shape) {
godot_js_display_cursor_set_shape(godot2dom_cursor(cursor_shape));
}
DisplayServer::CursorShape DisplayServerWeb::cursor_get_shape() const {
DisplayServerEnums::CursorShape DisplayServerWeb::cursor_get_shape() const {
return cursor_shape;
}
void DisplayServerWeb::cursor_set_custom_image(const Ref<Resource> &p_cursor, CursorShape p_shape, const Vector2 &p_hotspot) {
ERR_FAIL_INDEX(p_shape, CURSOR_MAX);
void DisplayServerWeb::cursor_set_custom_image(const Ref<Resource> &p_cursor, DisplayServerEnums::CursorShape p_shape, const Vector2 &p_hotspot) {
ERR_FAIL_INDEX(p_shape, DisplayServerEnums::CURSOR_MAX);
if (p_cursor.is_valid()) {
Ref<Image> image = _get_cursor_image_from_resource(p_cursor, p_hotspot);
ERR_FAIL_COND(image.is_null());
@ -553,31 +553,31 @@ void DisplayServerWeb::cursor_set_custom_image(const Ref<Resource> &p_cursor, Cu
// Mouse mode
void DisplayServerWeb::_mouse_update_mode() {
MouseMode wanted_mouse_mode = mouse_mode_override_enabled
DisplayServerEnums::MouseMode wanted_mouse_mode = mouse_mode_override_enabled
? mouse_mode_override
: mouse_mode_base;
ERR_FAIL_COND_MSG(wanted_mouse_mode == MOUSE_MODE_CONFINED || wanted_mouse_mode == MOUSE_MODE_CONFINED_HIDDEN, "MOUSE_MODE_CONFINED is not supported for the Web platform.");
ERR_FAIL_COND_MSG(wanted_mouse_mode == DisplayServerEnums::MOUSE_MODE_CONFINED || wanted_mouse_mode == DisplayServerEnums::MOUSE_MODE_CONFINED_HIDDEN, "DisplayServerEnums::MOUSE_MODE_CONFINED is not supported for the Web platform.");
if (wanted_mouse_mode == mouse_get_mode()) {
return;
}
if (wanted_mouse_mode == MOUSE_MODE_VISIBLE) {
if (wanted_mouse_mode == DisplayServerEnums::MOUSE_MODE_VISIBLE) {
godot_js_display_cursor_set_visible(1);
godot_js_display_cursor_lock_set(0);
} else if (wanted_mouse_mode == MOUSE_MODE_HIDDEN) {
} else if (wanted_mouse_mode == DisplayServerEnums::MOUSE_MODE_HIDDEN) {
godot_js_display_cursor_set_visible(0);
godot_js_display_cursor_lock_set(0);
} else if (wanted_mouse_mode == MOUSE_MODE_CAPTURED) {
} else if (wanted_mouse_mode == DisplayServerEnums::MOUSE_MODE_CAPTURED) {
godot_js_display_cursor_set_visible(1);
godot_js_display_cursor_lock_set(1);
}
}
void DisplayServerWeb::mouse_set_mode(MouseMode p_mode) {
ERR_FAIL_INDEX(p_mode, MouseMode::MOUSE_MODE_MAX);
void DisplayServerWeb::mouse_set_mode(DisplayServerEnums::MouseMode p_mode) {
ERR_FAIL_INDEX(p_mode, DisplayServerEnums::MouseMode::MOUSE_MODE_MAX);
if (mouse_mode_override_enabled) {
mouse_mode_base = p_mode;
@ -593,19 +593,19 @@ void DisplayServerWeb::mouse_set_mode(MouseMode p_mode) {
_mouse_update_mode();
}
DisplayServer::MouseMode DisplayServerWeb::mouse_get_mode() const {
DisplayServerEnums::MouseMode DisplayServerWeb::mouse_get_mode() const {
if (godot_js_display_cursor_is_hidden()) {
return MOUSE_MODE_HIDDEN;
return DisplayServerEnums::MOUSE_MODE_HIDDEN;
}
if (godot_js_display_cursor_is_locked()) {
return MOUSE_MODE_CAPTURED;
return DisplayServerEnums::MOUSE_MODE_CAPTURED;
}
return MOUSE_MODE_VISIBLE;
return DisplayServerEnums::MOUSE_MODE_VISIBLE;
}
void DisplayServerWeb::mouse_set_mode_override(MouseMode p_mode) {
ERR_FAIL_INDEX(p_mode, MouseMode::MOUSE_MODE_MAX);
void DisplayServerWeb::mouse_set_mode_override(DisplayServerEnums::MouseMode p_mode) {
ERR_FAIL_INDEX(p_mode, DisplayServerEnums::MouseMode::MOUSE_MODE_MAX);
if (!mouse_mode_override_enabled) {
mouse_mode_override = p_mode;
@ -621,7 +621,7 @@ void DisplayServerWeb::mouse_set_mode_override(MouseMode p_mode) {
_mouse_update_mode();
}
DisplayServer::MouseMode DisplayServerWeb::mouse_get_mode_override() const {
DisplayServerEnums::MouseMode DisplayServerWeb::mouse_get_mode_override() const {
return mouse_mode_override;
}
@ -821,7 +821,7 @@ void DisplayServerWeb::_vk_input_text_callback(const String &p_text, int p_curso
}
}
void DisplayServerWeb::virtual_keyboard_show(const String &p_existing_text, const Rect2 &p_screen_rect, VirtualKeyboardType p_type, int p_max_input_length, int p_cursor_start, int p_cursor_end) {
void DisplayServerWeb::virtual_keyboard_show(const String &p_existing_text, const Rect2 &p_screen_rect, DisplayServerEnums::VirtualKeyboardType p_type, int p_max_input_length, int p_cursor_start, int p_cursor_end) {
godot_js_display_vk_show(p_existing_text.utf8().get_data(), p_type, p_cursor_start, p_cursor_end);
}
@ -954,12 +954,12 @@ void DisplayServerWeb::_ime_callback(int p_type, const String &p_text) {
Input::get_singleton()->flush_buffered_events();
}
void DisplayServerWeb::window_set_ime_active(const bool p_active, WindowID p_window) {
void DisplayServerWeb::window_set_ime_active(const bool p_active, DisplayServerEnums::WindowID p_window) {
ime_active = p_active;
godot_js_set_ime_active(p_active);
}
void DisplayServerWeb::window_set_ime_position(const Point2i &p_pos, WindowID p_window) {
void DisplayServerWeb::window_set_ime_position(const Point2i &p_pos, DisplayServerEnums::WindowID p_window) {
godot_js_set_ime_position(p_pos.x, p_pos.y);
}
@ -1054,10 +1054,10 @@ void DisplayServerWeb::_send_window_event_callback(int p_notification) {
if (!ds) {
return;
}
if (p_notification == DisplayServer::WINDOW_EVENT_MOUSE_ENTER || p_notification == DisplayServer::WINDOW_EVENT_MOUSE_EXIT) {
ds->cursor_inside_canvas = p_notification == DisplayServer::WINDOW_EVENT_MOUSE_ENTER;
if (p_notification == DisplayServerEnums::WINDOW_EVENT_MOUSE_ENTER || p_notification == DisplayServerEnums::WINDOW_EVENT_MOUSE_EXIT) {
ds->cursor_inside_canvas = p_notification == DisplayServerEnums::WINDOW_EVENT_MOUSE_ENTER;
}
if (godot_js_is_ime_focused() && (p_notification == DisplayServer::WINDOW_EVENT_FOCUS_IN || p_notification == DisplayServer::WINDOW_EVENT_FOCUS_OUT)) {
if (godot_js_is_ime_focused() && (p_notification == DisplayServerEnums::WINDOW_EVENT_FOCUS_IN || p_notification == DisplayServerEnums::WINDOW_EVENT_FOCUS_OUT)) {
return;
}
if (ds->window_event_callback.is_valid()) {
@ -1110,11 +1110,11 @@ void DisplayServerWeb::_dispatch_input_event(const Ref<InputEvent> &p_event) {
}
}
DisplayServer *DisplayServerWeb::create_func(const String &p_rendering_driver, WindowMode p_window_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Point2i *p_position, const Size2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error) {
DisplayServer *DisplayServerWeb::create_func(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_window_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Point2i *p_position, const Size2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error) {
return memnew(DisplayServerWeb(p_rendering_driver, p_window_mode, p_vsync_mode, p_flags, p_position, p_resolution, p_screen, p_context, p_parent_window, r_error));
}
DisplayServerWeb::DisplayServerWeb(const String &p_rendering_driver, WindowMode p_window_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Point2i *p_position, const Size2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error) {
DisplayServerWeb::DisplayServerWeb(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_window_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Point2i *p_position, const Size2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error) {
r_error = OK; // Always succeeds for now.
native_menu = memnew(NativeMenu); // Dummy native menu.
@ -1123,7 +1123,7 @@ DisplayServerWeb::DisplayServerWeb(const String &p_rendering_driver, WindowMode
godot_js_config_canvas_id_get(canvas_id, 256);
// Handle contextmenu, webglcontextlost
godot_js_display_setup_canvas(p_resolution.x, p_resolution.y, (p_window_mode == WINDOW_MODE_FULLSCREEN || p_window_mode == WINDOW_MODE_EXCLUSIVE_FULLSCREEN), OS::get_singleton()->is_hidpi_allowed() ? 1 : 0);
godot_js_display_setup_canvas(p_resolution.x, p_resolution.y, (p_window_mode == DisplayServerEnums::WINDOW_MODE_FULLSCREEN || p_window_mode == DisplayServerEnums::WINDOW_MODE_EXCLUSIVE_FULLSCREEN), OS::get_singleton()->is_hidpi_allowed() ? 1 : 0);
// Check if it's windows.
swap_cancel_ok = godot_js_display_is_swap_ok_cancel() == 1;
@ -1176,10 +1176,10 @@ DisplayServerWeb::DisplayServerWeb(const String &p_rendering_driver, WindowMode
godot_js_display_fullscreen_cb(&DisplayServerWeb::fullscreen_change_callback);
godot_js_display_window_blur_cb(&DisplayServerWeb::window_blur_callback);
godot_js_display_notification_cb(&DisplayServerWeb::send_window_event_callback,
WINDOW_EVENT_MOUSE_ENTER,
WINDOW_EVENT_MOUSE_EXIT,
WINDOW_EVENT_FOCUS_IN,
WINDOW_EVENT_FOCUS_OUT);
DisplayServerEnums::WINDOW_EVENT_MOUSE_ENTER,
DisplayServerEnums::WINDOW_EVENT_MOUSE_EXIT,
DisplayServerEnums::WINDOW_EVENT_FOCUS_IN,
DisplayServerEnums::WINDOW_EVENT_FOCUS_OUT);
godot_js_display_vk_cb(&DisplayServerWeb::vk_input_text_callback);
Input::get_singleton()->set_event_dispatch_function(_dispatch_input_event);
@ -1198,37 +1198,37 @@ DisplayServerWeb::~DisplayServerWeb() {
#endif
}
bool DisplayServerWeb::has_feature(Feature p_feature) const {
bool DisplayServerWeb::has_feature(DisplayServerEnums::Feature p_feature) const {
switch (p_feature) {
#ifndef DISABLE_DEPRECATED
case FEATURE_GLOBAL_MENU: {
case DisplayServerEnums::FEATURE_GLOBAL_MENU: {
return (native_menu && native_menu->has_feature(NativeMenu::FEATURE_GLOBAL_MENU));
} break;
#endif
//case FEATURE_HIDPI:
case FEATURE_ICON:
case FEATURE_CLIPBOARD:
case FEATURE_CURSOR_SHAPE:
case FEATURE_CUSTOM_CURSOR_SHAPE:
case FEATURE_MOUSE:
case FEATURE_TOUCHSCREEN:
//case DisplayServerEnums::FEATURE_HIDPI:
case DisplayServerEnums::FEATURE_ICON:
case DisplayServerEnums::FEATURE_CLIPBOARD:
case DisplayServerEnums::FEATURE_CURSOR_SHAPE:
case DisplayServerEnums::FEATURE_CUSTOM_CURSOR_SHAPE:
case DisplayServerEnums::FEATURE_MOUSE:
case DisplayServerEnums::FEATURE_TOUCHSCREEN:
return true;
//case FEATURE_MOUSE_WARP:
//case FEATURE_NATIVE_DIALOG:
//case FEATURE_NATIVE_DIALOG_INPUT:
//case FEATURE_NATIVE_DIALOG_FILE:
//case FEATURE_NATIVE_DIALOG_FILE_EXTRA:
//case FEATURE_NATIVE_DIALOG_FILE_MIME:
//case FEATURE_NATIVE_ICON:
//case FEATURE_WINDOW_TRANSPARENCY:
//case FEATURE_KEEP_SCREEN_ON:
//case FEATURE_ORIENTATION:
case FEATURE_IME:
//case DisplayServerEnums::FEATURE_MOUSE_WARP:
//case DisplayServerEnums::FEATURE_NATIVE_DIALOG:
//case DisplayServerEnums::FEATURE_NATIVE_DIALOG_INPUT:
//case DisplayServerEnums::FEATURE_NATIVE_DIALOG_FILE:
//case DisplayServerEnums::FEATURE_NATIVE_DIALOG_FILE_EXTRA:
//case DisplayServerEnums::FEATURE_NATIVE_DIALOG_FILE_MIME:
//case DisplayServerEnums::FEATURE_NATIVE_ICON:
//case DisplayServerEnums::FEATURE_WINDOW_TRANSPARENCY:
//case DisplayServerEnums::FEATURE_KEEP_SCREEN_ON:
//case DisplayServerEnums::FEATURE_ORIENTATION:
case DisplayServerEnums::FEATURE_IME:
// IME does not work with experimental VK support.
return godot_js_display_vk_available() == 0;
case FEATURE_VIRTUAL_KEYBOARD:
case DisplayServerEnums::FEATURE_VIRTUAL_KEYBOARD:
return godot_js_display_vk_available() != 0;
case FEATURE_TEXT_TO_SPEECH:
case DisplayServerEnums::FEATURE_TEXT_TO_SPEECH:
return godot_js_display_tts_available() != 0;
default:
return false;
@ -1303,158 +1303,158 @@ float DisplayServerWeb::screen_get_refresh_rate(int p_screen) const {
return SCREEN_REFRESH_RATE_FALLBACK; // Web doesn't have much of a need for the screen refresh rate, and there's no native way to do so.
}
Vector<DisplayServer::WindowID> DisplayServerWeb::get_window_list() const {
Vector<WindowID> ret;
ret.push_back(MAIN_WINDOW_ID);
Vector<DisplayServerEnums::WindowID> DisplayServerWeb::get_window_list() const {
Vector<DisplayServerEnums::WindowID> ret;
ret.push_back(DisplayServerEnums::MAIN_WINDOW_ID);
return ret;
}
DisplayServerWeb::WindowID DisplayServerWeb::get_window_at_screen_position(const Point2i &p_position) const {
return MAIN_WINDOW_ID;
DisplayServerEnums::WindowID DisplayServerWeb::get_window_at_screen_position(const Point2i &p_position) const {
return DisplayServerEnums::MAIN_WINDOW_ID;
}
void DisplayServerWeb::window_attach_instance_id(ObjectID p_instance, WindowID p_window) {
void DisplayServerWeb::window_attach_instance_id(ObjectID p_instance, DisplayServerEnums::WindowID p_window) {
window_attached_instance_id = p_instance;
}
ObjectID DisplayServerWeb::window_get_attached_instance_id(WindowID p_window) const {
ObjectID DisplayServerWeb::window_get_attached_instance_id(DisplayServerEnums::WindowID p_window) const {
return window_attached_instance_id;
}
void DisplayServerWeb::window_set_rect_changed_callback(const Callable &p_callable, WindowID p_window) {
void DisplayServerWeb::window_set_rect_changed_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
rect_changed_callback = p_callable;
}
void DisplayServerWeb::window_set_window_event_callback(const Callable &p_callable, WindowID p_window) {
void DisplayServerWeb::window_set_window_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
window_event_callback = p_callable;
}
void DisplayServerWeb::window_set_input_event_callback(const Callable &p_callable, WindowID p_window) {
void DisplayServerWeb::window_set_input_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
input_event_callback = p_callable;
}
void DisplayServerWeb::window_set_input_text_callback(const Callable &p_callable, WindowID p_window) {
void DisplayServerWeb::window_set_input_text_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
input_text_callback = p_callable;
}
void DisplayServerWeb::window_set_drop_files_callback(const Callable &p_callable, WindowID p_window) {
void DisplayServerWeb::window_set_drop_files_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window) {
drop_files_callback = p_callable;
}
void DisplayServerWeb::window_set_title(const String &p_title, WindowID p_window) {
void DisplayServerWeb::window_set_title(const String &p_title, DisplayServerEnums::WindowID p_window) {
godot_js_display_window_title_set(p_title.utf8().get_data());
}
int DisplayServerWeb::window_get_current_screen(WindowID p_window) const {
ERR_FAIL_COND_V(p_window != MAIN_WINDOW_ID, INVALID_SCREEN);
int DisplayServerWeb::window_get_current_screen(DisplayServerEnums::WindowID p_window) const {
ERR_FAIL_COND_V(p_window != DisplayServerEnums::MAIN_WINDOW_ID, DisplayServerEnums::INVALID_SCREEN);
return 0;
}
void DisplayServerWeb::window_set_current_screen(int p_screen, WindowID p_window) {
void DisplayServerWeb::window_set_current_screen(int p_screen, DisplayServerEnums::WindowID p_window) {
// Not implemented.
}
Point2i DisplayServerWeb::window_get_position(WindowID p_window) const {
Point2i DisplayServerWeb::window_get_position(DisplayServerEnums::WindowID p_window) const {
return Point2i();
}
Point2i DisplayServerWeb::window_get_position_with_decorations(WindowID p_window) const {
Point2i DisplayServerWeb::window_get_position_with_decorations(DisplayServerEnums::WindowID p_window) const {
return Point2i();
}
void DisplayServerWeb::window_set_position(const Point2i &p_position, WindowID p_window) {
void DisplayServerWeb::window_set_position(const Point2i &p_position, DisplayServerEnums::WindowID p_window) {
// Not supported.
}
void DisplayServerWeb::window_set_transient(WindowID p_window, WindowID p_parent) {
void DisplayServerWeb::window_set_transient(DisplayServerEnums::WindowID p_window, DisplayServerEnums::WindowID p_parent) {
// Not supported.
}
void DisplayServerWeb::window_set_max_size(const Size2i p_size, WindowID p_window) {
void DisplayServerWeb::window_set_max_size(const Size2i p_size, DisplayServerEnums::WindowID p_window) {
// Not supported.
}
Size2i DisplayServerWeb::window_get_max_size(WindowID p_window) const {
Size2i DisplayServerWeb::window_get_max_size(DisplayServerEnums::WindowID p_window) const {
return Size2i();
}
void DisplayServerWeb::window_set_min_size(const Size2i p_size, WindowID p_window) {
void DisplayServerWeb::window_set_min_size(const Size2i p_size, DisplayServerEnums::WindowID p_window) {
// Not supported.
}
Size2i DisplayServerWeb::window_get_min_size(WindowID p_window) const {
Size2i DisplayServerWeb::window_get_min_size(DisplayServerEnums::WindowID p_window) const {
return Size2i();
}
void DisplayServerWeb::window_set_size(const Size2i p_size, WindowID p_window) {
void DisplayServerWeb::window_set_size(const Size2i p_size, DisplayServerEnums::WindowID p_window) {
godot_js_display_desired_size_set(p_size.x, p_size.y);
}
Size2i DisplayServerWeb::window_get_size(WindowID p_window) const {
Size2i DisplayServerWeb::window_get_size(DisplayServerEnums::WindowID p_window) const {
int size[2];
godot_js_display_window_size_get(size, size + 1);
return Size2i(size[0], size[1]);
}
Size2i DisplayServerWeb::window_get_size_with_decorations(WindowID p_window) const {
Size2i DisplayServerWeb::window_get_size_with_decorations(DisplayServerEnums::WindowID p_window) const {
return window_get_size(p_window);
}
void DisplayServerWeb::window_set_mode(WindowMode p_mode, WindowID p_window) {
void DisplayServerWeb::window_set_mode(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::WindowID p_window) {
if (window_mode == p_mode) {
return;
}
switch (p_mode) {
case WINDOW_MODE_WINDOWED: {
if (window_mode == WINDOW_MODE_FULLSCREEN) {
case DisplayServerEnums::WINDOW_MODE_WINDOWED: {
if (window_mode == DisplayServerEnums::WINDOW_MODE_FULLSCREEN) {
godot_js_display_fullscreen_exit();
}
window_mode = WINDOW_MODE_WINDOWED;
window_mode = DisplayServerEnums::WINDOW_MODE_WINDOWED;
} break;
case WINDOW_MODE_EXCLUSIVE_FULLSCREEN:
case WINDOW_MODE_FULLSCREEN: {
case DisplayServerEnums::WINDOW_MODE_EXCLUSIVE_FULLSCREEN:
case DisplayServerEnums::WINDOW_MODE_FULLSCREEN: {
int result = godot_js_display_fullscreen_request();
ERR_FAIL_COND_MSG(result, "The request was denied. Remember that enabling fullscreen is only possible from an input callback for the Web platform.");
} break;
case WINDOW_MODE_MAXIMIZED:
case WINDOW_MODE_MINIMIZED:
// WindowMode MAXIMIZED and MINIMIZED are not supported in Web platform.
case DisplayServerEnums::WINDOW_MODE_MAXIMIZED:
case DisplayServerEnums::WINDOW_MODE_MINIMIZED:
// DisplayServerEnums::WindowMode MAXIMIZED and MINIMIZED are not supported in Web platform.
break;
default:
break;
}
}
DisplayServerWeb::WindowMode DisplayServerWeb::window_get_mode(WindowID p_window) const {
DisplayServerEnums::WindowMode DisplayServerWeb::window_get_mode(DisplayServerEnums::WindowID p_window) const {
return window_mode;
}
bool DisplayServerWeb::window_is_maximize_allowed(WindowID p_window) const {
bool DisplayServerWeb::window_is_maximize_allowed(DisplayServerEnums::WindowID p_window) const {
return false;
}
void DisplayServerWeb::window_set_flag(WindowFlags p_flag, bool p_enabled, WindowID p_window) {
void DisplayServerWeb::window_set_flag(DisplayServerEnums::WindowFlags p_flag, bool p_enabled, DisplayServerEnums::WindowID p_window) {
// Not supported.
}
bool DisplayServerWeb::window_get_flag(WindowFlags p_flag, WindowID p_window) const {
bool DisplayServerWeb::window_get_flag(DisplayServerEnums::WindowFlags p_flag, DisplayServerEnums::WindowID p_window) const {
return false;
}
void DisplayServerWeb::window_request_attention(WindowID p_window) {
void DisplayServerWeb::window_request_attention(DisplayServerEnums::WindowID p_window) {
// Not supported.
}
void DisplayServerWeb::window_move_to_foreground(WindowID p_window) {
void DisplayServerWeb::window_move_to_foreground(DisplayServerEnums::WindowID p_window) {
// Not supported.
}
bool DisplayServerWeb::window_is_focused(WindowID p_window) const {
bool DisplayServerWeb::window_is_focused(DisplayServerEnums::WindowID p_window) const {
return true;
}
bool DisplayServerWeb::window_can_draw(WindowID p_window) const {
bool DisplayServerWeb::window_can_draw(DisplayServerEnums::WindowID p_window) const {
return true;
}
@ -1462,8 +1462,8 @@ bool DisplayServerWeb::can_any_window_draw() const {
return true;
}
DisplayServer::VSyncMode DisplayServerWeb::window_get_vsync_mode(WindowID p_vsync_mode) const {
return DisplayServer::VSYNC_ENABLED;
DisplayServerEnums::VSyncMode DisplayServerWeb::window_get_vsync_mode(DisplayServerEnums::WindowID p_vsync_mode) const {
return DisplayServerEnums::VSYNC_ENABLED;
}
void DisplayServerWeb::process_events() {

116
platform/web/display_server_web.h
View file

@ -66,7 +66,7 @@ private:
HashMap<int64_t, CharString> utterance_ids;
WindowMode window_mode = WINDOW_MODE_WINDOWED;
DisplayServerEnums::WindowMode window_mode = DisplayServerEnums::WINDOW_MODE_WINDOWED;
ObjectID window_attached_instance_id = {};
Callable rect_changed_callback;
@ -82,7 +82,7 @@ private:
char canvas_id[256] = { 0 };
bool cursor_inside_canvas = true;
CursorShape cursor_shape = CURSOR_ARROW;
DisplayServerEnums::CursorShape cursor_shape = DisplayServerEnums::CURSOR_ARROW;
Point2i last_click_pos = Point2(-100, -100); // TODO check this again.
uint64_t last_click_ms = 0;
MouseButton last_click_button_index = MouseButton::NONE;
@ -112,14 +112,14 @@ private:
int gamepad_count = 0;
MouseMode mouse_mode_base = MOUSE_MODE_VISIBLE;
MouseMode mouse_mode_override = MOUSE_MODE_VISIBLE;
DisplayServerEnums::MouseMode mouse_mode_base = DisplayServerEnums::MOUSE_MODE_VISIBLE;
DisplayServerEnums::MouseMode mouse_mode_override = DisplayServerEnums::MOUSE_MODE_VISIBLE;
bool mouse_mode_override_enabled = false;
void _mouse_update_mode();
// utilities
static void dom2godot_mod(Ref<InputEventWithModifiers> ev, int p_mod, Key p_keycode);
static const char *godot2dom_cursor(DisplayServer::CursorShape p_shape);
static const char *godot2dom_cursor(DisplayServerEnums::CursorShape p_shape);
// events
WASM_EXPORT static void fullscreen_change_callback(int p_fullscreen);
@ -159,7 +159,7 @@ private:
void process_keys();
static Vector<String> get_rendering_drivers_func();
static DisplayServer *create_func(const String &p_rendering_driver, WindowMode p_window_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error);
static DisplayServer *create_func(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_window_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Vector2i *p_position, const Vector2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
static void _dispatch_input_event(const Ref<InputEvent> &p_event);
@ -174,7 +174,7 @@ public:
bool check_size_force_redraw();
// from DisplayServer
virtual bool has_feature(Feature p_feature) const override;
virtual bool has_feature(DisplayServerEnums::Feature p_feature) const override;
virtual String get_name() const override;
// tts
@ -188,23 +188,23 @@ public:
virtual void tts_stop() override;
// cursor
virtual void cursor_set_shape(CursorShape p_shape) override;
virtual CursorShape cursor_get_shape() const override;
virtual void cursor_set_custom_image(const Ref<Resource> &p_cursor, CursorShape p_shape = CURSOR_ARROW, const Vector2 &p_hotspot = Vector2()) override;
virtual void cursor_set_shape(DisplayServerEnums::CursorShape p_shape) override;
virtual DisplayServerEnums::CursorShape cursor_get_shape() const override;
virtual void cursor_set_custom_image(const Ref<Resource> &p_cursor, DisplayServerEnums::CursorShape p_shape = DisplayServerEnums::CURSOR_ARROW, const Vector2 &p_hotspot = Vector2()) override;
// mouse
virtual void mouse_set_mode(MouseMode p_mode) override;
virtual MouseMode mouse_get_mode() const override;
virtual void mouse_set_mode_override(MouseMode p_mode) override;
virtual MouseMode mouse_get_mode_override() const override;
virtual void mouse_set_mode(DisplayServerEnums::MouseMode p_mode) override;
virtual DisplayServerEnums::MouseMode mouse_get_mode() const override;
virtual void mouse_set_mode_override(DisplayServerEnums::MouseMode p_mode) override;
virtual DisplayServerEnums::MouseMode mouse_get_mode_override() const override;
virtual void mouse_set_mode_override_enabled(bool p_override_enabled) override;
virtual bool mouse_is_mode_override_enabled() const override;
virtual Point2i mouse_get_position() const override;
// ime
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;
virtual void window_set_ime_active(const bool p_active, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_ime_position(const Point2i &p_pos, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Point2i ime_get_selection() const override;
virtual String ime_get_text() const override;
@ -219,71 +219,71 @@ public:
// screen
virtual int get_screen_count() const override;
virtual int get_primary_screen() const override;
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;
virtual float screen_get_scale(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_refresh_rate(int p_screen = SCREEN_OF_MAIN_WINDOW) const override;
virtual Point2i screen_get_position(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Size2i screen_get_size(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual Rect2i screen_get_usable_rect(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual int screen_get_dpi(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_scale(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual float screen_get_refresh_rate(int p_screen = DisplayServerEnums::SCREEN_OF_MAIN_WINDOW) const override;
virtual void screen_set_keep_on(bool p_enable) override {}
virtual void virtual_keyboard_show(const String &p_existing_text, const Rect2 &p_screen_rect = Rect2(), VirtualKeyboardType p_type = KEYBOARD_TYPE_DEFAULT, int p_max_input_length = -1, int p_cursor_start = -1, int p_cursor_end = -1) override;
virtual void virtual_keyboard_show(const String &p_existing_text, const Rect2 &p_screen_rect = Rect2(), DisplayServerEnums::VirtualKeyboardType p_type = DisplayServerEnums::KEYBOARD_TYPE_DEFAULT, int p_max_input_length = -1, int p_cursor_start = -1, int p_cursor_end = -1) override;
virtual void virtual_keyboard_hide() override;
// windows
virtual Vector<DisplayServer::WindowID> get_window_list() const override;
virtual WindowID get_window_at_screen_position(const Point2i &p_position) const override;
virtual Vector<DisplayServerEnums::WindowID> get_window_list() const override;
virtual DisplayServerEnums::WindowID get_window_at_screen_position(const Point2i &p_position) const override;
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;
virtual void window_attach_instance_id(ObjectID p_instance, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual ObjectID window_get_attached_instance_id(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_rect_changed_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_rect_changed_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::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_window_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_input_event_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_input_text_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_drop_files_callback(const Callable &p_callable, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_drop_files_callback(const Callable &p_callable, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_title(const String &p_title, WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_set_title(const String &p_title, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
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;
virtual int window_get_current_screen(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_current_screen(int p_screen, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Point2i window_get_position(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual Point2i window_get_position_with_decorations(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_position(const Point2i &p_position, WindowID p_window = MAIN_WINDOW_ID) override;
virtual Point2i window_get_position(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual Point2i window_get_position_with_decorations(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_set_position(const Point2i &p_position, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_set_transient(WindowID p_window, WindowID p_parent) override;
virtual void window_set_transient(DisplayServerEnums::WindowID p_window, DisplayServerEnums::WindowID p_parent) override;
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;
virtual void window_set_max_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_max_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_min_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_min_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual Size2i window_get_size_with_decorations(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_set_size(const Size2i p_size, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual Size2i window_get_size(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual Size2i window_get_size_with_decorations(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_mode(DisplayServerEnums::WindowMode p_mode, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual DisplayServerEnums::WindowMode window_get_mode(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool window_is_maximize_allowed(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual bool window_is_maximize_allowed(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
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;
virtual void window_set_flag(DisplayServerEnums::WindowFlags p_flag, bool p_enabled, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_get_flag(DisplayServerEnums::WindowFlags p_flag, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual void window_request_attention(WindowID p_window = MAIN_WINDOW_ID) override;
virtual void window_move_to_foreground(WindowID p_window = MAIN_WINDOW_ID) override;
virtual bool window_is_focused(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual void window_request_attention(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual void window_move_to_foreground(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override;
virtual bool window_is_focused(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool window_can_draw(WindowID p_window = MAIN_WINDOW_ID) const override;
virtual bool window_can_draw(DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) const override;
virtual bool can_any_window_draw() const override;
virtual void window_set_vsync_mode(VSyncMode p_vsync_mode, WindowID p_window = MAIN_WINDOW_ID) override {}
virtual DisplayServer::VSyncMode window_get_vsync_mode(WindowID p_vsync_mode) const override;
virtual void window_set_vsync_mode(DisplayServerEnums::VSyncMode p_vsync_mode, DisplayServerEnums::WindowID p_window = DisplayServerEnums::MAIN_WINDOW_ID) override {}
virtual DisplayServerEnums::VSyncMode window_get_vsync_mode(DisplayServerEnums::WindowID p_vsync_mode) const override;
// events
virtual void process_events() override;
@ -296,6 +296,6 @@ public:
virtual void swap_buffers() override;
static void register_web_driver();
DisplayServerWeb(const String &p_rendering_driver, WindowMode p_window_mode, VSyncMode p_vsync_mode, uint32_t p_flags, const Point2i *p_position, const Size2i &p_resolution, int p_screen, Context p_context, int64_t p_parent_window, Error &r_error);
DisplayServerWeb(const String &p_rendering_driver, DisplayServerEnums::WindowMode p_window_mode, DisplayServerEnums::VSyncMode p_vsync_mode, uint32_t p_flags, const Point2i *p_position, const Size2i &p_resolution, int p_screen, DisplayServerEnums::Context p_context, int64_t p_parent_window, Error &r_error);
~DisplayServerWeb();
};

Some files were not shown because too many files have changed in this diff Show more