SDL_GetDisplayUsableBounds returns initial bounds

[lailoken]

I'm currently on Ubuntu 24.04 LTS and have an application that is causing an assert due to an incorrect work area.

I am on 2.30.0 (I think this is the default on the OS?)

I tried to look through the logs / issues and did not see anything similar.

Issue:
I am calling SDL_GetDisplayUsableBounds and it returns 0 (success), yet the values are all 0,0,0,0 (SDL_GetError also returns no message)

I have three displays, and the issue seems to occur when I have a reserved area (task bar) on the right- hand side of the preceding display. (left-hand sides are fine)

On my main / middle display I also have a menu bar at the top, but then the side panel as well. And moving the side panel from the left (where SDL_GetDisplayUsableBounds returns the correct bounds for all displays) to the right, seems to break the following display's metrics.

[Sackzement]

I wasn't able to replicate this exact issue, but I noticed a very similar issue with the usable bounds and the panel on X11.

These tests probably won't fix the issue, but can give some insights into how X11 display bounds work.

---

My issue was on X11, when having the panel on the top or bottom of any display, it affected all usable bounds on every display.

This code was used to print the display bounds:

Code

To compile with SDL2, predefine: -DMY_SDL_MAJOR_VERSION=2
To compile with SDL3, predefine: -DMY_SDL_MAJOR_VERSION=3

Optionally: On SDL3, to compile with Wayland instead with X11, predefine -DMY_USE_WAYLAND

#if MY_SDL_MAJOR_VERSION == 2
#include <SDL2/SDL.h>
#include <stdbool.h>
#elif MY_SDL_MAJOR_VERSION == 3
#include <SDL3/SDL.h>
#else
#error define MY_SDL_MAJOR_VERSION as 2 or 3
#endif

#include <stdio.h>
#include <string.h>


// print error message if value is false
//
// check if error message was set if value is true
//
// returns original value
static int my_print_SDL_error(bool val) {
    const char *error_msg = SDL_GetError();
    
    if (!val) {
        printf("ERROR: %s\n", error_msg);
    }
    else if (error_msg[0]) {
        printf("TRUE_BUT_ERROR_MESSAGE_SET: %s\n", error_msg);
    }
    
    SDL_ClearError();
    
    return val;
}

