seedlingattempt/godot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #104907 from bruvzg/scr_ids

Browse Source 
Cleanup and unify `DisplayServer` screen methods and documentation.
This commit is contained in:
Thaddeus Crews
2025-06-02 18:51:45 -05:00
parent ae81b9f21f 2d93e004b9
commit 12b97c250d
14 changed files with 276 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
platform/android/display_server_android.cpp
View File

@ -264,6 +264,10 @@ bool DisplayServerAndroid::screen_is_kept_on() const {
}
void DisplayServerAndroid::screen_set_orientation(DisplayServer::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);
GodotIOJavaWrapper *godot_io_java = OS_Android::get_singleton()->get_godot_io_java();
ERR_FAIL_NULL(godot_io_java);
@ -271,6 +275,10 @@ void DisplayServerAndroid::screen_set_orientation(DisplayServer::ScreenOrientati
}
DisplayServer::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);
GodotIOJavaWrapper *godot_io_java = OS_Android::get_singleton()->get_godot_io_java();
ERR_FAIL_NULL_V(godot_io_java, SCREEN_LANDSCAPE);
@ -295,26 +303,46 @@ int DisplayServerAndroid::get_primary_screen() const {
}
Point2i DisplayServerAndroid::screen_get_position(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, Point2i());
return Point2i(0, 0);
}
Size2i DisplayServerAndroid::screen_get_size(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, Size2i());
return OS_Android::get_singleton()->get_display_size();
}
Rect2i DisplayServerAndroid::screen_get_usable_rect(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, Rect2i());
Size2i display_size = OS_Android::get_singleton()->get_display_size();
return Rect2i(0, 0, display_size.width, display_size.height);
}
int DisplayServerAndroid::screen_get_dpi(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, 160);
GodotIOJavaWrapper *godot_io_java = OS_Android::get_singleton()->get_godot_io_java();
ERR_FAIL_NULL_V(godot_io_java, 0);
ERR_FAIL_NULL_V(godot_io_java, 160);
return godot_io_java->get_screen_dpi();
}
float DisplayServerAndroid::screen_get_scale(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, 1.0f);
GodotIOJavaWrapper *godot_io_java = OS_Android::get_singleton()->get_godot_io_java();
ERR_FAIL_NULL_V(godot_io_java, 1.0f);
@ -332,6 +360,10 @@ float DisplayServerAndroid::screen_get_scale(int p_screen) const {
}
float DisplayServerAndroid::screen_get_refresh_rate(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_REFRESH_RATE_FALLBACK);
GodotIOJavaWrapper *godot_io_java = OS_Android::get_singleton()->get_godot_io_java();
if (!godot_io_java) {
ERR_PRINT("An error occurred while trying to get the screen refresh rate.");
@ -487,7 +519,8 @@ void DisplayServerAndroid::window_set_title(const String &p_title, DisplayServer
}
int DisplayServerAndroid::window_get_current_screen(DisplayServer::WindowID p_window) const {
return SCREEN_OF_MAIN_WINDOW;
ERR_FAIL_COND_V(p_window != MAIN_WINDOW_ID, INVALID_SCREEN);
return 0;
}
void DisplayServerAndroid::window_set_current_screen(int p_screen, DisplayServer::WindowID p_window) {

12
platform/ios/display_server_ios.mm
View File

@ -59,6 +59,10 @@ String DisplayServerIOS::get_name() const {
}
int DisplayServerIOS::screen_get_dpi(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, 72);
struct utsname systemInfo;
uname(&systemInfo);
@ -96,6 +100,10 @@ int DisplayServerIOS::screen_get_dpi(int p_screen) const {
}
float DisplayServerIOS::screen_get_refresh_rate(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_REFRESH_RATE_FALLBACK);
float fps = [UIScreen mainScreen].maximumFramesPerSecond;
if ([NSProcessInfo processInfo].lowPowerModeEnabled) {
fps = 60;
@ -104,5 +112,9 @@ float DisplayServerIOS::screen_get_refresh_rate(int p_screen) const {
}
float DisplayServerIOS::screen_get_scale(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, 1.0f);
return [UIScreen mainScreen].scale;
}

36
platform/linuxbsd/wayland/display_server_wayland.cpp
View File

@ -576,9 +576,9 @@ int DisplayServerWayland::get_primary_screen() const {
Point2i DisplayServerWayland::screen_get_position(int p_screen) const {
MutexLock mutex_lock(wayland_thread.mutex);
if (p_screen == SCREEN_OF_MAIN_WINDOW) {
p_screen = window_get_current_screen();
}
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Point2i());
return wayland_thread.screen_get_data(p_screen).position;
}
@ -586,24 +586,27 @@ Point2i DisplayServerWayland::screen_get_position(int p_screen) const {
Size2i DisplayServerWayland::screen_get_size(int p_screen) const {
MutexLock mutex_lock(wayland_thread.mutex);
if (p_screen == SCREEN_OF_MAIN_WINDOW) {
p_screen = window_get_current_screen();
}
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Size2i());
return wayland_thread.screen_get_data(p_screen).size;
}
Rect2i DisplayServerWayland::screen_get_usable_rect(int p_screen) const {
// Unsupported on wayland.
return Rect2i(Point2i(), screen_get_size(p_screen));
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Rect2i());
return Rect2i(screen_get_position(p_screen), screen_get_size(p_screen));
}
int DisplayServerWayland::screen_get_dpi(int p_screen) const {
MutexLock mutex_lock(wayland_thread.mutex);
if (p_screen == SCREEN_OF_MAIN_WINDOW) {
p_screen = window_get_current_screen();
}
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, 96);
const WaylandThread::ScreenData &data = wayland_thread.screen_get_data(p_screen);
@ -636,15 +639,19 @@ float DisplayServerWayland::screen_get_scale(int p_screen) const {
return wayland_thread.window_state_get_scale_factor(ws);
}
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, 1.0f);
return wayland_thread.screen_get_data(p_screen).scale;
}
float DisplayServerWayland::screen_get_refresh_rate(int p_screen) const {
MutexLock mutex_lock(wayland_thread.mutex);
if (p_screen == SCREEN_OF_MAIN_WINDOW) {
p_screen = window_get_current_screen();
}
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, SCREEN_REFRESH_RATE_FALLBACK);
return wayland_thread.screen_get_data(p_screen).refresh_rate;
}
@ -1042,6 +1049,7 @@ void DisplayServerWayland::window_set_drop_files_callback(const Callable &p_call
}
int DisplayServerWayland::window_get_current_screen(DisplayServer::WindowID p_window_id) const {
ERR_FAIL_COND_V(p_window_id != MAIN_WINDOW_ID, INVALID_SCREEN);
// Standard Wayland APIs don't support getting the screen of a window.
return 0;
}