// "main" function =================================================================================
int main(void) {
    bool return_value;
    
#if MY_SDL_MAJOR_VERSION == 3 && defined(MY_USE_WAYLAND)
    return_value = SDL_SetHint(SDL_HINT_VIDEO_DRIVER, "wayland");
    my_print_SDL_error(return_value);
#endif

    // init SDL
#if MY_SDL_MAJOR_VERSION == 2
    return_value = SDL_Init(SDL_INIT_VIDEO) == 0;
#elif MY_SDL_MAJOR_VERSION == 3
    return_value = SDL_Init(SDL_INIT_VIDEO);
#endif
    if (!my_print_SDL_error(return_value)) {
        printf("ERROR: %s\n", SDL_GetError());
        return -1;
    }
    
    // print SDL version
    printf("SDL Version (linked): ");
#if MY_SDL_MAJOR_VERSION == 2
    SDL_version linked_version;
    SDL_GetVersion(&linked_version);
    printf("%d.%d.%d\n", linked_version.major, linked_version.minor, linked_version.patch);
#elif MY_SDL_MAJOR_VERSION == 3
    printf("%d.%d.%d\n", SDL_VERSIONNUM_MAJOR(SDL_GetVersion()),
                         SDL_VERSIONNUM_MINOR(SDL_GetVersion()),
                         SDL_VERSIONNUM_MICRO(SDL_GetVersion()));
#endif
    
    // print video driver
    const char * current_video_driver = SDL_GetCurrentVideoDriver();
    printf("SDL_GetCurrentVideoDriver(): ");
    printf("%s\n", current_video_driver ? current_video_driver : "NULL");
    my_print_SDL_error(current_video_driver);
    
    // num displays variable (and SDL3 display ID array)
#if MY_SDL_MAJOR_VERSION == 2
    printf("SDL_GetNumVideoDisplays(): ");
    const int num_video_displays =  SDL_GetNumVideoDisplays();
    printf("%d\n", num_video_displays);
#elif MY_SDL_MAJOR_VERSION == 3
    printf("SDL_GetDisplays(): ");
    int display_count;
    SDL_DisplayID * displays = SDL_GetDisplays(&display_count);
    printf("display_count = %d\n", display_count);
    my_print_SDL_error(displays);
#endif

    // print primary display
#if MY_SDL_MAJOR_VERSION == 3
    printf("SDL_GetPrimaryDisplay(): ID = ");
    const SDL_DisplayID primary_display_id = SDL_GetPrimaryDisplay();
    printf("%d\n", primary_display_id);
    my_print_SDL_error(primary_display_id);
#endif
    
    // get max display name len
    size_t max_display_name_len = 0;
#if MY_SDL_MAJOR_VERSION == 2
    for (int display_idx = 0; display_idx < num_video_displays; ++display_idx) {
#elif MY_SDL_MAJOR_VERSION == 3
    for (int display_idx = 0; display_idx < display_count; ++display_idx) {
#endif
#if MY_SDL_MAJOR_VERSION == 2
        const char * const display_name = SDL_GetDisplayName(display_idx);
#elif MY_SDL_MAJOR_VERSION == 3
        const char * const display_name = SDL_GetDisplayName(displays[display_idx]);
#endif
        if (display_name) {
            const size_t display_name_len = strlen(display_name);
            if (display_name_len > max_display_name_len) {
                max_display_name_len = display_name_len;
            }
        }
    }
    if (max_display_name_len < 4) {
        max_display_name_len = 4;
    }
    
    // print display info table --------------------------------------------------------------------
    printf("Display Info:\n");
    
    // print header
    printf("idx | ");
#if MY_SDL_MAJOR_VERSION == 3
    printf("ID | ");
#endif
    printf("%-*s | bounds                | usable bounds\n", (int)max_display_name_len, "name");
    printf("----|");
#if MY_SDL_MAJOR_VERSION == 3
    printf("----|");
#endif
    for (int num_dashes_to_print = (int)max_display_name_len + 2; num_dashes_to_print > 0; --num_dashes_to_print) {
        printf("-");
    }
    printf("|-----------------------|----------------------\n");
    
    // loop start
#if MY_SDL_MAJOR_VERSION == 2
    for (int display_idx = 0; display_idx < num_video_displays; ++display_idx) {
#elif MY_SDL_MAJOR_VERSION == 3
    for (int display_idx = 0; display_idx < display_count; ++display_idx) {
#endif
        
        // print idx
        printf("%d   | ", display_idx);
        
        // print ID
#if MY_SDL_MAJOR_VERSION == 3
        printf("%d  | ", displays[display_idx]);
#endif
        
        // print name
#if MY_SDL_MAJOR_VERSION == 2
        const char * const display_name = SDL_GetDisplayName(display_idx);
#elif MY_SDL_MAJOR_VERSION == 3
        const char * const display_name = SDL_GetDisplayName(displays[display_idx]);
#endif
        printf("%-*s | ", (int)max_display_name_len, display_name ? display_name : "NULL");
        my_print_SDL_error(display_name);
        
        SDL_Rect display_bounds = {0,0,0,0};
        
        // print display bounds
#if MY_SDL_MAJOR_VERSION == 2
        return_value = SDL_GetDisplayBounds(display_idx, &display_bounds) == 0;
#elif MY_SDL_MAJOR_VERSION == 3
        return_value = SDL_GetDisplayBounds(displays[display_idx], &display_bounds);
#endif
        printf("{%4d,%4d,%4d,%4d} | ", display_bounds.x, display_bounds.y, display_bounds.w, display_bounds.h);
        my_print_SDL_error(return_value);
        
        // print display usable bounds
#if MY_SDL_MAJOR_VERSION == 2
        return_value = SDL_GetDisplayUsableBounds(display_idx, &display_bounds) == 0;
#elif MY_SDL_MAJOR_VERSION == 3
        return_value = SDL_GetDisplayUsableBounds(displays[display_idx], &display_bounds);
#endif
        printf("{%4d,%4d,%4d,%4d}", display_bounds.x, display_bounds.y, display_bounds.w, display_bounds.h);
        my_print_SDL_error(return_value);
        printf("\n");
    } // loop end
    
    // cleanup and quit
#if MY_SDL_MAJOR_VERSION == 3
    SDL_free(displays);
#endif
    
    SDL_Quit();
    
    return 0;
}

My setup:

3 displays: 1920x1080, 2560x1440, 1920x1080
Ordered from left to right. they are all aligned at the top.
KDE Plasma

Results:

I tested SDL2.30.0, SDL2.30.9 and the newest commit of the git master branch for SDL3.
The results were the same across these three versions.

Result 1:

Panel display: middle
Panel position: bottom
Panel size: 100

SDL Version (linked): 3.1.7
SDL_GetCurrentVideoDriver(): x11
SDL_GetDisplays(): display_count = 3
SDL_GetPrimaryDisplay(): ID = 1
Display Info:
idx | ID | name         | bounds                | usable bounds
----|----|--------------|-----------------------|----------------------
0   | 1  | DP-3 31"     | {1920,   0,2560,1440} | {1920,   0,2560,1340}
1   | 2  | DP-1 27"     | {4480,   0,1920,1080} | {4480,   0,1920,1080}
2   | 3  | HDMI-A-1 27" | {   0,   0,1920,1080} | {   0,   0,1920,1080}

Result 1, is my normal setup(the panel height is bigger for demonstration purposes).
All values look good. The panel size was subtracted from the middle display's height to get the usable bound's height.

For further results, only the display table will be shown,
X11 is used, with a panel size of 100.

Result 2:

Panel display: left or middle or right
Panel position: top

idx | ID | name         | bounds                | usable bounds
----|----|--------------|-----------------------|----------------------
0   | 1  | DP-3 31"     | {1920,   0,2560,1440} | {1920, 100,2560,1340}
1   | 2  | DP-1 27"     | {4480,   0,1920,1080} | {4480, 100,1920, 980}
2   | 3  | HDMI-A-1 27" | {   0,   0,1920,1080} | {   0, 100,1920, 980}

When the panel is at the top, the panel-height is added to display bound's y and subtracted from the height to get the usable bounds.
It doesn't matter on which display the panel is. If the panel is at the top on either display, the usable bounds will be adjusted for all displays.
This was a surprise, I thought it would only adjust the usable bounds of the display the panel was on, but it adjusts it for all displays.

Result 3:

Panel display: left or right
Panel position: bottom

idx | ID | name         | bounds                | usable bounds
----|----|--------------|-----------------------|----------------------
0   | 1  | DP-3 31"     | {1920,   0,2560,1440} | {1920,   0,2560, 980}
1   | 2  | DP-1 27"     | {4480,   0,1920,1080} | {4480,   0,1920, 980}
2   | 3  | HDMI-A-1 27" | {   0,   0,1920,1080} | {   0,   0,1920, 980}

This result was even more surprising then the second one. The usable bound's height doesn't just get subtracted, it even crops the height of the middle display to 980.
After the second result, I expected the height of the middle display to be subtracted to 1340, but it gets cropped to the same height as the left and right display.

Result 4:

Panel display: left
Panel position: left

idx | ID | name         | bounds                | usable bounds
----|----|--------------|-----------------------|----------------------
0   | 1  | DP-3 31"     | {1920,   0,2560,1440} | {1920,   0,2560,1440}
1   | 2  | DP-1 27"     | {4480,   0,1920,1080} | {4480,   0,1920,1080}
2   | 3  | HDMI-A-1 27" | {   0,   0,1920,1080} | { 100,   0,1820,1080}

Here, everything seems correct. The panel size was added to x and subtracted from the width to get the usable bounds of the left display.

Result 5:

Panel display: middle or right
Panel position: left

idx | ID | name         | bounds                | usable bounds
----|----|--------------|-----------------------|----------------------
0   | 1  | DP-3 31"     | {1920,   0,2560,1440} | {1920,   0,2560,1440}
1   | 2  | DP-1 27"     | {4480,   0,1920,1080} | {4480,   0,1920,1080}
2   | 3  | HDMI-A-1 27" | {   0,   0,1920,1080} | {   0,   0,1920,1080}

Here, the panel was ignored and the usable bounds are the same as the display bounds.

Result 6:

Panel display: left or middle
Panel side: right

idx | ID | name         | bounds                | usable bounds
----|----|--------------|-----------------------|----------------------
0   | 1  | DP-3 31"     | {1920,   0,2560,1440} | {1920,   0,2560,1440}
1   | 2  | DP-1 27"     | {4480,   0,1920,1080} | {4480,   0,1920,1080}
2   | 3  | HDMI-A-1 27" | {   0,   0,1920,1080} | {   0,   0,1920,1080}

The panel was ignored again.

Result 7:

Panel display: right
Panel position: right

idx | ID | name         | bounds                | usable bounds
----|----|--------------|-----------------------|----------------------
0   | 1  | DP-3 31"     | {1920,   0,2560,1440} | {1920,   0,2560,1440}
1   | 2  | DP-1 27"     | {4480,   0,1920,1080} | {4480,   0,1820,1080}
2   | 3  | HDMI-A-1 27" | {   0,   0,1920,1080} | {   0,   0,1920,1080}

This one seems correct again. It was subtracted from the right display's usable bound width.

Result Summary:

It seems like, if the panel is in between two displays, the panel is ignored and the usable bounds are the same as the display bounds.
And if the panel is on the outside, it gets computed correctly. BUT, if any display crosses the line of the panel of another display, it gets cropped.

---

Were do these values come from?

SDL seems to get the usable bounds for a display from an X11 function:

SDL/src/video/x11/SDL_x11modes.c

Lines 1017 to 1027 in 332fd82

	int status = X11_XGetWindowProperty(display, DefaultRootWindow(display),
	_NET_WORKAREA, 0L, 4L, False, XA_CARDINAL,
	&real_type, &real_format, &items_read,
	&items_left, &propdata);
	if ((status == Success) && (items_read >= 4)) {
	const long *p = (long *)propdata;
	const SDL_Rect usable = { (int)p[0], (int)p[1], (int)p[2], (int)p[3] };
	result = true;
	if (!SDL_GetRectIntersection(rect, &usable, rect)) {
	SDL_zerop(rect);
	}

I'm not sure if SDL has any influence on what X11 returns for the usable bounds.

And Wayland?

With Wayland the panel was always ignored and the returned usable bounds were always the same as the display bounds.

[slouken]

@Sackzement, can you print out the value of rect and usable in each of those case, before the intersection? I'm guessing the usable rect is relative to the monitor rect, or something like that.

[slouken]

@Kontrabant, do we expect Wayland to provide usable bounds here?

[Kontrabant]

@Kontrabant, do we expect Wayland to provide usable bounds here?

No, unfortunately, there is no reliable way to query the usable desktop bounds. We do apply the toplevel window content size hints for resizable windows now though, so even if windows are slightly larger than the usable desktop space, they won't spill off of the edges.

[Sackzement]

@Sackzement, can you print out the value of rect and usable in each of those case, before the intersection? I'm guessing the usable rect is relative to the monitor rect, or something like that.

Here are the results with the rect and usable values right before the intersection:

Results 2 and 3 are the problematic ones, because the usable bounds of other displays get cropped as well. Especially in result 3 they get cropped by a lot.

This is an illustration of result 3:
yellow represents the panel
green are the resulting usable bounds
red are cropped regions

---

Panel size: 100

Result 1:

Panel display: middle
Panel position: bottom

SDL Version (linked): 3.1.9
SDL_GetCurrentVideoDriver(): x11
SDL_GetDisplays(): display_count = 3
SDL_GetPrimaryDisplay(): ID = 1
Display Info:
idx | ID | name         | bounds                | usable bounds         | rect before intersect | usable before intersect
----|----|--------------|-----------------------|-----------------------|-----------------------|-----------------------
0   | 1  | DP-3 31"     | {1920,   0,2560,1440} | {1920,   0,2560,1340} | {1920,   0,2560,1440} | {   0,   0,6400,1340}
1   | 2  | HDMI-A-1 27" | {   0,   0,1920,1080} | {   0,   0,1920,1080} | {   0,   0,1920,1080} | {   0,   0,6400,1340}
2   | 3  | DP-1 27"     | {4480,   0,1920,1080} | {4480,   0,1920,1080} | {4480,   0,1920,1080} | {   0,   0,6400,1340}

Result 2:

Panel display: left or middle or right
Panel position: top

idx | ID | name         | bounds                | usable bounds         | rect before intersect | usable before intersect
----|----|--------------|-----------------------|-----------------------|-----------------------|-----------------------
0   | 1  | DP-3 31"     | {1920,   0,2560,1440} | {1920, 100,2560,1340} | {1920,   0,2560,1440} | {   0, 100,6400,1340}
1   | 2  | HDMI-A-1 27" | {   0,   0,1920,1080} | {   0, 100,1920, 980} | {   0,   0,1920,1080} | {   0, 100,6400,1340}
2   | 3  | DP-1 27"     | {4480,   0,1920,1080} | {4480, 100,1920, 980} | {4480,   0,1920,1080} | {   0, 100,6400,1340}

Result 3:

Panel display: left or right
Panel position: bottom

idx | ID | name         | bounds                | usable bounds         | rect before intersect | usable before intersect
----|----|--------------|-----------------------|-----------------------|-----------------------|-----------------------
0   | 1  | DP-3 31"     | {1920,   0,2560,1440} | {1920,   0,2560, 980} | {1920,   0,2560,1440} | {   0,   0,6400, 980}
1   | 2  | HDMI-A-1 27" | {   0,   0,1920,1080} | {   0,   0,1920, 980} | {   0,   0,1920,1080} | {   0,   0,6400, 980}
2   | 3  | DP-1 27"     | {4480,   0,1920,1080} | {4480,   0,1920, 980} | {4480,   0,1920,1080} | {   0,   0,6400, 980}

Result 4:

Panel display: left
Panel position: left

idx | ID | name         | bounds                | usable bounds         | rect before intersect | usable before intersect
----|----|--------------|-----------------------|-----------------------|-----------------------|-----------------------
0   | 1  | DP-3 31"     | {1920,   0,2560,1440} | {1920,   0,2560,1440} | {1920,   0,2560,1440} | { 100,   0,6300,1440}
1   | 2  | HDMI-A-1 27" | {   0,   0,1920,1080} | { 100,   0,1820,1080} | {   0,   0,1920,1080} | { 100,   0,6300,1440}
2   | 3  | DP-1 27"     | {4480,   0,1920,1080} | {4480,   0,1920,1080} | {4480,   0,1920,1080} | { 100,   0,6300,1440}

Result 5:

Panel display: middle or right
Panel position: left

idx | ID | name         | bounds                | usable bounds         | rect before intersect | usable before intersect
----|----|--------------|-----------------------|-----------------------|-----------------------|-----------------------
0   | 1  | DP-3 31"     | {1920,   0,2560,1440} | {1920,   0,2560,1440} | {1920,   0,2560,1440} | {   0,   0,6400,1440}
1   | 2  | HDMI-A-1 27" | {   0,   0,1920,1080} | {   0,   0,1920,1080} | {   0,   0,1920,1080} | {   0,   0,6400,1440}
2   | 3  | DP-1 27"     | {4480,   0,1920,1080} | {4480,   0,1920,1080} | {4480,   0,1920,1080} | {   0,   0,6400,1440}

Result 6:

Panel display: left or middle
Panel side: right

idx | ID | name         | bounds                | usable bounds         | rect before intersect | usable before intersect
----|----|--------------|-----------------------|-----------------------|-----------------------|-----------------------
0   | 1  | DP-3 31"     | {1920,   0,2560,1440} | {1920,   0,2560,1440} | {1920,   0,2560,1440} | {   0,   0,6400,1440}
1   | 2  | HDMI-A-1 27" | {   0,   0,1920,1080} | {   0,   0,1920,1080} | {   0,   0,1920,1080} | {   0,   0,6400,1440}
2   | 3  | DP-1 27"     | {4480,   0,1920,1080} | {4480,   0,1920,1080} | {4480,   0,1920,1080} | {   0,   0,6400,1440}

Result 7:

Panel display: right
Panel position: right

idx | ID | name         | bounds                | usable bounds         | rect before intersect | usable before intersect
----|----|--------------|-----------------------|-----------------------|-----------------------|-----------------------
0   | 1  | DP-3 31"     | {1920,   0,2560,1440} | {1920,   0,2560,1440} | {1920,   0,2560,1440} | {   0,   0,6300,1440}
1   | 2  | HDMI-A-1 27" | {   0,   0,1920,1080} | {   0,   0,1920,1080} | {   0,   0,1920,1080} | {   0,   0,6300,1440}
2   | 3  | DP-1 27"     | {4480,   0,1920,1080} | {4480,   0,1820,1080} | {4480,   0,1920,1080} | {   0,   0,6300,1440}

[slouken]

So that all makes sense. What's happening is that the usable bounds aren't per-monitor, they're a rectangle across all three monitors that is guaranteed not to intersect the panel. Unfortunately, this means that depending on the panel position, we're left with a small rectangle across otherwise completely open monitors.

[slouken]

Here's someone asking about this on Stack Overflow:
https://stackoverflow.com/questions/2598580/gtk-get-usable-area-of-each-monitor-excluding-panels

[slouken]

X-Tile solves this by taking the monitor bounds and subtracting the areas covered by strut windows:
https://github.com/giuspen/x-tile/blob/9ec59c93f3991ab16975fee3215a6236833aa9a2/modules/support.py#L291-L315

[slouken]

I'm not sure if this approach is a good one for our purposes or not. @Sackzement, do you want to prototype it up and see how it works on your desktop?

In any case, changing how this works needs more testing time than we have for 3.2.0, so I'm bumping it out of the milestone.