35
platform/linuxbsd/x11/display_server_x11.cpp
View File

@ -1206,7 +1206,8 @@ Rect2i DisplayServerX11::_screen_get_rect(int p_screen) const {
Rect2i rect(0, 0, 0, 0);
p_screen = _get_screen_index(p_screen);
ERR_FAIL_COND_V(p_screen < 0, rect);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Rect2i());
// Using Xinerama Extension.
bool found = false;
@ -1294,9 +1295,7 @@ Rect2i DisplayServerX11::screen_get_usable_rect(int p_screen) const {
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
// Check if screen is valid.
ERR_FAIL_INDEX_V(p_screen, screen_count, Rect2i(0, 0, 0, 0));
ERR_FAIL_INDEX_V(p_screen, screen_count, Rect2i());
bool is_multiscreen = screen_count > 1;
@ -1600,7 +1599,8 @@ int DisplayServerX11::screen_get_dpi(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
ERR_FAIL_INDEX_V(p_screen, get_screen_count(), 0);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, 96);
//Get physical monitor Dimensions through XRandR and calculate dpi
Size2i sc = screen_get_size(p_screen);
@ -1677,18 +1677,9 @@ Color DisplayServerX11::screen_get_pixel(const Point2i &p_position) const {
Ref<Image> DisplayServerX11::screen_get_image(int p_screen) const {
ERR_FAIL_INDEX_V(p_screen, get_screen_count(), Ref<Image>());
switch (p_screen) {
case SCREEN_PRIMARY: {
p_screen = get_primary_screen();
} break;
case SCREEN_OF_MAIN_WINDOW: {
p_screen = window_get_current_screen(MAIN_WINDOW_ID);
} break;
default:
break;
}
ERR_FAIL_COND_V(p_screen < 0, Ref<Image>());
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Ref<Image>());
if (xwayland) {
return Ref<Image>();
@ -1794,7 +1785,8 @@ float DisplayServerX11::screen_get_refresh_rate(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
ERR_FAIL_INDEX_V(p_screen, get_screen_count(), SCREEN_REFRESH_RATE_FALLBACK);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, SCREEN_REFRESH_RATE_FALLBACK);
//Use xrandr to get screen refresh rate.
if (xrandr_ext_ok) {
@ -2245,7 +2237,7 @@ int DisplayServerX11::window_get_current_screen(WindowID p_window) const {
return 0;
}
ERR_FAIL_COND_V(!windows.has(p_window), 0);
ERR_FAIL_COND_V(!windows.has(p_window), INVALID_SCREEN);
const WindowData &wd = windows[p_window];
const Rect2i window_rect(wd.position, wd.size);
@ -2281,14 +2273,15 @@ void DisplayServerX11::window_set_current_screen(int p_screen, WindowID p_window
_THREAD_SAFE_METHOD_
ERR_FAIL_COND(!windows.has(p_window));
WindowData &wd = windows[p_window];
p_screen = _get_screen_index(p_screen);
ERR_FAIL_INDEX(p_screen, get_screen_count());
int screen_count = get_screen_count();
ERR_FAIL_INDEX(p_screen, screen_count);
if (window_get_current_screen(p_window) == p_screen) {
return;
}
WindowData &wd = windows[p_window];
if (wd.embed_parent) {
print_line("Embedded window can't be moved to another screen.");

35
platform/macos/display_server_embedded.mm
View File

@ -503,24 +503,52 @@ int DisplayServerEmbedded::get_primary_screen() const {
}
Point2i DisplayServerEmbedded::screen_get_position(int p_screen) const {
return Size2i();
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Point2i());
return Point2i(0, 0);
}
Size2i DisplayServerEmbedded::screen_get_size(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Size2i());
return window_get_size(MAIN_WINDOW_ID);
}
Rect2i DisplayServerEmbedded::screen_get_usable_rect(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Rect2i());
return Rect2i(screen_get_position(p_screen), screen_get_size(p_screen));
}
int DisplayServerEmbedded::screen_get_dpi(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, 72);
return 96;
}
float DisplayServerEmbedded::screen_get_refresh_rate(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, SCREEN_REFRESH_RATE_FALLBACK);
p_screen = _get_screen_index(p_screen);
NSArray *screenArray = [NSScreen screens];
if ((NSUInteger)p_screen < [screenArray count]) {
@ -556,7 +584,10 @@ void DisplayServerEmbedded::window_set_title(const String &p_title, WindowID p_w
}
int DisplayServerEmbedded::window_get_current_screen(WindowID p_window) const {
return SCREEN_OF_MAIN_WINDOW;
_THREAD_SAFE_METHOD_
ERR_FAIL_COND_V(p_window != MAIN_WINDOW_ID, INVALID_SCREEN);
return 0;
}
void DisplayServerEmbedded::window_set_current_screen(int p_screen, WindowID p_window) {

32
platform/macos/display_server_macos.mm
View File

@ -1718,13 +1718,16 @@ int DisplayServerMacOS::get_primary_screen() const {
int DisplayServerMacOS::get_keyboard_focus_screen() const {
const NSUInteger index = [[NSScreen screens] indexOfObject:[NSScreen mainScreen]];
return (index == NSNotFound) ? 0 : index;
return (index == NSNotFound) ? get_primary_screen() : index;
}
Point2i DisplayServerMacOS::screen_get_position(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Point2i());
Point2i position = _get_native_screen_position(p_screen) - _get_screens_origin();
// macOS native y-coordinate relative to _get_screens_origin() is negative,
// Godot expects a positive value.
@ -1736,6 +1739,9 @@ Size2i DisplayServerMacOS::screen_get_size(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Size2i());
NSArray *screenArray = [NSScreen screens];
if ((NSUInteger)p_screen < [screenArray count]) {
// Note: Use frame to get the whole screen size.
@ -1750,6 +1756,9 @@ int DisplayServerMacOS::screen_get_dpi(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, 72);
NSArray *screenArray = [NSScreen screens];
if ((NSUInteger)p_screen < [screenArray count]) {
NSDictionary *description = [[screenArray objectAtIndex:p_screen] deviceDescription];
@ -1771,6 +1780,9 @@ float DisplayServerMacOS::screen_get_scale(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, 1.0f);
if (OS::get_singleton()->is_hidpi_allowed()) {
NSArray<NSScreen *> *screens = NSScreen.screens;
NSUInteger index = (NSUInteger)p_screen;
@ -1793,6 +1805,9 @@ Rect2i DisplayServerMacOS::screen_get_usable_rect(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Rect2i());
NSArray *screenArray = [NSScreen screens];
if ((NSUInteger)p_screen < [screenArray count]) {
const float scale = screen_get_max_scale();
@ -1849,7 +1864,9 @@ Color DisplayServerMacOS::screen_get_pixel(const Point2i &p_position) const {
}
Ref<Image> DisplayServerMacOS::screen_get_image(int p_screen) const {
ERR_FAIL_INDEX_V(p_screen, get_screen_count(), Ref<Image>());
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Ref<Image>());
HashSet<CGWindowID> exclude_windows;
for (HashMap<WindowID, WindowData>::ConstIterator E = windows.begin(); E; ++E) {
@ -1950,6 +1967,9 @@ float DisplayServerMacOS::screen_get_refresh_rate(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, SCREEN_REFRESH_RATE_FALLBACK);
NSArray *screenArray = [NSScreen screens];
if ((NSUInteger)p_screen < [screenArray count]) {
NSDictionary *description = [[screenArray objectAtIndex:p_screen] deviceDescription];
@ -2144,7 +2164,7 @@ void DisplayServerMacOS::window_set_mouse_passthrough(const Vector<Vector2> &p_r
int DisplayServerMacOS::window_get_current_screen(WindowID p_window) const {
_THREAD_SAFE_METHOD_
ERR_FAIL_COND_V(!windows.has(p_window), -1);
ERR_FAIL_COND_V(!windows.has(p_window), INVALID_SCREEN);
const WindowData &wd = windows[p_window];
const NSUInteger index = [[NSScreen screens] indexOfObject:[wd.window_object screen]];
@ -2155,11 +2175,15 @@ void DisplayServerMacOS::window_set_current_screen(int p_screen, WindowID p_wind
_THREAD_SAFE_METHOD_
ERR_FAIL_COND(!windows.has(p_window));
WindowData &wd = windows[p_window];
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX(p_screen, screen_count);
if (window_get_current_screen(p_window) == p_screen) {
return;
}
WindowData &wd = windows[p_window];
bool was_fullscreen = false;
if (wd.fullscreen) {

12
platform/visionos/display_server_visionos.mm
View File

@ -54,14 +54,26 @@ String DisplayServerVisionOS::get_name() const {
}
int DisplayServerVisionOS::screen_get_dpi(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, 72);
// TODO(Apple): Compute this properly from SwiftUI Metric APIs
return 72;
}
float DisplayServerVisionOS::screen_get_refresh_rate(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_REFRESH_RATE_FALLBACK);
return 90;
}
float DisplayServerVisionOS::screen_get_scale(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, 1.0f);
return 1;
}

29
platform/web/display_server_web.cpp
View File

@ -1217,30 +1217,54 @@ int DisplayServerWeb::get_primary_screen() const {
}
Point2i DisplayServerWeb::screen_get_position(int p_screen) const {
return Point2i(); // TODO offsetX/Y?
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Point2i());
return Point2i(0, 0); // TODO offsetX/Y?
}
Size2i DisplayServerWeb::screen_get_size(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, Size2i());
int size[2];
godot_js_display_screen_size_get(size, size + 1);
return Size2(size[0], size[1]);
}
Rect2i DisplayServerWeb::screen_get_usable_rect(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, Rect2i());
int size[2];
godot_js_display_window_size_get(size, size + 1);
return Rect2i(0, 0, size[0], size[1]);
}
int DisplayServerWeb::screen_get_dpi(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, 72);
return godot_js_display_screen_dpi_get();
}
float DisplayServerWeb::screen_get_scale(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, 1.0f);
return godot_js_display_pixel_ratio_get();
}
float DisplayServerWeb::screen_get_refresh_rate(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_REFRESH_RATE_FALLBACK);
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.
}
@ -1287,7 +1311,8 @@ void DisplayServerWeb::window_set_title(const String &p_title, WindowID p_window
}
int DisplayServerWeb::window_get_current_screen(WindowID p_window) const {
return 1;
ERR_FAIL_COND_V(p_window != MAIN_WINDOW_ID, INVALID_SCREEN);
return 0;
}
void DisplayServerWeb::window_set_current_screen(int p_screen, WindowID p_window) {

38
platform/windows/display_server_windows.cpp
View File

@ -1202,6 +1202,9 @@ Point2i DisplayServerWindows::screen_get_position(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Point2i());
EnumPosData data = { 0, p_screen, Point2() };
EnumDisplayMonitors(nullptr, nullptr, _MonitorEnumProcPos, (LPARAM)&data);
return data.pos - _get_screens_origin();
@ -1242,6 +1245,9 @@ Size2i DisplayServerWindows::screen_get_size(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Size2i());
EnumSizeData data = { 0, p_screen, Size2() };
EnumDisplayMonitors(nullptr, nullptr, _MonitorEnumProcSize, (LPARAM)&data);
return data.size;
@ -1307,6 +1313,9 @@ Rect2i DisplayServerWindows::screen_get_usable_rect(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Rect2i());
EnumRectData data = { 0, p_screen, Rect2i() };
EnumDisplayMonitors(nullptr, nullptr, _MonitorEnumProcUsableSize, (LPARAM)&data);
data.rect.position -= _get_screens_origin();
@ -1385,6 +1394,9 @@ int DisplayServerWindows::screen_get_dpi(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, 72);
EnumDpiData data = { 0, p_screen, 72 };
EnumDisplayMonitors(nullptr, nullptr, _MonitorEnumProcDpi, (LPARAM)&data);
return data.dpi;
@ -1413,18 +1425,9 @@ Color DisplayServerWindows::screen_get_pixel(const Point2i &p_position) const {
}
Ref<Image> DisplayServerWindows::screen_get_image(int p_screen) const {
ERR_FAIL_INDEX_V(p_screen, get_screen_count(), Ref<Image>());
switch (p_screen) {
case SCREEN_PRIMARY: {
p_screen = get_primary_screen();
} break;
case SCREEN_OF_MAIN_WINDOW: {
p_screen = window_get_current_screen(MAIN_WINDOW_ID);
} break;
default:
break;
}
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, Ref<Image>());
Point2i pos = screen_get_position(p_screen) + _get_screens_origin();
Size2i size = screen_get_size(p_screen);
@ -1541,6 +1544,9 @@ float DisplayServerWindows::screen_get_refresh_rate(int p_screen) const {
_THREAD_SAFE_METHOD_
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX_V(p_screen, screen_count, SCREEN_REFRESH_RATE_FALLBACK);
EnumRefreshRateData data = { Vector<DISPLAYCONFIG_PATH_INFO>(), Vector<DISPLAYCONFIG_MODE_INFO>(), 0, p_screen, SCREEN_REFRESH_RATE_FALLBACK };
uint32_t path_count = 0;
@ -2018,7 +2024,7 @@ void DisplayServerWindows::_update_window_mouse_passthrough(WindowID p_window) {
int DisplayServerWindows::window_get_current_screen(WindowID p_window) const {
_THREAD_SAFE_METHOD_
ERR_FAIL_COND_V(!windows.has(p_window), -1);
ERR_FAIL_COND_V(!windows.has(p_window), INVALID_SCREEN);
EnumScreenData data = { 0, 0, MonitorFromWindow(windows[p_window].hWnd, MONITOR_DEFAULTTONEAREST) };
EnumDisplayMonitors(nullptr, nullptr, _MonitorEnumProcScreen, (LPARAM)&data);
@ -2029,12 +2035,16 @@ void DisplayServerWindows::window_set_current_screen(int p_screen, WindowID p_wi
_THREAD_SAFE_METHOD_
ERR_FAIL_COND(!windows.has(p_window));
ERR_FAIL_INDEX(p_screen, get_screen_count());
p_screen = _get_screen_index(p_screen);
int screen_count = get_screen_count();
ERR_FAIL_INDEX(p_screen, screen_count);
if (window_get_current_screen(p_window) == p_screen) {
return;
}
const WindowData &wd = windows[p_window];
if (wd.parent_hwnd) {
print_line("Embedded window can't be moved to another screen.");
return;