shadps4-emu/ext-SDL
1
0
Fork 0
mirror of https://github.com/shadps4-emu/ext-SDL.git synced 2024-11-23 10:09:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
7c75801571
ext-SDL/include/SDL3/SDL_video.h

2654 lines
103 KiB
C
Raw Normal View History

Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/*
Simple DirectMedia Layer
Updated copyright for 2024
2024-01-01 21:15:26 +00:00
Copyright (C) 1997-2024 Sam Lantinga <slouken@libsdl.org>
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
/**
wikiheaders: bridge wiki Category docs to the headers! Did an initial cleanup on the headers and wrote a few pieces of documentation, but this needs more work to fill out the documentation.
2024-05-16 14:44:37 +00:00
* # CategoryVideo
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
wikiheaders: bridge wiki Category docs to the headers! Did an initial cleanup on the headers and wrote a few pieces of documentation, but this needs more work to fill out the documentation.
2024-05-16 14:44:37 +00:00
* SDL video functions.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renaming of guard header names to quiet -Wreserved-id-macro Patch contributed by Sylvain
2016-11-21 05:34:54 +00:00
#ifndef SDL_video_h_
#define SDL_video_h_
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
Switch header convention from `#include "SDL.h"` to `#include <SDL3/SDLh>` I ran this script in the include directory: ```sh sed -i '' -e 's,#include "\(SDL.*\)",#include <SDL3/\1>,' *.h ``` I ran this script in the src directory: ```sh for i in ../include/SDL3/SDL*.h do hdr=$(basename $i) if [ x"$(echo $hdr | egrep 'SDL_main|SDL_name|SDL_test|SDL_syswm|SDL_opengl|SDL_egl|SDL_vulkan')" != x ]; then find . -type f -exec sed -i '' -e 's,#include "\('$hdr'\)",#include <SDL3/\1>,' {} \; else find . -type f -exec sed -i '' -e '/#include "'$hdr'"/d' {} \; fi done ``` Fixes https://github.com/libsdl-org/SDL/issues/6575
2022-11-27 04:43:38 +00:00
#include <SDL3/SDL_stdinc.h>
Including SD_error.h into headers with error-returning functions
2024-04-04 16:38:21 +00:00
#include <SDL3/SDL_error.h>
Switch header convention from `#include "SDL.h"` to `#include <SDL3/SDLh>` I ran this script in the include directory: ```sh sed -i '' -e 's,#include "\(SDL.*\)",#include <SDL3/\1>,' *.h ``` I ran this script in the src directory: ```sh for i in ../include/SDL3/SDL*.h do hdr=$(basename $i) if [ x"$(echo $hdr | egrep 'SDL_main|SDL_name|SDL_test|SDL_syswm|SDL_opengl|SDL_egl|SDL_vulkan')" != x ]; then find . -type f -exec sed -i '' -e 's,#include "\('$hdr'\)",#include <SDL3/\1>,' {} \; else find . -type f -exec sed -i '' -e '/#include "'$hdr'"/d' {} \; fi done ``` Fixes https://github.com/libsdl-org/SDL/issues/6575
2022-11-27 04:43:38 +00:00
#include <SDL3/SDL_pixels.h>
Added properties to various SDL objects The following objects now have properties that can be user modified: * SDL_AudioStream * SDL_Gamepad * SDL_Joystick * SDL_RWops * SDL_Renderer * SDL_Sensor * SDL_Surface * SDL_Texture * SDL_Window
2023-10-11 23:59:51 +00:00
#include <SDL3/SDL_properties.h>
Switch header convention from `#include "SDL.h"` to `#include <SDL3/SDLh>` I ran this script in the include directory: ```sh sed -i '' -e 's,#include "\(SDL.*\)",#include <SDL3/\1>,' *.h ``` I ran this script in the src directory: ```sh for i in ../include/SDL3/SDL*.h do hdr=$(basename $i) if [ x"$(echo $hdr | egrep 'SDL_main|SDL_name|SDL_test|SDL_syswm|SDL_opengl|SDL_egl|SDL_vulkan')" != x ]; then find . -type f -exec sed -i '' -e 's,#include "\('$hdr'\)",#include <SDL3/\1>,' {} \; else find . -type f -exec sed -i '' -e '/#include "'$hdr'"/d' {} \; fi done ``` Fixes https://github.com/libsdl-org/SDL/issues/6575
2022-11-27 04:43:38 +00:00
#include <SDL3/SDL_rect.h>
#include <SDL3/SDL_surface.h>
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
include: Renamed begin_code.h and close_code.h to have SDL_ prefixes. Fixes #6864.
2022-12-22 16:38:59 +00:00
#include <SDL3/SDL_begin_code.h>
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/* Set up for C function definitions, even when using C++ */
#ifdef __cplusplus
extern "C" {
#endif
Add SDL_WindowID type for SDL_Window id
2023-01-04 09:27:28 +00:00
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
typedef Uint32 SDL_DisplayID;
Add SDL_WindowID type for SDL_Window id
2023-01-04 09:27:28 +00:00
typedef Uint32 SDL_WindowID;
include: Filling in more documentation gaps.
2024-05-03 17:01:41 +00:00
/* Global video properties... */
/**
* The pointer to the global `wl_display` object used by the Wayland video
* backend.
wayland: Add the ability to import and wrap external surfaces Add the ability to import and wrap external surfaces from external toolkits such as Qt and GTK. Wayland surfaces and windows are more intrinsically tied to the client library than other windowing systems, so it is necessary to provide a way to initialize SDL with an existing wl_display object, which needs to be set prior to video system initialization, or export the internal SDL wl_display object for use by external applications or toolkits. For this, the global property SDL_PROPERTY_GLOBAL_VIDEO_WAYLAND_WL_DISPLAY_POINTER is used. A Wayland example was added to testnative, and a basic example of Qt 6 interoperation is provided in the Wayland readme to demonstrate the use of external windows with both SDL owning the wl_display, and an external toolkit owning it.
2024-01-09 16:38:38 +00:00
*
include: Filling in more documentation gaps.
2024-05-03 17:01:41 +00:00
* Can be set before the video subsystem is initialized to import an external
* `wl_display` object from an application or toolkit for use in SDL, or read
* after initialization to export the `wl_display` used by the Wayland video
* backend. Setting this property after the video subsystem has been
* initialized has no effect, and reading it when the video subsystem is
* uninitialized will either return the user provided value, if one was set
* prior to initialization, or NULL. See docs/README-wayland.md for more
* information.
wayland: Add the ability to import and wrap external surfaces Add the ability to import and wrap external surfaces from external toolkits such as Qt and GTK. Wayland surfaces and windows are more intrinsically tied to the client library than other windowing systems, so it is necessary to provide a way to initialize SDL with an existing wl_display object, which needs to be set prior to video system initialization, or export the internal SDL wl_display object for use by external applications or toolkits. For this, the global property SDL_PROPERTY_GLOBAL_VIDEO_WAYLAND_WL_DISPLAY_POINTER is used. A Wayland example was added to testnative, and a basic example of Qt 6 interoperation is provided in the Wayland readme to demonstrate the use of external windows with both SDL owning the wl_display, and an external toolkit owning it.
2024-01-09 16:38:38 +00:00
*/
video: Prepend global video property with "SDL"
2024-03-19 01:52:39 +00:00
#define SDL_PROP_GLOBAL_VIDEO_WAYLAND_WL_DISPLAY_POINTER "SDL.video.wayland.wl_display"
wayland: Add the ability to import and wrap external surfaces Add the ability to import and wrap external surfaces from external toolkits such as Qt and GTK. Wayland surfaces and windows are more intrinsically tied to the client library than other windowing systems, so it is necessary to provide a way to initialize SDL with an existing wl_display object, which needs to be set prior to video system initialization, or export the internal SDL wl_display object for use by external applications or toolkits. For this, the global property SDL_PROPERTY_GLOBAL_VIDEO_WAYLAND_WL_DISPLAY_POINTER is used. A Wayland example was added to testnative, and a basic example of Qt 6 interoperation is provided in the Wayland readme to demonstrate the use of external windows with both SDL owning the wl_display, and an external toolkit owning it.
2024-01-09 16:38:38 +00:00
Added SDL_GetSystemTheme() to return whether the system is using a dark or light color theme, and SDL_EVENT_SYSTEM_THEME_CHANGED is sent when this changes Fixes https://github.com/libsdl-org/SDL/issues/5334 Fixes https://github.com/libsdl-org/SDL/issues/6958 Closes https://github.com/libsdl-org/SDL/pull/6440
2023-03-07 08:01:34 +00:00
/**
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
* System theme.
*
* \since This enum is available since SDL 3.0.0.
Added SDL_GetSystemTheme() to return whether the system is using a dark or light color theme, and SDL_EVENT_SYSTEM_THEME_CHANGED is sent when this changes Fixes https://github.com/libsdl-org/SDL/issues/5334 Fixes https://github.com/libsdl-org/SDL/issues/6958 Closes https://github.com/libsdl-org/SDL/pull/6440
2023-03-07 08:01:34 +00:00
*/
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
typedef enum SDL_SystemTheme
Added SDL_GetSystemTheme() to return whether the system is using a dark or light color theme, and SDL_EVENT_SYSTEM_THEME_CHANGED is sent when this changes Fixes https://github.com/libsdl-org/SDL/issues/5334 Fixes https://github.com/libsdl-org/SDL/issues/6958 Closes https://github.com/libsdl-org/SDL/pull/6440
2023-03-07 08:01:34 +00:00
{
SDL_SYSTEM_THEME_UNKNOWN, /**< Unknown system theme */
SDL_SYSTEM_THEME_LIGHT, /**< Light colored system theme */
Fixed pedantic warning: comma at end of enumerator list Fixes https://github.com/libsdl-org/SDL/issues/7878
2023-06-28 04:52:33 +00:00
SDL_SYSTEM_THEME_DARK /**< Dark colored system theme */
Added SDL_GetSystemTheme() to return whether the system is using a dark or light color theme, and SDL_EVENT_SYSTEM_THEME_CHANGED is sent when this changes Fixes https://github.com/libsdl-org/SDL/issues/5334 Fixes https://github.com/libsdl-org/SDL/issues/6958 Closes https://github.com/libsdl-org/SDL/pull/6440
2023-03-07 08:01:34 +00:00
} SDL_SystemTheme;
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
* The structure that defines a display mode.
*
* \since This struct is available since SDL 3.0.0.
Sync SDL3 wiki -> headers
2024-04-09 04:49:23 +00:00
*
* \sa SDL_GetFullscreenDisplayModes
* \sa SDL_GetDesktopDisplayMode
* \sa SDL_GetCurrentDisplayMode
* \sa SDL_SetWindowFullscreenMode
* \sa SDL_GetWindowFullscreenMode
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
typedef struct SDL_DisplayMode
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
{
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
SDL_DisplayID displayID; /**< the display this mode is associated with */
The pixel format in SDL_DisplayMode uses SDL_PixelFormatEnum
2024-03-07 11:39:06 +00:00
SDL_PixelFormatEnum format; /**< pixel format */
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
int w; /**< width */
int h; /**< height */
float pixel_density; /**< scale converting size to pixels (e.g. a 1920x1080 mode with 2.0 scale would have 3840x2160 pixels) */
The refresh rate in SDL_DisplayMode is now a float
2023-01-02 23:47:19 +00:00
float refresh_rate; /**< refresh rate (or zero for unspecified) */
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
void *driverdata; /**< driver-specific data, initialize to 0 */
} SDL_DisplayMode;
Added SDL_GetSystemTheme() to return whether the system is using a dark or light color theme, and SDL_EVENT_SYSTEM_THEME_CHANGED is sent when this changes Fixes https://github.com/libsdl-org/SDL/issues/5334 Fixes https://github.com/libsdl-org/SDL/issues/6958 Closes https://github.com/libsdl-org/SDL/pull/6440
2023-03-07 08:01:34 +00:00
/**
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
* Display orientation values; the way a display is rotated.
*
* \since This enum is available since SDL 3.0.0.
Added SDL_GetSystemTheme() to return whether the system is using a dark or light color theme, and SDL_EVENT_SYSTEM_THEME_CHANGED is sent when this changes Fixes https://github.com/libsdl-org/SDL/issues/5334 Fixes https://github.com/libsdl-org/SDL/issues/6958 Closes https://github.com/libsdl-org/SDL/pull/6440
2023-03-07 08:01:34 +00:00
*/
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
typedef enum SDL_DisplayOrientation
Added SDL_GetSystemTheme() to return whether the system is using a dark or light color theme, and SDL_EVENT_SYSTEM_THEME_CHANGED is sent when this changes Fixes https://github.com/libsdl-org/SDL/issues/5334 Fixes https://github.com/libsdl-org/SDL/issues/6958 Closes https://github.com/libsdl-org/SDL/pull/6440
2023-03-07 08:01:34 +00:00
{
SDL_ORIENTATION_UNKNOWN, /**< The display orientation can't be determined */
SDL_ORIENTATION_LANDSCAPE, /**< The display is in landscape mode, with the right side up, relative to portrait mode */
SDL_ORIENTATION_LANDSCAPE_FLIPPED, /**< The display is in landscape mode, with the left side up, relative to portrait mode */
SDL_ORIENTATION_PORTRAIT, /**< The display is in portrait mode */
SDL_ORIENTATION_PORTRAIT_FLIPPED /**< The display is in portrait mode, upside down */
} SDL_DisplayOrientation;
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Sync SDL3 wiki -> headers
2024-04-09 04:49:23 +00:00
* The struct used as an opaque handle to a window.
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
*
* \since This struct is available since SDL 3.0.0.
*
* \sa SDL_CreateWindow
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
typedef struct SDL_Window SDL_Window;
/**
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
* The flags on a window.
*
Sync SDL3 wiki -> header
2024-04-11 12:59:41 +00:00
* These cover a lot of true/false, or on/off, window state. Some of it is
* immutable after being set through SDL_CreateWindow(), some of it can be
* changed on existing windows by the app, and some of it might be altered by
* the user or system outside of the app's control.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
include: Add `\since` to all documentation that was missing it.
2024-04-11 17:34:29 +00:00
* \since This datatype is available since SDL 3.0.0.
*
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
* \sa SDL_GetWindowFlags
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
SDL_WindowFlags is now 64-bit Fixes https://github.com/libsdl-org/SDL/issues/7321
2024-05-09 17:11:44 +00:00
typedef Uint64 SDL_WindowFlags;
#define SDL_WINDOW_FULLSCREEN SDL_UINT64_C(0x0000000000000001) /**< window is in fullscreen mode */
#define SDL_WINDOW_OPENGL SDL_UINT64_C(0x0000000000000002) /**< window usable with OpenGL context */
#define SDL_WINDOW_OCCLUDED SDL_UINT64_C(0x0000000000000004) /**< window is occluded */
#define SDL_WINDOW_HIDDEN SDL_UINT64_C(0x0000000000000008) /**< window is neither mapped onto the desktop nor shown in the taskbar/dock/window list; SDL_ShowWindow() is required for it to become visible */
#define SDL_WINDOW_BORDERLESS SDL_UINT64_C(0x0000000000000010) /**< no window decoration */
#define SDL_WINDOW_RESIZABLE SDL_UINT64_C(0x0000000000000020) /**< window can be resized */
#define SDL_WINDOW_MINIMIZED SDL_UINT64_C(0x0000000000000040) /**< window is minimized */
#define SDL_WINDOW_MAXIMIZED SDL_UINT64_C(0x0000000000000080) /**< window is maximized */
#define SDL_WINDOW_MOUSE_GRABBED SDL_UINT64_C(0x0000000000000100) /**< window has grabbed mouse input */
#define SDL_WINDOW_INPUT_FOCUS SDL_UINT64_C(0x0000000000000200) /**< window has input focus */
#define SDL_WINDOW_MOUSE_FOCUS SDL_UINT64_C(0x0000000000000400) /**< window has mouse focus */
#define SDL_WINDOW_EXTERNAL SDL_UINT64_C(0x0000000000000800) /**< window not created by SDL */
#define SDL_WINDOW_MODAL SDL_UINT64_C(0x0000000000001000) /**< window is modal */
#define SDL_WINDOW_HIGH_PIXEL_DENSITY SDL_UINT64_C(0x0000000000002000) /**< window uses high pixel density back buffer if possible */
#define SDL_WINDOW_MOUSE_CAPTURE SDL_UINT64_C(0x0000000000004000) /**< window has mouse captured (unrelated to MOUSE_GRABBED) */
#define SDL_WINDOW_ALWAYS_ON_TOP SDL_UINT64_C(0x0000000000008000) /**< window should always be above others */
#define SDL_WINDOW_UTILITY SDL_UINT64_C(0x0000000000020000) /**< window should be treated as a utility window, not showing in the task bar and window list */
#define SDL_WINDOW_TOOLTIP SDL_UINT64_C(0x0000000000040000) /**< window should be treated as a tooltip and does not get mouse or keyboard focus, requires a parent window */
#define SDL_WINDOW_POPUP_MENU SDL_UINT64_C(0x0000000000080000) /**< window should be treated as a popup menu, requires a parent window */
#define SDL_WINDOW_KEYBOARD_GRABBED SDL_UINT64_C(0x0000000000100000) /**< window has grabbed keyboard input */
#define SDL_WINDOW_VULKAN SDL_UINT64_C(0x0000000010000000) /**< window usable for Vulkan surface */
#define SDL_WINDOW_METAL SDL_UINT64_C(0x0000000020000000) /**< window usable for Metal view */
#define SDL_WINDOW_TRANSPARENT SDL_UINT64_C(0x0000000040000000) /**< window with transparent buffer */
#define SDL_WINDOW_NOT_FOCUSABLE SDL_UINT64_C(0x0000000080000000) /**< window should not be focusable */
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
wikiheaders: Allow blank lines in post-typedef `#define` blocks. Reference Issue #9557.
2024-04-25 18:26:49 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Sync SDL3 wiki -> headers
2024-04-09 04:49:23 +00:00
* Used to indicate that you don't care what the window position is.
include: Add `\since` to all documentation that was missing it.
2024-04-11 17:34:29 +00:00
*
* \since This macro is available since SDL 3.0.0.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Fixed bug 3165 - define numbers don't match types in Swift C.W. Betts Swift is very strict with types, so much that those of different signedness/size must be cast. Most of the defines are imported as 32-bit signed integers, while the corresponding field in a struct is a 32-bit unsigned integer. Appending a "u" would cause the defined types to be imported as 32-bit unsigned integers.
2016-10-01 20:35:36 +00:00
#define SDL_WINDOWPOS_UNDEFINED_MASK 0x1FFF0000u
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
#define SDL_WINDOWPOS_UNDEFINED_DISPLAY(X) (SDL_WINDOWPOS_UNDEFINED_MASK|(X))
#define SDL_WINDOWPOS_UNDEFINED SDL_WINDOWPOS_UNDEFINED_DISPLAY(0)
#define SDL_WINDOWPOS_ISUNDEFINED(X) \
(((X)&0xFFFF0000) == SDL_WINDOWPOS_UNDEFINED_MASK)
/**
Sync SDL3 wiki -> headers
2024-04-09 04:49:23 +00:00
* Used to indicate that the window position should be centered.
include: Add `\since` to all documentation that was missing it.
2024-04-11 17:34:29 +00:00
*
* \since This macro is available since SDL 3.0.0.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Fixed bug 3165 - define numbers don't match types in Swift C.W. Betts Swift is very strict with types, so much that those of different signedness/size must be cast. Most of the defines are imported as 32-bit signed integers, while the corresponding field in a struct is a 32-bit unsigned integer. Appending a "u" would cause the defined types to be imported as 32-bit unsigned integers.
2016-10-01 20:35:36 +00:00
#define SDL_WINDOWPOS_CENTERED_MASK 0x2FFF0000u
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
#define SDL_WINDOWPOS_CENTERED_DISPLAY(X) (SDL_WINDOWPOS_CENTERED_MASK|(X))
#define SDL_WINDOWPOS_CENTERED SDL_WINDOWPOS_CENTERED_DISPLAY(0)
#define SDL_WINDOWPOS_ISCENTERED(X) \
(((X)&0xFFFF0000) == SDL_WINDOWPOS_CENTERED_MASK)
Added a window flash operation to be explicit about window flash behavior
2021-07-24 20:41:55 +00:00
/**
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
* Window flash operation.
*
* \since This enum is available since SDL 3.0.0.
Added a window flash operation to be explicit about window flash behavior
2021-07-24 20:41:55 +00:00
*/
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
typedef enum SDL_FlashOperation
Added a window flash operation to be explicit about window flash behavior
2021-07-24 20:41:55 +00:00
{
SDL_FLASH_CANCEL, /**< Cancel any window flash state */
SDL_FLASH_BRIEFLY, /**< Flash the window briefly to get attention */
include/SDL_video.h: Remove a comma at end of enumerator list
2021-08-16 04:43:37 +00:00
SDL_FLASH_UNTIL_FOCUSED /**< Flash the window until it gets focus */
Added a window flash operation to be explicit about window flash behavior
2021-07-24 20:41:55 +00:00
} SDL_FlashOperation;
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Sync SDL3 wiki -> header
2024-04-11 12:59:41 +00:00
* An opaque handle to an OpenGL context.
include: Add `\since` to all documentation that was missing it.
2024-04-11 17:34:29 +00:00
*
* \since This datatype is available since SDL 3.0.0.
SDL_video.h: Added a `\sa` from SDL_GLContext to SDL_GL_CreateContext.
2024-05-09 17:51:26 +00:00
*
* \sa SDL_GL_CreateContext
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
typedef void *SDL_GLContext;
egl: implement public functions to obtain internal EGL handles These functions allow applications to call EGL functions against the SDL EGL context. For example, applications can use an EGL API loader via SDL_EGL_GetCurrentDisplay and SDL_EGL_GetProcAddress, and can call functions such as eglQuerySurface against the internal EGLSurface and EGLDisplay.
2022-08-26 02:44:35 +00:00
/**
Sync SDL3 wiki -> header
2024-04-11 12:59:41 +00:00
* Opaque EGL types.
include: Add `\since` to all documentation that was missing it.
2024-04-11 17:34:29 +00:00
*
* \since This datatype is available since SDL 3.0.0.
egl: implement public functions to obtain internal EGL handles These functions allow applications to call EGL functions against the SDL EGL context. For example, applications can use an EGL API loader via SDL_EGL_GetCurrentDisplay and SDL_EGL_GetProcAddress, and can call functions such as eglQuerySurface against the internal EGLSurface and EGLDisplay.
2022-08-26 02:44:35 +00:00
*/
typedef void *SDL_EGLDisplay;
typedef void *SDL_EGLConfig;
typedef void *SDL_EGLSurface;
egl: implement callbacks for defining custom EGL attributes Depending on the underlying EGL library, it may be desirable to conditionally set some specific EGL attributes depending on available extensions and other application state. SDL's EGL usage makes this a little bit complicated because: - there are multiple functions used to set up a working EGL context - some of these functions take different types of EGL attributes (EGLAttrib vs EGLint) - the EGL extension list before creating an EGLDisplay differs from the extension list after (i.e. display vs client extensions) - all of the above happens in a single SDL_CreateWindow call This leaves no place for the application to discover what EGL extensions are available and provide custom attribute lists. Until now, if a developer wants to add a custom EGL attribute for eglGetPlatformDisplay, eglCreateWindowSurface or eglCreateContext, they needed to patch SDL itself. This is very undesirable, since such developers would have to disable the SDL dynapi in order to maintain compatibility with their needs. This patch implements some callbacks which developers can use to dynamically generate custom EGL attributes for SDL to use during SDL_CreateWindow.
2022-08-26 05:41:06 +00:00
typedef intptr_t SDL_EGLAttrib;
typedef int SDL_EGLint;
/**
Sync SDL3 wiki -> header
2024-04-11 12:59:41 +00:00
* EGL attribute initialization callback types.
include: Add `\since` to all documentation that was missing it.
2024-04-11 17:34:29 +00:00
*
* \since This datatype is available since SDL 3.0.0.
egl: implement callbacks for defining custom EGL attributes Depending on the underlying EGL library, it may be desirable to conditionally set some specific EGL attributes depending on available extensions and other application state. SDL's EGL usage makes this a little bit complicated because: - there are multiple functions used to set up a working EGL context - some of these functions take different types of EGL attributes (EGLAttrib vs EGLint) - the EGL extension list before creating an EGLDisplay differs from the extension list after (i.e. display vs client extensions) - all of the above happens in a single SDL_CreateWindow call This leaves no place for the application to discover what EGL extensions are available and provide custom attribute lists. Until now, if a developer wants to add a custom EGL attribute for eglGetPlatformDisplay, eglCreateWindowSurface or eglCreateContext, they needed to patch SDL itself. This is very undesirable, since such developers would have to disable the SDL dynapi in order to maintain compatibility with their needs. This patch implements some callbacks which developers can use to dynamically generate custom EGL attributes for SDL to use during SDL_CreateWindow.
2022-08-26 05:41:06 +00:00
*/
typedef SDL_EGLAttrib *(SDLCALL *SDL_EGLAttribArrayCallback)(void);
typedef SDL_EGLint *(SDLCALL *SDL_EGLIntArrayCallback)(void);
egl: implement public functions to obtain internal EGL handles These functions allow applications to call EGL functions against the SDL EGL context. For example, applications can use an EGL API loader via SDL_EGL_GetCurrentDisplay and SDL_EGL_GetProcAddress, and can call functions such as eglQuerySurface against the internal EGLSurface and EGLDisplay.
2022-08-26 02:44:35 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
* An enumeration of OpenGL configuration attributes.
*
Sync SDL3 wiki -> headers
2024-04-09 04:49:23 +00:00
* While you can set most OpenGL attributes normally, the attributes listed
* above must be known before SDL creates the window that will be used with
* the OpenGL context. These attributes are set and read with
* SDL_GL_SetAttribute() and SDL_GL_GetAttribute().
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
*
Sync SDL3 wiki -> headers
2024-04-09 04:49:23 +00:00
* In some cases, these attributes are minimum requests; the GL does not
* promise to give you exactly what you asked for. It's possible to ask for a
* 16-bit depth buffer and get a 24-bit one instead, for example, or to ask
* for no stencil buffer and still have one available. Context creation should
* fail if the GL can't provide your requested attributes at a minimum, but
* you should check to see exactly what you got.
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
*
* \since This enum is available since SDL 3.0.0.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
typedef enum SDL_GLattr
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
{
SDL_GL_RED_SIZE,
SDL_GL_GREEN_SIZE,
SDL_GL_BLUE_SIZE,
SDL_GL_ALPHA_SIZE,
SDL_GL_BUFFER_SIZE,
SDL_GL_DOUBLEBUFFER,
SDL_GL_DEPTH_SIZE,
SDL_GL_STENCIL_SIZE,
SDL_GL_ACCUM_RED_SIZE,
SDL_GL_ACCUM_GREEN_SIZE,
SDL_GL_ACCUM_BLUE_SIZE,
SDL_GL_ACCUM_ALPHA_SIZE,
SDL_GL_STEREO,
SDL_GL_MULTISAMPLEBUFFERS,
SDL_GL_MULTISAMPLESAMPLES,
SDL_GL_ACCELERATED_VISUAL,
SDL_GL_RETAINED_BACKING,
SDL_GL_CONTEXT_MAJOR_VERSION,
SDL_GL_CONTEXT_MINOR_VERSION,
SDL_GL_CONTEXT_FLAGS,
SDL_GL_CONTEXT_PROFILE_MASK,
SDL_GL_SHARE_WITH_CURRENT_CONTEXT,
SDL_GL_FRAMEBUFFER_SRGB_CAPABLE,
opengl: Add support for [GLX|WGL]_ARB_create_context_robustness. This patch was originally written by Marc Di Luzio for glX and enhanced by Maximilian Malek for WGL, etc. Thanks to both of you! Fixes Bugzilla #3643. Fixes Bugzilla #3735.
2017-08-19 19:02:03 +00:00
SDL_GL_CONTEXT_RELEASE_BEHAVIOR,
opengl: add support for GL_KHR_no_error. This is completely untested! Fixes Bugzilla #3721.
2017-08-25 01:30:53 +00:00
SDL_GL_CONTEXT_RESET_NOTIFICATION,
SDL_video: Added SDL_GL_FLOATBUFFERS to allow Cocoa GL contexts to use EDR
2022-07-06 19:12:30 +00:00
SDL_GL_CONTEXT_NO_ERROR,
egl: implement SDL_GL_EGL_PLATFORM attribute This implements a new SDL_GL_EGL_PLATFORM attribute to set the "platform" argument for SDL_EGL_LoadLibrary on Windows, macOS, and Linux. I've limited it to those three operating systems because that's what I've been able to test against.
2022-08-26 03:29:41 +00:00
SDL_GL_FLOATBUFFERS,
SDL_GL_EGL_PLATFORM
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
} SDL_GLattr;
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
/**
* Possible values to be set for the SDL_GL_CONTEXT_PROFILE_MASK attribute.
*
* \since This enum is available since SDL 3.0.0.
*/
typedef enum SDL_GLprofile
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
{
SDL_GL_CONTEXT_PROFILE_CORE = 0x0001,
SDL_GL_CONTEXT_PROFILE_COMPATIBILITY = 0x0002,
Fixed comments in headers for doxygen output.
2017-06-04 21:15:39 +00:00
SDL_GL_CONTEXT_PROFILE_ES = 0x0004 /**< GLX_CONTEXT_ES2_PROFILE_BIT_EXT */
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
} SDL_GLprofile;
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
/**
* Possible values to be set for the SDL_GL_CONTEXT_FLAGS attribute.
*
* \since This enum is available since SDL 3.0.0.
*/
typedef enum SDL_GLcontextFlag
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
{
SDL_GL_CONTEXT_DEBUG_FLAG = 0x0001,
SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG = 0x0002,
SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG = 0x0004,
SDL_GL_CONTEXT_RESET_ISOLATION_FLAG = 0x0008
} SDL_GLcontextFlag;
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
/**
Sync SDL3 wiki -> headers
2024-04-09 04:49:23 +00:00
* Possible values to be set for the SDL_GL_CONTEXT_RELEASE_BEHAVIOR
* attribute.
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
*
* \since This enum is available since SDL 3.0.0.
*/
typedef enum SDL_GLcontextReleaseFlag
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
{
SDL_GL_CONTEXT_RELEASE_BEHAVIOR_NONE = 0x0000,
SDL_GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH = 0x0001
} SDL_GLcontextReleaseFlag;
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
/**
* Possible values to be set SDL_GL_CONTEXT_RESET_NOTIFICATION attribute.
*
* \since This enum is available since SDL 3.0.0.
*/
typedef enum SDL_GLContextResetNotification
opengl: Add support for [GLX|WGL]_ARB_create_context_robustness. This patch was originally written by Marc Di Luzio for glX and enhanced by Maximilian Malek for WGL, etc. Thanks to both of you! Fixes Bugzilla #3643. Fixes Bugzilla #3735.
2017-08-19 19:02:03 +00:00
{
SDL_GL_CONTEXT_RESET_NO_NOTIFICATION = 0x0000,
SDL_GL_CONTEXT_RESET_LOSE_CONTEXT = 0x0001
} SDL_GLContextResetNotification;
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/* Function prototypes */
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the number of video drivers compiled into SDL.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \returns a number >= 1 on success or a negative error code on failure; call
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetVideoDriver
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GetNumVideoDrivers(void);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the name of a built in video driver.
*
* The video drivers are presented in the order in which they are normally
* checked during initialization.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param index the index of a video driver
* \returns the name of the video driver with the given **index**.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetNumVideoDrivers
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC const char *SDLCALL SDL_GetVideoDriver(int index);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the name of the currently initialized video driver.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \returns the name of the current video driver or NULL if no driver has been
* initialized.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \sa SDL_GetNumVideoDrivers
* \sa SDL_GetVideoDriver
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC const char *SDLCALL SDL_GetCurrentVideoDriver(void);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
Added SDL_GetSystemTheme() to return whether the system is using a dark or light color theme, and SDL_EVENT_SYSTEM_THEME_CHANGED is sent when this changes Fixes https://github.com/libsdl-org/SDL/issues/5334 Fixes https://github.com/libsdl-org/SDL/issues/6958 Closes https://github.com/libsdl-org/SDL/pull/6440
2023-03-07 08:01:34 +00:00
/**
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
* Get the current system theme.
Added SDL_GetSystemTheme() to return whether the system is using a dark or light color theme, and SDL_EVENT_SYSTEM_THEME_CHANGED is sent when this changes Fixes https://github.com/libsdl-org/SDL/issues/5334 Fixes https://github.com/libsdl-org/SDL/issues/6958 Closes https://github.com/libsdl-org/SDL/pull/6440
2023-03-07 08:01:34 +00:00
*
* \returns the current system theme, light, dark, or unknown
*
* \since This function is available since SDL 3.0.0.
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_SystemTheme SDLCALL SDL_GetSystemTheme(void);
Added SDL_GetSystemTheme() to return whether the system is using a dark or light color theme, and SDL_EVENT_SYSTEM_THEME_CHANGED is sent when this changes Fixes https://github.com/libsdl-org/SDL/issues/5334 Fixes https://github.com/libsdl-org/SDL/issues/6958 Closes https://github.com/libsdl-org/SDL/pull/6440
2023-03-07 08:01:34 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* Get a list of currently connected displays.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \param count a pointer filled in with the number of displays returned
Sync SDL3 wiki -> header
2023-01-30 03:26:14 +00:00
* \returns a 0 terminated array of display instance IDs which should be freed
* with SDL_free(), or NULL on error; call SDL_GetError() for more
* details.
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
*
* \since This function is available since SDL 3.0.0.
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_DisplayID *SDLCALL SDL_GetDisplays(int *count);
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
/**
* Return the primary display.
*
Sync SDL3 wiki -> header
2023-01-30 03:26:14 +00:00
* \returns the instance ID of the primary display on success or 0 on failure;
* call SDL_GetError() for more information.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \sa SDL_GetDisplays
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_DisplayID SDLCALL SDL_GetPrimaryDisplay(void);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
Added display properties
2023-11-07 17:58:49 +00:00
/**
* Get the properties associated with a display.
*
Added HDR display properties and related event Also added an HDR calibration stage to testcolorspace
2024-02-06 09:53:03 +00:00
* The following read-only properties are provided by SDL:
*
Sync SDL3 wiki -> header
2024-02-25 23:55:23 +00:00
* - `SDL_PROP_DISPLAY_HDR_ENABLED_BOOLEAN`: true if the display has HDR
* headroom above the SDR white point. This property can change dynamically
* when SDL_EVENT_DISPLAY_HDR_STATE_CHANGED is sent.
Sync SDL3 wiki -> header
2024-02-22 03:26:22 +00:00
* - `SDL_PROP_DISPLAY_SDR_WHITE_POINT_FLOAT`: the value of SDR white in the
* SDL_COLORSPACE_SRGB_LINEAR colorspace. On Windows this corresponds to the
* SDR white level in scRGB colorspace, and on Apple platforms this is
Sync SDL3 wiki -> header
2024-02-25 23:55:23 +00:00
* always 1.0 for EDR content. This property can change dynamically when
* SDL_EVENT_DISPLAY_HDR_STATE_CHANGED is sent.
Sync SDL3 wiki -> header
2024-02-22 03:26:22 +00:00
* - `SDL_PROP_DISPLAY_HDR_HEADROOM_FLOAT`: the additional high dynamic range
* that can be displayed, in terms of the SDR white point. When HDR is not
Sync SDL3 wiki -> header
2024-02-25 23:55:23 +00:00
* enabled, this will be 1.0. This property can change dynamically when
* SDL_EVENT_DISPLAY_HDR_STATE_CHANGED is sent.
Added HDR display properties and related event Also added an HDR calibration stage to testcolorspace
2024-02-06 09:53:03 +00:00
*
kmsdrm: Report the panel orientation hint property Queries the "panel orientation" property on the connector and reports it in degrees of clockwise rotation via the 'SDL.display.KMSDRM.panel_orientation' display property. This is provided by the kernel as a hint to userspace applications, and the application itself is ultimately responsible for any required coordinate transformations needed to conform to the requested orientation.
2024-05-05 15:05:15 +00:00
* On KMS/DRM:
*
Sync SDL3 wiki -> header
2024-05-08 16:56:38 +00:00
* - `SDL_PROP_DISPLAY_KMSDRM_ORIENTATION_NUMBER`: the "panel orientation"
* property for the display in degrees of clockwise rotation. Note that this
* is provided only as a hint, and the application is responsible for any
* coordinate transformations needed to conform to the requested display
* orientation.
kmsdrm: Report the panel orientation hint property Queries the "panel orientation" property on the connector and reports it in degrees of clockwise rotation via the 'SDL.display.KMSDRM.panel_orientation' display property. This is provided by the kernel as a hint to userspace applications, and the application itself is ultimately responsible for any required coordinate transformations needed to conform to the requested orientation.
2024-05-05 15:05:15 +00:00
*
Added display properties
2023-11-07 17:58:49 +00:00
* \param displayID the instance ID of the display to query
* \returns a valid property ID on success or 0 on failure; call
* SDL_GetError() for more information.
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_GetProperty
* \sa SDL_SetProperty
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_PropertiesID SDLCALL SDL_GetDisplayProperties(SDL_DisplayID displayID);
Added display properties
2023-11-07 17:58:49 +00:00
kmsdrm: Report the panel orientation hint property Queries the "panel orientation" property on the connector and reports it in degrees of clockwise rotation via the 'SDL.display.KMSDRM.panel_orientation' display property. This is provided by the kernel as a hint to userspace applications, and the application itself is ultimately responsible for any required coordinate transformations needed to conform to the requested orientation.
2024-05-05 15:05:15 +00:00
#define SDL_PROP_DISPLAY_HDR_ENABLED_BOOLEAN "SDL.display.HDR_enabled"
#define SDL_PROP_DISPLAY_SDR_WHITE_POINT_FLOAT "SDL.display.SDR_white_point"
#define SDL_PROP_DISPLAY_HDR_HEADROOM_FLOAT "SDL.display.HDR_headroom"
#define SDL_PROP_DISPLAY_KMSDRM_PANEL_ORIENTATION_NUMBER "SDL.display.KMSDRM.panel_orientation"
Added HDR display properties and related event Also added an HDR calibration stage to testcolorspace
2024-02-06 09:53:03 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the name of a display in UTF-8 encoding.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \param displayID the instance ID of the display to query
Sync SDL3 wiki -> header
2023-01-30 03:26:14 +00:00
* \returns the name of a display or NULL on failure; call SDL_GetError() for
* more information.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \sa SDL_GetDisplays
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC const char *SDLCALL SDL_GetDisplayName(SDL_DisplayID displayID);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
* Get the desktop area represented by a display.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* The primary display is always located at (0,0).
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \param displayID the instance ID of the display to query
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param rect the SDL_Rect structure filled in with the display bounds
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \sa SDL_GetDisplayUsableBounds
* \sa SDL_GetDisplays
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GetDisplayBounds(SDL_DisplayID displayID, SDL_Rect *rect);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
Added SDL_GetDisplayUsableBounds().
2016-01-05 04:52:40 +00:00
/**
Sync wiki -> headers.
2023-01-25 17:58:29 +00:00
* Get the usable desktop area represented by a display, in screen
* coordinates.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* This is the same area as SDL_GetDisplayBounds() reports, but with portions
* reserved by the system removed. For example, on Apple's macOS, this
* subtracts the area occupied by the menu bar and dock.
*
* Setting a window to be fullscreen generally bypasses these unusable areas,
* so these are good guidelines for the maximum space available to a
* non-fullscreen window.
*
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \param displayID the instance ID of the display to query
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param rect the SDL_Rect structure filled in with the display bounds
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Added SDL_GetDisplayUsableBounds().
2016-01-05 04:52:40 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Added SDL_GetDisplayUsableBounds().
2016-01-05 04:52:40 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetDisplayBounds
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \sa SDL_GetDisplays
Added SDL_GetDisplayUsableBounds().
2016-01-05 04:52:40 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GetDisplayUsableBounds(SDL_DisplayID displayID, SDL_Rect *rect);
Added SDL_GetDisplayUsableBounds().
2016-01-05 04:52:40 +00:00
Added the concept of display natural orientation Also renamed SDL_GetDisplayOrientation() SDL_GetDisplayCurrentOrientation() The natural orientation of the primary display is the frame of reference for accelerometer and gyro sensor readings.
2023-06-17 07:52:40 +00:00
/**
* Get the orientation of a display when it is unrotated.
*
* \param displayID the instance ID of the display to query
* \returns The SDL_DisplayOrientation enum value of the display, or
* `SDL_ORIENTATION_UNKNOWN` if it isn't available.
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_GetDisplays
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_DisplayOrientation SDLCALL SDL_GetNaturalDisplayOrientation(SDL_DisplayID displayID);
Added the concept of display natural orientation Also renamed SDL_GetDisplayOrientation() SDL_GetDisplayCurrentOrientation() The natural orientation of the primary display is the frame of reference for accelerometer and gyro sensor readings.
2023-06-17 07:52:40 +00:00
Added SDL_GetDisplayOrientation() to get the display orientation, and added a new event SDL_DISPLAYEVENT to notify the application when the orientation changes. Documented the values returned by the accelerometer and gyroscope sensors
2018-08-23 04:48:28 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the orientation of a display.
Added SDL_GetDisplayOrientation() to get the display orientation, and added a new event SDL_DISPLAYEVENT to notify the application when the orientation changes. Documented the values returned by the accelerometer and gyroscope sensors
2018-08-23 04:48:28 +00:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \param displayID the instance ID of the display to query
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \returns The SDL_DisplayOrientation enum value of the display, or
* `SDL_ORIENTATION_UNKNOWN` if it isn't available.
Added SDL_GetDisplayOrientation() to get the display orientation, and added a new event SDL_DISPLAYEVENT to notify the application when the orientation changes. Documented the values returned by the accelerometer and gyroscope sensors
2018-08-23 04:48:28 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \sa SDL_GetDisplays
Added SDL_GetDisplayOrientation() to get the display orientation, and added a new event SDL_DISPLAYEVENT to notify the application when the orientation changes. Documented the values returned by the accelerometer and gyroscope sensors
2018-08-23 04:48:28 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_DisplayOrientation SDLCALL SDL_GetCurrentDisplayOrientation(SDL_DisplayID displayID);
Added SDL_GetDisplayOrientation() to get the display orientation, and added a new event SDL_DISPLAYEVENT to notify the application when the orientation changes. Documented the values returned by the accelerometer and gyroscope sensors
2018-08-23 04:48:28 +00:00
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
/**
* Get the content scale of a display.
*
Sync SDL3 wiki -> header
2023-05-17 19:59:14 +00:00
* The content scale is the expected scale for content based on the DPI
* settings of the display. For example, a 4K display might have a 2.0 (200%)
* display scale, which means that the user expects UI elements to be twice as
* big on this display, to aid in readability.
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
*
* \param displayID the instance ID of the display to query
Sync SDL3 wiki -> header
2023-05-17 19:59:14 +00:00
* \returns The content scale of the display, or 0.0f on error; call
* SDL_GetError() for more details.
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_GetDisplays
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC float SDLCALL SDL_GetDisplayContentScale(SDL_DisplayID displayID);
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
* Get a list of fullscreen display modes available on a display.
*
* The display modes are sorted in this priority:
Sync wiki -> headers.
2023-02-24 16:49:41 +00:00
*
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
* - w -> largest to smallest
* - h -> largest to smallest
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
* - bits per pixel -> more colors to fewer colors
* - packed pixel layout -> largest to smallest
* - refresh rate -> highest to lowest
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
* - pixel density -> lowest to highest
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \param displayID the instance ID of the display to query
Sync SDL3 wiki -> header
2024-04-13 01:10:12 +00:00
* \param count a pointer filled in with the number of display modes returned
Sync wiki -> headers.
2023-02-24 16:49:41 +00:00
* \returns a NULL terminated array of display mode pointers which should be
* freed with SDL_free(), or NULL on error; call SDL_GetError() for
* more details.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \sa SDL_GetDisplays
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC const SDL_DisplayMode **SDLCALL SDL_GetFullscreenDisplayModes(SDL_DisplayID displayID, int *count);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
* Get the closest match to the requested display mode.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
* The available display modes are scanned and `closest` is filled in with the
* closest mode matching the requested mode and returned. The mode format and
* refresh rate default to the desktop mode if they are set to 0. The modes
* are scanned with size being first priority, format being second priority,
* and finally checking the refresh rate. If all the available modes are too
* small, then NULL is returned.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \param displayID the instance ID of the display to query
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
* \param w the width in pixels of the desired display mode
* \param h the height in pixels of the desired display mode
Sync wiki -> headers.
2023-02-24 16:49:41 +00:00
* \param refresh_rate the refresh rate of the desired display mode, or 0.0f
* for the desktop refresh rate
Sync SDL3 wiki -> header
2023-06-22 13:45:16 +00:00
* \param include_high_density_modes Boolean to include high density modes in
* the search
Sync wiki -> headers.
2023-02-24 16:49:41 +00:00
* \returns a pointer to the closest display mode equal to or larger than the
* desired mode, or NULL on error; call SDL_GetError() for more
* information.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
* \sa SDL_GetDisplays
* \sa SDL_GetFullscreenDisplayModes
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC const SDL_DisplayMode *SDLCALL SDL_GetClosestFullscreenDisplayMode(SDL_DisplayID displayID, int w, int h, float refresh_rate, SDL_bool include_high_density_modes);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get information about the desktop's display mode.
*
* There's a difference between this function and SDL_GetCurrentDisplayMode()
* when SDL runs fullscreen and has changed the resolution. In that case this
* function will return the previous native display mode, and not the current
* display mode.
*
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \param displayID the instance ID of the display to query
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
* \returns a pointer to the desktop display mode or NULL on error; call
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetCurrentDisplayMode
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
* \sa SDL_GetDisplays
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC const SDL_DisplayMode *SDLCALL SDL_GetDesktopDisplayMode(SDL_DisplayID displayID);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get information about the current display mode.
*
* There's a difference between this function and SDL_GetDesktopDisplayMode()
* when SDL runs fullscreen and has changed the resolution. In that case this
* function will return the current display mode, and not the previous native
* display mode.
*
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \param displayID the instance ID of the display to query
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
* \returns a pointer to the desktop display mode or NULL on error; call
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetDesktopDisplayMode
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \sa SDL_GetDisplays
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC const SDL_DisplayMode *SDLCALL SDL_GetCurrentDisplayMode(SDL_DisplayID displayID);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
Add `SDL_GetPointDisplayIndex` and `SDL_GetRectDisplayIndex` and re-implement `SDL_GetWindowDisplayIndex` in terms of `SDL_GetRectDisplayIndex` - This allows looking up the display index for an arbitrary location rather than requiring an active window to do so. - This change also reimplements the fallback display lookup that found the display with center closest to the window's center to instead find the display rect edge closest to the window center (this was done in the almost identical display lookup used in SDL_windowsmodes.c, which now uses `SDL_GetPointDisplayIndex`). In practice this should almost never be hit as it requires the window's center to not be enclosed by any display rect.
2022-08-08 18:26:52 +00:00
/**
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
* Get the display containing a point.
Add `SDL_GetPointDisplayIndex` and `SDL_GetRectDisplayIndex` and re-implement `SDL_GetWindowDisplayIndex` in terms of `SDL_GetRectDisplayIndex` - This allows looking up the display index for an arbitrary location rather than requiring an active window to do so. - This change also reimplements the fallback display lookup that found the display with center closest to the window's center to instead find the display rect edge closest to the window center (this was done in the almost identical display lookup used in SDL_windowsmodes.c, which now uses `SDL_GetPointDisplayIndex`). In practice this should almost never be hit as it requires the window's center to not be enclosed by any display rect.
2022-08-08 18:26:52 +00:00
*
* \param point the point to query
Sync SDL3 wiki -> header
2023-01-30 03:26:14 +00:00
* \returns the instance ID of the display containing the point or 0 on
* failure; call SDL_GetError() for more information.
Add `SDL_GetPointDisplayIndex` and `SDL_GetRectDisplayIndex` and re-implement `SDL_GetWindowDisplayIndex` in terms of `SDL_GetRectDisplayIndex` - This allows looking up the display index for an arbitrary location rather than requiring an active window to do so. - This change also reimplements the fallback display lookup that found the display with center closest to the window's center to instead find the display rect edge closest to the window center (this was done in the almost identical display lookup used in SDL_windowsmodes.c, which now uses `SDL_GetPointDisplayIndex`). In practice this should almost never be hit as it requires the window's center to not be enclosed by any display rect.
2022-08-08 18:26:52 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
SDL_video.h: Added \since info to new APIs.
2022-08-09 13:05:08 +00:00
*
Add `SDL_GetPointDisplayIndex` and `SDL_GetRectDisplayIndex` and re-implement `SDL_GetWindowDisplayIndex` in terms of `SDL_GetRectDisplayIndex` - This allows looking up the display index for an arbitrary location rather than requiring an active window to do so. - This change also reimplements the fallback display lookup that found the display with center closest to the window's center to instead find the display rect edge closest to the window center (this was done in the almost identical display lookup used in SDL_windowsmodes.c, which now uses `SDL_GetPointDisplayIndex`). In practice this should almost never be hit as it requires the window's center to not be enclosed by any display rect.
2022-08-08 18:26:52 +00:00
* \sa SDL_GetDisplayBounds
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \sa SDL_GetDisplays
Add `SDL_GetPointDisplayIndex` and `SDL_GetRectDisplayIndex` and re-implement `SDL_GetWindowDisplayIndex` in terms of `SDL_GetRectDisplayIndex` - This allows looking up the display index for an arbitrary location rather than requiring an active window to do so. - This change also reimplements the fallback display lookup that found the display with center closest to the window's center to instead find the display rect edge closest to the window center (this was done in the almost identical display lookup used in SDL_windowsmodes.c, which now uses `SDL_GetPointDisplayIndex`). In practice this should almost never be hit as it requires the window's center to not be enclosed by any display rect.
2022-08-08 18:26:52 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_DisplayID SDLCALL SDL_GetDisplayForPoint(const SDL_Point *point);
Add `SDL_GetPointDisplayIndex` and `SDL_GetRectDisplayIndex` and re-implement `SDL_GetWindowDisplayIndex` in terms of `SDL_GetRectDisplayIndex` - This allows looking up the display index for an arbitrary location rather than requiring an active window to do so. - This change also reimplements the fallback display lookup that found the display with center closest to the window's center to instead find the display rect edge closest to the window center (this was done in the almost identical display lookup used in SDL_windowsmodes.c, which now uses `SDL_GetPointDisplayIndex`). In practice this should almost never be hit as it requires the window's center to not be enclosed by any display rect.
2022-08-08 18:26:52 +00:00
/**
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
* Get the display primarily containing a rect.
Add `SDL_GetPointDisplayIndex` and `SDL_GetRectDisplayIndex` and re-implement `SDL_GetWindowDisplayIndex` in terms of `SDL_GetRectDisplayIndex` - This allows looking up the display index for an arbitrary location rather than requiring an active window to do so. - This change also reimplements the fallback display lookup that found the display with center closest to the window's center to instead find the display rect edge closest to the window center (this was done in the almost identical display lookup used in SDL_windowsmodes.c, which now uses `SDL_GetPointDisplayIndex`). In practice this should almost never be hit as it requires the window's center to not be enclosed by any display rect.
2022-08-08 18:26:52 +00:00
*
* \param rect the rect to query
Sync SDL3 wiki -> header
2023-01-30 03:26:14 +00:00
* \returns the instance ID of the display entirely containing the rect or
* closest to the center of the rect on success or 0 on failure; call
* SDL_GetError() for more information.
Add `SDL_GetPointDisplayIndex` and `SDL_GetRectDisplayIndex` and re-implement `SDL_GetWindowDisplayIndex` in terms of `SDL_GetRectDisplayIndex` - This allows looking up the display index for an arbitrary location rather than requiring an active window to do so. - This change also reimplements the fallback display lookup that found the display with center closest to the window's center to instead find the display rect edge closest to the window center (this was done in the almost identical display lookup used in SDL_windowsmodes.c, which now uses `SDL_GetPointDisplayIndex`). In practice this should almost never be hit as it requires the window's center to not be enclosed by any display rect.
2022-08-08 18:26:52 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
SDL_video.h: Added \since info to new APIs.
2022-08-09 13:05:08 +00:00
*
Add `SDL_GetPointDisplayIndex` and `SDL_GetRectDisplayIndex` and re-implement `SDL_GetWindowDisplayIndex` in terms of `SDL_GetRectDisplayIndex` - This allows looking up the display index for an arbitrary location rather than requiring an active window to do so. - This change also reimplements the fallback display lookup that found the display with center closest to the window's center to instead find the display rect edge closest to the window center (this was done in the almost identical display lookup used in SDL_windowsmodes.c, which now uses `SDL_GetPointDisplayIndex`). In practice this should almost never be hit as it requires the window's center to not be enclosed by any display rect.
2022-08-08 18:26:52 +00:00
* \sa SDL_GetDisplayBounds
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \sa SDL_GetDisplays
Add `SDL_GetPointDisplayIndex` and `SDL_GetRectDisplayIndex` and re-implement `SDL_GetWindowDisplayIndex` in terms of `SDL_GetRectDisplayIndex` - This allows looking up the display index for an arbitrary location rather than requiring an active window to do so. - This change also reimplements the fallback display lookup that found the display with center closest to the window's center to instead find the display rect edge closest to the window center (this was done in the almost identical display lookup used in SDL_windowsmodes.c, which now uses `SDL_GetPointDisplayIndex`). In practice this should almost never be hit as it requires the window's center to not be enclosed by any display rect.
2022-08-08 18:26:52 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_DisplayID SDLCALL SDL_GetDisplayForRect(const SDL_Rect *rect);
Add `SDL_GetPointDisplayIndex` and `SDL_GetRectDisplayIndex` and re-implement `SDL_GetWindowDisplayIndex` in terms of `SDL_GetRectDisplayIndex` - This allows looking up the display index for an arbitrary location rather than requiring an active window to do so. - This change also reimplements the fallback display lookup that found the display with center closest to the window's center to instead find the display rect edge closest to the window center (this was done in the almost identical display lookup used in SDL_windowsmodes.c, which now uses `SDL_GetPointDisplayIndex`). In practice this should almost never be hit as it requires the window's center to not be enclosed by any display rect.
2022-08-08 18:26:52 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* Get the display associated with a window.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \param window the window to query
Sync SDL3 wiki -> header
2023-01-30 03:26:14 +00:00
* \returns the instance ID of the display containing the center of the window
* on success or 0 on failure; call SDL_GetError() for more
* information.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetDisplayBounds
Displays are now referenced by instance ID instead of index
2023-01-29 21:30:55 +00:00
* \sa SDL_GetDisplays
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_DisplayID SDLCALL SDL_GetDisplayForWindow(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
Officially added the concept of window pixel density The SDL_WINDOW_ALLOW_HIGHDPI flag has been renamed SDL_WINDOW_HIGH_PIXEL_DENSITY, and added the function SDL_GetWindowPixelDensity()
2023-05-17 23:39:15 +00:00
/**
* Get the pixel density of a window.
*
Sync SDL3 wiki -> header
2023-05-18 00:55:15 +00:00
* This is a ratio of pixel size to window size. For example, if the window is
* 1920x1080 and it has a high density back buffer of 3840x2160 pixels, it
* would have a pixel density of 2.0.
Officially added the concept of window pixel density The SDL_WINDOW_ALLOW_HIGHDPI flag has been renamed SDL_WINDOW_HIGH_PIXEL_DENSITY, and added the function SDL_GetWindowPixelDensity()
2023-05-17 23:39:15 +00:00
*
* \param window the window to query
Sync SDL3 wiki -> header
2023-05-18 00:55:15 +00:00
* \returns the pixel density or 0.0f on failure; call SDL_GetError() for more
* information.
Officially added the concept of window pixel density The SDL_WINDOW_ALLOW_HIGHDPI flag has been renamed SDL_WINDOW_HIGH_PIXEL_DENSITY, and added the function SDL_GetWindowPixelDensity()
2023-05-17 23:39:15 +00:00
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_GetWindowDisplayScale
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC float SDLCALL SDL_GetWindowPixelDensity(SDL_Window *window);
Officially added the concept of window pixel density The SDL_WINDOW_ALLOW_HIGHDPI flag has been renamed SDL_WINDOW_HIGH_PIXEL_DENSITY, and added the function SDL_GetWindowPixelDensity()
2023-05-17 23:39:15 +00:00
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
/**
* Get the content display scale relative to a window's pixel size.
*
Sync SDL3 wiki -> header
2023-05-17 19:59:14 +00:00
* This is a combination of the window pixel density and the display content
* scale, and is the expected scale for displaying content in this window. For
* example, if a 3840x2160 window had a display scale of 2.0, the user expects
* the content to take twice as many pixels and be the same physical size as
* if it were being displayed in a 1920x1080 window with a display scale of
* 1.0.
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
*
Sync SDL3 wiki -> header
2023-05-17 19:59:14 +00:00
* Conceptually this value corresponds to the scale display setting, and is
* updated when that setting is changed, or the window moves to a display with
* a different scale setting.
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
*
* \param window the window to query
Sync SDL3 wiki -> header
2023-05-17 19:59:14 +00:00
* \returns the display scale, or 0.0f on failure; call SDL_GetError() for
* more information.
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
*
* \since This function is available since SDL 3.0.0.
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC float SDLCALL SDL_GetWindowDisplayScale(SDL_Window *window);
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
* Set the display mode to use when a window is visible and fullscreen.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* This only affects the display mode used when the window is fullscreen. To
* change the window size when the window is not fullscreen, use
* SDL_SetWindowSize().
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* If the window is currently in the fullscreen state, this request is
* asynchronous on some windowing systems and the new mode dimensions may not
* be applied immediately upon the return of this function. If an immediate
* change is required, call SDL_SyncWindow() to block until the changes have
* taken effect.
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
* When the new mode takes effect, an SDL_EVENT_WINDOW_RESIZED and/or an
* SDL_EVENT_WINDOOW_PIXEL_SIZE_CHANGED event will be emitted with the new
* mode dimensions.
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to affect
Sync wiki -> headers.
2023-02-24 16:49:41 +00:00
* \param mode a pointer to the display mode to use, which can be NULL for
Sync SDL3 wiki -> header
2024-01-18 12:07:19 +00:00
* borderless fullscreen desktop mode, or one of the fullscreen
* modes returned by SDL_GetFullscreenDisplayModes() to set an
* exclusive fullscreen mode.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
* \sa SDL_GetWindowFullscreenMode
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_SetWindowFullscreen
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
* \sa SDL_SyncWindow
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowFullscreenMode(SDL_Window *window, const SDL_DisplayMode *mode);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Query the display mode to use when a window is visible at fullscreen.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to query
Sync SDL3 wiki -> header
2024-01-18 12:07:19 +00:00
* \returns a pointer to the exclusive fullscreen mode to use or NULL for
* borderless fullscreen desktop mode
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
* \sa SDL_SetWindowFullscreenMode
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_SetWindowFullscreen
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC const SDL_DisplayMode *SDLCALL SDL_GetWindowFullscreenMode(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
Add SDL_GetWindowICCProfile(). (#4314) * Add SDL_GetWindowICCProfile * Add new SDL display events * Implement ICC profile change event for macOS * Implement ICC profile notification for Windows * Fix SDL_GetWindowICCProfile() for X11 * Fix compile errors
2021-10-22 00:37:20 +00:00
/**
* Get the raw ICC profile data for the screen the window is currently on.
Sync wiki -> header
2021-10-22 00:39:04 +00:00
*
Add SDL_GetWindowICCProfile(). (#4314) * Add SDL_GetWindowICCProfile * Add new SDL display events * Implement ICC profile change event for macOS * Implement ICC profile notification for Windows * Fix SDL_GetWindowICCProfile() for X11 * Fix compile errors
2021-10-22 00:37:20 +00:00
* Data returned should be freed with SDL_free.
Sync wiki -> header
2021-10-22 00:39:04 +00:00
*
Add SDL_GetWindowICCProfile(). (#4314) * Add SDL_GetWindowICCProfile * Add new SDL display events * Implement ICC profile change event for macOS * Implement ICC profile notification for Windows * Fix SDL_GetWindowICCProfile() for X11 * Fix compile errors
2021-10-22 00:37:20 +00:00
* \param window the window to query
* \param size the size of the ICC profile
Sync wiki -> header
2021-10-22 00:39:04 +00:00
* \returns the raw ICC profile data on success or NULL on failure; call
* SDL_GetError() for more information.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Add SDL_GetWindowICCProfile(). (#4314) * Add SDL_GetWindowICCProfile * Add new SDL display events * Implement ICC profile change event for macOS * Implement ICC profile notification for Windows * Fix SDL_GetWindowICCProfile() for X11 * Fix compile errors
2021-10-22 00:37:20 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC void *SDLCALL SDL_GetWindowICCProfile(SDL_Window *window, size_t *size);
Add SDL_GetWindowICCProfile(). (#4314) * Add SDL_GetWindowICCProfile * Add new SDL display events * Implement ICC profile change event for macOS * Implement ICC profile notification for Windows * Fix SDL_GetWindowICCProfile() for X11 * Fix compile errors
2021-10-22 00:37:20 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the pixel format associated with the window.
*
* \param window the window to query
* \returns the pixel format of the window on success or
* SDL_PIXELFORMAT_UNKNOWN on failure; call SDL_GetError() for more
* information.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC Uint32 SDLCALL SDL_GetWindowPixelFormat(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Added SDL_CreateWindowWithPosition() It turns out there's a race condition on X11 where the window could be placed by the window manager while being placed by the application, so we need to have the initial position available at window creation.
2023-04-01 00:07:38 +00:00
* Create a window with the specified dimensions and flags.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* `flags` may be any of the following OR'd together:
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Folded SDL_WINDOW_FULLSCREEN_EXCLUSIVE and SDL_WINDOW_FULLSCREEN_DESKTOP into a single SDL_WINDOW_FULLSCREEN flag The fullscreen video mode used by the window can be used to determine whether it's in exclusive fullscreen or fullscreen desktop mode.
2023-02-01 19:30:28 +00:00
* - `SDL_WINDOW_FULLSCREEN`: fullscreen window at desktop resolution
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* - `SDL_WINDOW_OPENGL`: window usable with an OpenGL context
* - `SDL_WINDOW_VULKAN`: window usable with a Vulkan instance
* - `SDL_WINDOW_METAL`: window usable with a Metal instance
* - `SDL_WINDOW_HIDDEN`: window is not visible
* - `SDL_WINDOW_BORDERLESS`: no window decoration
* - `SDL_WINDOW_RESIZABLE`: window can be resized
* - `SDL_WINDOW_MINIMIZED`: window is minimized
* - `SDL_WINDOW_MAXIMIZED`: window is maximized
SDL_WINDOW_INPUT_GRABBED has been renamed SDL_WINDOW_MOUSE_GRABBED
2023-01-28 17:55:27 +00:00
* - `SDL_WINDOW_MOUSE_GRABBED`: window has grabbed mouse focus
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Remove SDL_WINDOW_SHOW flag, as redundant with SDL_WINDOW_HIDDEN
2022-12-28 19:17:55 +00:00
* The SDL_Window is implicitly shown if SDL_WINDOW_HIDDEN is not set.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* On Apple's macOS, you **must** set the NSHighResolutionCapable Info.plist
* property to YES, otherwise you will not receive a High-DPI OpenGL canvas.
*
Sync SDL3 wiki -> header
2023-05-17 19:59:14 +00:00
* The window pixel size may differ from its window coordinate size if the
* window is on a high pixel density display. Use SDL_GetWindowSize() to query
* the client area's size in window coordinates, and
* SDL_GetWindowSizeInPixels() or SDL_GetRenderOutputSize() to query the
* drawable size in pixels. Note that the drawable size can vary after the
* window is created and should be queried again if you get an
Renderer logical size is now implemented as a render target This fixes rounding errors with coordinate scaling and gives more flexibility in the presentation, as well as making it easy to maintain device independent resolution as windows move between different pixel density displays. By default when a renderer is created, it will match the window size so window coordinates and render coordinates are 1-1. Mouse and touch events are no longer filtered to change their coordinates, instead you can call SDL_ConvertEventToRenderCoordinates() to explicitly map event coordinates into the rendering viewport. SDL_RenderWindowToLogical() and SDL_RenderLogicalToWindow() have been renamed SDL_RenderCoordinatesFromWindow() and SDL_RenderCoordinatesToWindow() and take floating point coordinates in both directions. The viewport, clipping state, and scale for render targets are now persistent and will remain set whenever they are active.
2023-02-03 20:25:46 +00:00
* SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED event.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* If the window is created with any of the SDL_WINDOW_OPENGL or
* SDL_WINDOW_VULKAN flags, then the corresponding LoadLibrary function
* (SDL_GL_LoadLibrary or SDL_Vulkan_LoadLibrary) is called and the
* corresponding UnloadLibrary function is called by SDL_DestroyWindow().
*
* If SDL_WINDOW_VULKAN is specified and there isn't a working Vulkan driver,
* SDL_CreateWindow() will fail because SDL_Vulkan_LoadLibrary() will fail.
*
* If SDL_WINDOW_METAL is specified on an OS that does not support Metal,
* SDL_CreateWindow() will fail.
*
Sync SDL3 wiki -> header
2024-05-23 17:04:35 +00:00
* If you intend to use this window with an SDL_Renderer, you should use
* SDL_CreateWindowAndRenderer() instead of this function, to avoid window
* flicker.
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* On non-Apple devices, SDL requires you to either not link to the Vulkan
* loader or link to a dynamic library version. This limitation may be removed
* in a future version of SDL.
*
* \param title the title of the window, in UTF-8 encoding
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
* \param w the width of the window
* \param h the height of the window
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param flags 0, or one or more SDL_WindowFlags OR'd together
* \returns the window that was created or NULL on failure; call
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
video: Add the concept of child popup windows Add the CreatePopupWindow function to allow the creation of child tooltip and menu popup windows. Popup windows must be created as either a tooltip or popup menu and cannot be minimized, maximized, made fullscreen, or grab the mouse. Child popup windows are tracked and will be recursively hidden, shown, or destroyed in tandem with the parent window.
2023-02-26 19:16:05 +00:00
* \sa SDL_CreatePopupWindow
SDL_CreateWindowWithPosition() and SDL_CreateWindowFrom() have been replaced with SDL_CreateWindowWithProperties() This is a more general interface that can be extended in the future as needed.
2023-11-13 19:29:30 +00:00
* \sa SDL_CreateWindowWithProperties
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_DestroyWindow
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_Window *SDLCALL SDL_CreateWindow(const char *title, int w, int h, SDL_WindowFlags flags);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
video: Add the concept of child popup windows Add the CreatePopupWindow function to allow the creation of child tooltip and menu popup windows. Popup windows must be created as either a tooltip or popup menu and cannot be minimized, maximized, made fullscreen, or grab the mouse. Child popup windows are tracked and will be recursively hidden, shown, or destroyed in tandem with the parent window.
2023-02-26 19:16:05 +00:00
/**
* Create a child popup window of the specified parent window.
*
Sync SDL3 wiki -> header
2023-03-13 17:57:18 +00:00
* 'flags' **must** contain exactly one of the following: -
* 'SDL_WINDOW_TOOLTIP': The popup window is a tooltip and will not pass any
* input events. - 'SDL_WINDOW_POPUP_MENU': The popup window is a popup menu.
* The topmost popup menu will implicitly gain the keyboard focus.
*
Sync SDL3 wiki -> header
2023-11-30 15:22:19 +00:00
* The following flags are not relevant to popup window creation and will be
* ignored:
SDL_CreateWindowWithPosition() and SDL_CreateWindowFrom() have been replaced with SDL_CreateWindowWithProperties() This is a more general interface that can be extended in the future as needed.
2023-11-13 19:29:30 +00:00
*
* - 'SDL_WINDOW_MINIMIZED'
* - 'SDL_WINDOW_MAXIMIZED'
* - 'SDL_WINDOW_FULLSCREEN'
* - 'SDL_WINDOW_BORDERLESS'
Sync SDL3 wiki -> header
2023-03-10 23:52:18 +00:00
*
* The parent parameter **must** be non-null and a valid window. The parent of
* a popup window can be either a regular, toplevel window, or another popup
* window.
*
Sync SDL3 wiki -> header
2023-03-13 17:57:18 +00:00
* Popup windows cannot be minimized, maximized, made fullscreen, raised,
* flash, be made a modal window, be the parent of a modal window, or grab the
* mouse and/or keyboard. Attempts to do so will fail.
video: Update the popup window creation documentation and disallowed flags Update the popup window creation documentation with additional info, remove the SDL_WINDOW_MOUSE_GRABBED flag check since it isn't a valid window creation flag and will be removed automatically elsewhere, and check for and remove the explicit skip taskbar and borderless flags since they are implicit for popup windows.
2023-03-13 17:46:06 +00:00
*
* Popup windows implicitly do not have a border/decorations and do not appear
* on the taskbar/dock or in lists of windows such as alt-tab menus.
video: Add the concept of child popup windows Add the CreatePopupWindow function to allow the creation of child tooltip and menu popup windows. Popup windows must be created as either a tooltip or popup menu and cannot be minimized, maximized, made fullscreen, or grab the mouse. Child popup windows are tracked and will be recursively hidden, shown, or destroyed in tandem with the parent window.
2023-02-26 19:16:05 +00:00
*
* If a parent window is hidden, any child popup windows will be recursively
* hidden as well. Child popup windows not explicitly hidden will be restored
* when the parent is shown.
*
* If the parent window is destroyed, any child popup windows will be
* recursively destroyed as well.
*
* \param parent the parent of the window, must not be NULL
* \param offset_x the x position of the popup window relative to the origin
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
* of the parent
video: Add the concept of child popup windows Add the CreatePopupWindow function to allow the creation of child tooltip and menu popup windows. Popup windows must be created as either a tooltip or popup menu and cannot be minimized, maximized, made fullscreen, or grab the mouse. Child popup windows are tracked and will be recursively hidden, shown, or destroyed in tandem with the parent window.
2023-02-26 19:16:05 +00:00
* \param offset_y the y position of the popup window relative to the origin
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
* of the parent window
* \param w the width of the window
* \param h the height of the window
Sync SDL3 wiki -> header
2024-04-15 13:01:12 +00:00
* \param flags SDL_WINDOW_TOOLTIP or SDL_WINDOW_POPUP_MENU, and zero or more
video: Update the popup window creation documentation and disallowed flags Update the popup window creation documentation with additional info, remove the SDL_WINDOW_MOUSE_GRABBED flag check since it isn't a valid window creation flag and will be removed automatically elsewhere, and check for and remove the explicit skip taskbar and borderless flags since they are implicit for popup windows.
2023-03-13 17:46:06 +00:00
* additional SDL_WindowFlags OR'd together.
video: Add the concept of child popup windows Add the CreatePopupWindow function to allow the creation of child tooltip and menu popup windows. Popup windows must be created as either a tooltip or popup menu and cannot be minimized, maximized, made fullscreen, or grab the mouse. Child popup windows are tracked and will be recursively hidden, shown, or destroyed in tandem with the parent window.
2023-02-26 19:16:05 +00:00
* \returns the window that was created or NULL on failure; call
* SDL_GetError() for more information.
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_CreateWindow
SDL_CreateWindowWithPosition() and SDL_CreateWindowFrom() have been replaced with SDL_CreateWindowWithProperties() This is a more general interface that can be extended in the future as needed.
2023-11-13 19:29:30 +00:00
* \sa SDL_CreateWindowWithProperties
video: Add the concept of child popup windows Add the CreatePopupWindow function to allow the creation of child tooltip and menu popup windows. Popup windows must be created as either a tooltip or popup menu and cannot be minimized, maximized, made fullscreen, or grab the mouse. Child popup windows are tracked and will be recursively hidden, shown, or destroyed in tandem with the parent window.
2023-02-26 19:16:05 +00:00
* \sa SDL_DestroyWindow
Added SDL_GetWindowParent() to get the parent of popup windows
2023-03-13 18:20:42 +00:00
* \sa SDL_GetWindowParent
video: Add the concept of child popup windows Add the CreatePopupWindow function to allow the creation of child tooltip and menu popup windows. Popup windows must be created as either a tooltip or popup menu and cannot be minimized, maximized, made fullscreen, or grab the mouse. Child popup windows are tracked and will be recursively hidden, shown, or destroyed in tandem with the parent window.
2023-02-26 19:16:05 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_Window *SDLCALL SDL_CreatePopupWindow(SDL_Window *parent, int offset_x, int offset_y, int w, int h, SDL_WindowFlags flags);
video: Add the concept of child popup windows Add the CreatePopupWindow function to allow the creation of child tooltip and menu popup windows. Popup windows must be created as either a tooltip or popup menu and cannot be minimized, maximized, made fullscreen, or grab the mouse. Child popup windows are tracked and will be recursively hidden, shown, or destroyed in tandem with the parent window.
2023-02-26 19:16:05 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
SDL_CreateWindowWithPosition() and SDL_CreateWindowFrom() have been replaced with SDL_CreateWindowWithProperties() This is a more general interface that can be extended in the future as needed.
2023-11-13 19:29:30 +00:00
* Create a window with the specified properties.
SDL_CreateWindowFrom() now takes a set of properties that describe the native window and options.
2023-11-13 05:37:00 +00:00
*
* These are the supported properties:
Sync wiki -> headers.
2023-11-13 18:03:42 +00:00
*
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_CREATE_ALWAYS_ON_TOP_BOOLEAN`: true if the window should
* be always on top
* - `SDL_PROP_WINDOW_CREATE_BORDERLESS_BOOLEAN`: true if the window has no
* window decoration
Sync SDL3 wiki -> header
2024-02-12 17:55:23 +00:00
* - `SDL_PROP_WINDOW_CREATE_EXTERNAL_GRAPHICS_CONTEXT_BOOLEAN`: true if the
* window will be used with an externally managed graphics context.
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_CREATE_FOCUSABLE_BOOLEAN`: true if the window should
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* accept keyboard input (defaults true)
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_CREATE_FULLSCREEN_BOOLEAN`: true if the window should
* start in fullscreen mode at desktop resolution
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER`: the height of the window
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_CREATE_HIDDEN_BOOLEAN`: true if the window should start
* hidden
* - `SDL_PROP_WINDOW_CREATE_HIGH_PIXEL_DENSITY_BOOLEAN`: true if the window
* uses a high pixel density buffer if possible
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_CREATE_MAXIMIZED_BOOLEAN`: true if the window should
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* start maximized
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_CREATE_MENU_BOOLEAN`: true if the window is a popup menu
* - `SDL_PROP_WINDOW_CREATE_METAL_BOOLEAN`: true if the window will be used
* with Metal rendering
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_CREATE_MINIMIZED_BOOLEAN`: true if the window should
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* start minimized
Sync SDL3 wiki -> header
2024-04-30 17:48:27 +00:00
* - `SDL_PROP_WINDOW_CREATE_MODAL_BOOLEAN`: true if the window is modal to
* its parent
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_CREATE_MOUSE_GRABBED_BOOLEAN`: true if the window starts
* with grabbed mouse focus
* - `SDL_PROP_WINDOW_CREATE_OPENGL_BOOLEAN`: true if the window will be used
* with OpenGL rendering
* - `SDL_PROP_WINDOW_CREATE_PARENT_POINTER`: an SDL_Window that will be the
Sync SDL3 wiki -> header
2024-04-30 17:48:27 +00:00
* parent of this window, required for windows with the "toolip", "menu",
* and "modal" properties
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_CREATE_RESIZABLE_BOOLEAN`: true if the window should be
* resizable
* - `SDL_PROP_WINDOW_CREATE_TITLE_STRING`: the title of the window, in UTF-8
* encoding
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_CREATE_TRANSPARENT_BOOLEAN`: true if the window show
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* transparent in the areas with alpha of 0
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_CREATE_TOOLTIP_BOOLEAN`: true if the window is a tooltip
* - `SDL_PROP_WINDOW_CREATE_UTILITY_BOOLEAN`: true if the window is a utility
* window, not showing in the task bar and window list
* - `SDL_PROP_WINDOW_CREATE_VULKAN_BOOLEAN`: true if the window will be used
* with Vulkan rendering
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER`: the width of the window
* - `SDL_PROP_WINDOW_CREATE_X_NUMBER`: the x position of the window, or
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* `SDL_WINDOWPOS_CENTERED`, defaults to `SDL_WINDOWPOS_UNDEFINED`. This is
* relative to the parent for windows with the "parent" property set.
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_CREATE_Y_NUMBER`: the y position of the window, or
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* `SDL_WINDOWPOS_CENTERED`, defaults to `SDL_WINDOWPOS_UNDEFINED`. This is
* relative to the parent for windows with the "parent" property set.
SDL_CreateWindowFrom() now takes a set of properties that describe the native window and options.
2023-11-13 05:37:00 +00:00
*
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 17:13:18 +00:00
* These are additional supported properties on macOS:
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_CREATE_COCOA_WINDOW_POINTER`: the
Sync SDL3 wiki -> header
2024-01-08 17:16:19 +00:00
* `(__unsafe_unretained)` NSWindow associated with the window, if you want
* to wrap an existing window.
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_CREATE_COCOA_VIEW_POINTER`: the `(__unsafe_unretained)`
* NSView associated with the window, defaults to `[window contentView]`
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
wayland: Allow the creation of roleless window surfaces for custom application use Allow for the creation of SDL windows with a roleless surface that applications can use for their own purposes, such as with a windowing protocol other than XDG toplevel. The property `wayland.surface_role_custom` will create a window with a surface that SDL can render to and handles input for, but is not associated with a toplevel window, so applications can use it for their own, custom purposes (e.g. wlr_layer_shell). A test/minimal example is included in tests/testwaylandcustom.c
2024-01-06 20:37:38 +00:00
* These are additional supported properties on Wayland:
*
Sync SDL3 wiki -> header
2024-04-25 21:23:14 +00:00
* - `SDL_PROP_WINDOW_CREATE_WAYLAND_SURFACE_ROLE_CUSTOM_BOOLEAN` - true if
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* the application wants to use the Wayland surface for a custom role and
wayland: Allow the creation of roleless window surfaces for custom application use Allow for the creation of SDL windows with a roleless surface that applications can use for their own purposes, such as with a windowing protocol other than XDG toplevel. The property `wayland.surface_role_custom` will create a window with a surface that SDL can render to and handles input for, but is not associated with a toplevel window, so applications can use it for their own, custom purposes (e.g. wlr_layer_shell). A test/minimal example is included in tests/testwaylandcustom.c
2024-01-06 20:37:38 +00:00
* does not want it attached to an XDG toplevel window. See
Sync SDL3 wiki -> header
2024-04-25 21:23:14 +00:00
* [README/wayland](README/wayland) for more information on using custom
* surfaces.
Sync SDL3 wiki -> header
2024-04-25 20:40:14 +00:00
* - `SDL_PROP_WINDOW_CREATE_WAYLAND_CREATE_EGL_WINDOW_BOOLEAN` - true if the
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* application wants an associated `wl_egl_window` object to be created,
wayland: Add a property to allow creation of a wl_egl_window object even if OpenGL is not enabled Useful if the application handles OpenGL outside of SDL and wants to use the window without having to pull in Wayland as a dependency.
2024-01-07 17:25:49 +00:00
* even if the window does not have the OpenGL property or flag set.
Sync SDL3 wiki -> header
2024-04-25 21:23:14 +00:00
* - `SDL_PROP_WINDOW_CREATE_WAYLAND_WL_SURFACE_POINTER` - the wl_surface
wayland: Add the ability to import and wrap external surfaces Add the ability to import and wrap external surfaces from external toolkits such as Qt and GTK. Wayland surfaces and windows are more intrinsically tied to the client library than other windowing systems, so it is necessary to provide a way to initialize SDL with an existing wl_display object, which needs to be set prior to video system initialization, or export the internal SDL wl_display object for use by external applications or toolkits. For this, the global property SDL_PROPERTY_GLOBAL_VIDEO_WAYLAND_WL_DISPLAY_POINTER is used. A Wayland example was added to testnative, and a basic example of Qt 6 interoperation is provided in the Wayland readme to demonstrate the use of external windows with both SDL owning the wl_display, and an external toolkit owning it.
2024-01-09 16:38:38 +00:00
* associated with the window, if you want to wrap an existing window. See
Sync SDL3 wiki -> header
2024-04-25 21:23:14 +00:00
* [README/wayland](README/wayland) for more information.
wayland: Allow the creation of roleless window surfaces for custom application use Allow for the creation of SDL windows with a roleless surface that applications can use for their own purposes, such as with a windowing protocol other than XDG toplevel. The property `wayland.surface_role_custom` will create a window with a surface that SDL can render to and handles input for, but is not associated with a toplevel window, so applications can use it for their own, custom purposes (e.g. wlr_layer_shell). A test/minimal example is included in tests/testwaylandcustom.c
2024-01-06 20:37:38 +00:00
*
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 17:13:18 +00:00
* These are additional supported properties on Windows:
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_CREATE_WIN32_HWND_POINTER`: the HWND associated with the
* window, if you want to wrap an existing window.
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_CREATE_WIN32_PIXEL_FORMAT_HWND_POINTER`: optional,
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* another window to share pixel format with, useful for OpenGL windows
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 17:13:18 +00:00
* These are additional supported properties with X11:
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_CREATE_X11_WINDOW_NUMBER`: the X11 Window associated
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* with the window, if you want to wrap an existing window.
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 17:13:18 +00:00
* The window is implicitly shown if the "hidden" property is not set.
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
* Windows with the "tooltip" and "menu" properties are popup windows and have
Sync SDL3 wiki -> header
2024-04-25 20:40:14 +00:00
* the behaviors and guidelines outlined in SDL_CreatePopupWindow().
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
Sync SDL3 wiki -> header
2024-05-23 17:09:44 +00:00
* If this window is being created to be used with an SDL_Renderer, you should
* not add a graphics API specific property
* (`SDL_PROP_WINDOW_CREATE_OPENGL_BOOLEAN`, etc), as SDL will handle that
* internally when it chooses a renderer. However, SDL might need to recreate
* your window at that point, which may cause the window to appear briefly,
* and then flicker as it is recreated. The correct approach to this is to
* create the window with the `SDL_PROP_WINDOW_CREATE_HIDDEN_BOOLEAN` property
* set to true, then create the renderer, then show the window with
* SDL_ShowWindow().
*
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
* \param props the properties to use
* \returns the window that was created or NULL on failure; call
* SDL_GetError() for more information.
*
* \since This function is available since SDL 3.0.0.
*
Updated "see also" references to be more consistent Fixes https://github.com/libsdl-org/SDL/issues/9282
2024-03-17 18:00:15 +00:00
* \sa SDL_CreateProperties
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
* \sa SDL_CreateWindow
* \sa SDL_DestroyWindow
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_Window *SDLCALL SDL_CreateWindowWithProperties(SDL_PropertiesID props);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
Removed SDL_HINT_VIDEO_EXTERNAL_CONTEXT This is replaced with SDL_PROP_WINDOW_CREATE_EXTERNAL_GRAPHICS_CONTEXT in SDL_CreateWindowWithProperties()
2024-02-12 03:37:16 +00:00
#define SDL_PROP_WINDOW_CREATE_ALWAYS_ON_TOP_BOOLEAN "always_on_top"
Shortened SDL property names
2024-01-27 21:00:37 +00:00
#define SDL_PROP_WINDOW_CREATE_BORDERLESS_BOOLEAN "borderless"
#define SDL_PROP_WINDOW_CREATE_FOCUSABLE_BOOLEAN "focusable"
Removed SDL_HINT_VIDEO_EXTERNAL_CONTEXT This is replaced with SDL_PROP_WINDOW_CREATE_EXTERNAL_GRAPHICS_CONTEXT in SDL_CreateWindowWithProperties()
2024-02-12 03:37:16 +00:00
#define SDL_PROP_WINDOW_CREATE_EXTERNAL_GRAPHICS_CONTEXT_BOOLEAN "external_graphics_context"
Shortened SDL property names
2024-01-27 21:00:37 +00:00
#define SDL_PROP_WINDOW_CREATE_FULLSCREEN_BOOLEAN "fullscreen"
#define SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER "height"
#define SDL_PROP_WINDOW_CREATE_HIDDEN_BOOLEAN "hidden"
Removed SDL_HINT_VIDEO_EXTERNAL_CONTEXT This is replaced with SDL_PROP_WINDOW_CREATE_EXTERNAL_GRAPHICS_CONTEXT in SDL_CreateWindowWithProperties()
2024-02-12 03:37:16 +00:00
#define SDL_PROP_WINDOW_CREATE_HIGH_PIXEL_DENSITY_BOOLEAN "high_pixel_density"
Shortened SDL property names
2024-01-27 21:00:37 +00:00
#define SDL_PROP_WINDOW_CREATE_MAXIMIZED_BOOLEAN "maximized"
#define SDL_PROP_WINDOW_CREATE_MENU_BOOLEAN "menu"
#define SDL_PROP_WINDOW_CREATE_METAL_BOOLEAN "metal"
#define SDL_PROP_WINDOW_CREATE_MINIMIZED_BOOLEAN "minimized"
Add support for modal windows to more platforms - Adds support for modal windows to Win32, Mac, and Haiku, and enhances functionality on Wayland and X11, which previous set only the parent window, but not the modal state. - Windows can be declared modal at creation time, and the modal state can be toggled at any time via SDL_SetWindowModalFor() (tested with UE5 through sdl2-compat). - Allows dynamic unparenting/reparenting of windows. - Includes a modal window test.
2024-04-03 20:44:03 +00:00
#define SDL_PROP_WINDOW_CREATE_MODAL_BOOLEAN "modal"
Changed property name from '-' to '_'
2024-02-12 17:55:12 +00:00
#define SDL_PROP_WINDOW_CREATE_MOUSE_GRABBED_BOOLEAN "mouse_grabbed"
Shortened SDL property names
2024-01-27 21:00:37 +00:00
#define SDL_PROP_WINDOW_CREATE_OPENGL_BOOLEAN "opengl"
#define SDL_PROP_WINDOW_CREATE_PARENT_POINTER "parent"
#define SDL_PROP_WINDOW_CREATE_RESIZABLE_BOOLEAN "resizable"
#define SDL_PROP_WINDOW_CREATE_TITLE_STRING "title"
#define SDL_PROP_WINDOW_CREATE_TRANSPARENT_BOOLEAN "transparent"
#define SDL_PROP_WINDOW_CREATE_TOOLTIP_BOOLEAN "tooltip"
#define SDL_PROP_WINDOW_CREATE_UTILITY_BOOLEAN "utility"
#define SDL_PROP_WINDOW_CREATE_VULKAN_BOOLEAN "vulkan"
#define SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER "width"
#define SDL_PROP_WINDOW_CREATE_X_NUMBER "x"
#define SDL_PROP_WINDOW_CREATE_Y_NUMBER "y"
#define SDL_PROP_WINDOW_CREATE_COCOA_WINDOW_POINTER "cocoa.window"
#define SDL_PROP_WINDOW_CREATE_COCOA_VIEW_POINTER "cocoa.view"
#define SDL_PROP_WINDOW_CREATE_WAYLAND_SURFACE_ROLE_CUSTOM_BOOLEAN "wayland.surface_role_custom"
#define SDL_PROP_WINDOW_CREATE_WAYLAND_CREATE_EGL_WINDOW_BOOLEAN "wayland.create_egl_window"
#define SDL_PROP_WINDOW_CREATE_WAYLAND_WL_SURFACE_POINTER "wayland.wl_surface"
#define SDL_PROP_WINDOW_CREATE_WIN32_HWND_POINTER "win32.hwnd"
#define SDL_PROP_WINDOW_CREATE_WIN32_PIXEL_FORMAT_HWND_POINTER "win32.pixel_format_hwnd"
#define SDL_PROP_WINDOW_CREATE_X11_WINDOW_NUMBER "x11.window"
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 17:13:18 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the numeric ID of a window.
*
* The numeric ID is what SDL_WindowEvent references, and is necessary to map
* these events to specific SDL_Window objects.
*
* \param window the window to query
* \returns the ID of the window on success or 0 on failure; call
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \sa SDL_GetWindowFromID
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_WindowID SDLCALL SDL_GetWindowID(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get a window from a stored ID.
*
* The numeric ID is what SDL_WindowEvent references, and is necessary to map
* these events to specific SDL_Window objects.
*
* \param id the ID of the window
Sync wiki -> header.
2021-07-14 21:07:04 +00:00
* \returns the window associated with `id` or NULL if it doesn't exist; call
* SDL_GetError() for more information.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetWindowID
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_Window *SDLCALL SDL_GetWindowFromID(SDL_WindowID id);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
Added SDL_GetWindowParent() to get the parent of popup windows
2023-03-13 18:20:42 +00:00
/**
* Get parent of a window.
*
* \param window the window to query
Sync SDL3 wiki -> header
2023-03-13 18:22:16 +00:00
* \returns the parent of the window on success or NULL if the window has no
* parent.
Added SDL_GetWindowParent() to get the parent of popup windows
2023-03-13 18:20:42 +00:00
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_CreatePopupWindow
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_Window *SDLCALL SDL_GetWindowParent(SDL_Window *window);
Added SDL_GetWindowParent() to get the parent of popup windows
2023-03-13 18:20:42 +00:00
Added properties to various SDL objects The following objects now have properties that can be user modified: * SDL_AudioStream * SDL_Gamepad * SDL_Joystick * SDL_RWops * SDL_Renderer * SDL_Sensor * SDL_Surface * SDL_Texture * SDL_Window
2023-10-11 23:59:51 +00:00
/**
* Get the properties associated with a window.
*
Note that the SDL window properties are read-only
2023-11-13 21:58:33 +00:00
* The following read-only properties are provided by SDL:
Sync wiki -> headers.
2023-11-13 18:03:42 +00:00
*
Sync SDL3 wiki -> header
2024-02-10 00:05:26 +00:00
* - `SDL_PROP_WINDOW_SHAPE_POINTER`: the surface associated with a shaped
* window
Re-added a simplified version of SDL_SetWindowShape() In order to handle mouse click transparency this needs to be implemented inside SDL
2024-02-09 15:09:59 +00:00
*
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
* On Android:
*
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_ANDROID_WINDOW_POINTER`: the ANativeWindow associated
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* with the window
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_ANDROID_SURFACE_POINTER`: the EGLSurface associated with
* the window
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
* On iOS:
*
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_UIKIT_WINDOW_POINTER`: the `(__unsafe_unretained)`
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* UIWindow associated with the window
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_UIKIT_METAL_VIEW_TAG_NUMBER`: the NSInteger tag
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* assocated with metal views on the window
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
* On KMS/DRM:
*
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_KMSDRM_DEVICE_INDEX_NUMBER`: the device index associated
* with the window (e.g. the X in /dev/dri/cardX)
* - `SDL_PROP_WINDOW_KMSDRM_DRM_FD_NUMBER`: the DRM FD associated with the
* window
* - `SDL_PROP_WINDOW_KMSDRM_GBM_DEVICE_POINTER`: the GBM device associated
* with the window
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
* On macOS:
*
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_COCOA_WINDOW_POINTER`: the `(__unsafe_unretained)`
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* NSWindow associated with the window
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_COCOA_METAL_VIEW_TAG_NUMBER`: the NSInteger tag
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* assocated with metal views on the window
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
* On Vivante:
*
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_VIVANTE_DISPLAY_POINTER`: the EGLNativeDisplayType
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* associated with the window
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_VIVANTE_WINDOW_POINTER`: the EGLNativeWindowType
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* associated with the window
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_VIVANTE_SURFACE_POINTER`: the EGLSurface associated with
* the window
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
* On UWP:
*
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_WINRT_WINDOW_POINTER`: the IInspectable CoreWindow
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* associated with the window
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
* On Windows:
*
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_WIN32_HWND_POINTER`: the HWND associated with the window
* - `SDL_PROP_WINDOW_WIN32_HDC_POINTER`: the HDC associated with the window
* - `SDL_PROP_WINDOW_WIN32_INSTANCE_POINTER`: the HINSTANCE associated with
* the window
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
* On Wayland:
*
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 17:13:18 +00:00
* Note: The `xdg_*` window objects do not internally persist across window
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
* show/hide calls. They will be null if the window is hidden and must be
* queried each time it is shown.
*
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_WAYLAND_DISPLAY_POINTER`: the wl_display associated with
* the window
* - `SDL_PROP_WINDOW_WAYLAND_SURFACE_POINTER`: the wl_surface associated with
* the window
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_WAYLAND_EGL_WINDOW_POINTER`: the wl_egl_window
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* associated with the window
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_WAYLAND_XDG_SURFACE_POINTER`: the xdg_surface associated
* with the window
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_WAYLAND_XDG_TOPLEVEL_POINTER`: the xdg_toplevel role
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* associated with the window
wayland: Handle the toplevel export property as a string xdg-toplevel export handles are strings, so treat the property as one. Avoids the need to manually manage the string pointer.
2024-03-18 15:39:11 +00:00
* - 'SDL_PROP_WINDOW_WAYLAND_XDG_TOPLEVEL_EXPORT_HANDLE_STRING': the export
wayland: Add the xdg-foreign-unstable-v2 protocol Add the xdg-foreign-unstable-v2 protocol and use it to create export handles for toplevel windows, which will be used when an external component, such as the file chooser portal, requires it.
2024-03-15 15:36:05 +00:00
* handle associated with the window
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_WAYLAND_XDG_POPUP_POINTER`: the xdg_popup role
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* associated with the window
Shortened SDL property names
2024-01-27 21:00:37 +00:00
* - `SDL_PROP_WINDOW_WAYLAND_XDG_POSITIONER_POINTER`: the xdg_positioner
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* associated with the window, in popup mode
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 17:13:18 +00:00
*
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
* On X11:
*
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_X11_DISPLAY_POINTER`: the X11 Display associated with
Sync SDL3 wiki -> header
2024-01-08 17:34:23 +00:00
* the window
Sync SDL3 wiki -> header
2024-01-27 21:01:19 +00:00
* - `SDL_PROP_WINDOW_X11_SCREEN_NUMBER`: the screen number associated with
* the window
* - `SDL_PROP_WINDOW_X11_WINDOW_NUMBER`: the X11 Window associated with the
* window
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*
* \param window the window to query
* \returns a valid property ID on success or 0 on failure; call
* SDL_GetError() for more information.
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_GetProperty
Sync SDL3 wiki -> header
2024-04-15 19:13:11 +00:00
* \sa SDL_GetNumberProperty
Sync SDL3 wiki -> header
2024-01-08 01:02:25 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_PropertiesID SDLCALL SDL_GetWindowProperties(SDL_Window *window);
Added properties to various SDL objects The following objects now have properties that can be user modified: * SDL_AudioStream * SDL_Gamepad * SDL_Joystick * SDL_RWops * SDL_Renderer * SDL_Sensor * SDL_Surface * SDL_Texture * SDL_Window
2023-10-11 23:59:51 +00:00
wayland: Handle the toplevel export property as a string xdg-toplevel export handles are strings, so treat the property as one. Avoids the need to manually manage the string pointer.
2024-03-18 15:39:11 +00:00
#define SDL_PROP_WINDOW_SHAPE_POINTER "SDL.window.shape"
#define SDL_PROP_WINDOW_ANDROID_WINDOW_POINTER "SDL.window.android.window"
#define SDL_PROP_WINDOW_ANDROID_SURFACE_POINTER "SDL.window.android.surface"
#define SDL_PROP_WINDOW_UIKIT_WINDOW_POINTER "SDL.window.uikit.window"
#define SDL_PROP_WINDOW_UIKIT_METAL_VIEW_TAG_NUMBER "SDL.window.uikit.metal_view_tag"
#define SDL_PROP_WINDOW_KMSDRM_DEVICE_INDEX_NUMBER "SDL.window.kmsdrm.dev_index"
#define SDL_PROP_WINDOW_KMSDRM_DRM_FD_NUMBER "SDL.window.kmsdrm.drm_fd"
#define SDL_PROP_WINDOW_KMSDRM_GBM_DEVICE_POINTER "SDL.window.kmsdrm.gbm_dev"
#define SDL_PROP_WINDOW_COCOA_WINDOW_POINTER "SDL.window.cocoa.window"
#define SDL_PROP_WINDOW_COCOA_METAL_VIEW_TAG_NUMBER "SDL.window.cocoa.metal_view_tag"
#define SDL_PROP_WINDOW_VIVANTE_DISPLAY_POINTER "SDL.window.vivante.display"
#define SDL_PROP_WINDOW_VIVANTE_WINDOW_POINTER "SDL.window.vivante.window"
#define SDL_PROP_WINDOW_VIVANTE_SURFACE_POINTER "SDL.window.vivante.surface"
#define SDL_PROP_WINDOW_WINRT_WINDOW_POINTER "SDL.window.winrt.window"
#define SDL_PROP_WINDOW_WIN32_HWND_POINTER "SDL.window.win32.hwnd"
#define SDL_PROP_WINDOW_WIN32_HDC_POINTER "SDL.window.win32.hdc"
#define SDL_PROP_WINDOW_WIN32_INSTANCE_POINTER "SDL.window.win32.instance"
#define SDL_PROP_WINDOW_WAYLAND_DISPLAY_POINTER "SDL.window.wayland.display"
#define SDL_PROP_WINDOW_WAYLAND_SURFACE_POINTER "SDL.window.wayland.surface"
#define SDL_PROP_WINDOW_WAYLAND_EGL_WINDOW_POINTER "SDL.window.wayland.egl_window"
#define SDL_PROP_WINDOW_WAYLAND_XDG_SURFACE_POINTER "SDL.window.wayland.xdg_surface"
#define SDL_PROP_WINDOW_WAYLAND_XDG_TOPLEVEL_POINTER "SDL.window.wayland.xdg_toplevel"
#define SDL_PROP_WINDOW_WAYLAND_XDG_TOPLEVEL_EXPORT_HANDLE_STRING "SDL.window.wayland.xdg_toplevel_export_handle"
#define SDL_PROP_WINDOW_WAYLAND_XDG_POPUP_POINTER "SDL.window.wayland.xdg_popup"
#define SDL_PROP_WINDOW_WAYLAND_XDG_POSITIONER_POINTER "SDL.window.wayland.xdg_positioner"
#define SDL_PROP_WINDOW_X11_DISPLAY_POINTER "SDL.window.x11.display"
#define SDL_PROP_WINDOW_X11_SCREEN_NUMBER "SDL.window.x11.screen"
#define SDL_PROP_WINDOW_X11_WINDOW_NUMBER "SDL.window.x11.window"
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 17:13:18 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the window flags.
*
* \param window the window to query
* \returns a mask of the SDL_WindowFlags associated with `window`
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_CreateWindow
* \sa SDL_HideWindow
* \sa SDL_MaximizeWindow
* \sa SDL_MinimizeWindow
* \sa SDL_SetWindowFullscreen
Remove legacy SDL2 input grab API
2024-03-24 23:35:40 +00:00
* \sa SDL_SetWindowMouseGrab
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_ShowWindow
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_WindowFlags SDLCALL SDL_GetWindowFlags(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Set the title of a window.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* This string is expected to be in UTF-8 encoding.
*
* \param window the window to change
* \param title the desired window title in UTF-8 format
[SDL3] Cleanup void functions (#7253) Some functions that do call SDL_SetError but return void changed to instead return non-zero in case of errors.
2023-02-06 16:53:52 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetWindowTitle
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowTitle(SDL_Window *window, const char *title);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the title of a window.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to query
* \returns the title of the window in UTF-8 format or "" if there is no
* title.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_SetWindowTitle
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC const char *SDLCALL SDL_GetWindowTitle(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Set the icon for a window.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to change
* \param icon an SDL_Surface structure containing the icon for the window
[SDL3] Cleanup void functions (#7253) Some functions that do call SDL_SetError but return void changed to instead return non-zero in case of errors.
2023-02-06 16:53:52 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowIcon(SDL_Window *window, SDL_Surface *icon);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
* Request that the window's position be set.
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* If, at the time of this request, the window is in a fixed-size state such
* as maximized, this request may be deferred until the window returns to a
* resizable state.
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* This can be used to reposition fullscreen-desktop windows onto a different
* display, however, exclusive fullscreen windows are locked to a specific
* display and can only be repositioned programmatically via
* SDL_SetWindowFullscreenMode().
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* On some windowing systems this request is asynchronous and the new
* coordinates may not have have been applied immediately upon the return of
* this function. If an immediate change is required, call SDL_SyncWindow() to
* block until the changes have taken effect.
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
* When the window position changes, an SDL_EVENT_WINDOW_MOVED event will be
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* emitted with the window's new coordinates. Note that the new coordinates
* may not match the exact coordinates requested, as some windowing systems
* can restrict the position of the window in certain scenarios (e.g.
* constraining the position so the window is always within desktop bounds).
* Additionally, as this is just a request, it can be denied by the windowing
* system.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to reposition
Sync wiki -> headers.
2023-01-25 17:58:29 +00:00
* \param x the x coordinate of the window, or `SDL_WINDOWPOS_CENTERED` or
* `SDL_WINDOWPOS_UNDEFINED`
* \param y the y coordinate of the window, or `SDL_WINDOWPOS_CENTERED` or
* `SDL_WINDOWPOS_UNDEFINED`
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetWindowPosition
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
* \sa SDL_SyncWindow
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowPosition(SDL_Window *window, int x, int y);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
* Get the position of a window.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* This is the current position of the window as last reported by the
* windowing system.
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* If you do not need the value for one of the positions a NULL may be passed
* in the `x` or `y` parameter.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to query
SDL 3.0 is going to be high DPI aware and officially separates screen… (#7145) * SDL 3.0 is going to be high DPI aware and officially separates screen coordinates from client pixel area The public APIs to disable high DPI support have been removed Work in progress on https://github.com/libsdl-org/SDL/issues/7134
2023-01-25 09:23:17 +00:00
* \param x a pointer filled in with the x position of the window, may be NULL
* \param y a pointer filled in with the y position of the window, may be NULL
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_SetWindowPosition
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GetWindowPosition(SDL_Window *window, int *x, int *y);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
* Request that the size of a window's client area be set.
*
* NULL can safely be passed as the `w` or `h` parameter if the width or
* height value is not desired.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* If, at the time of this request, the window in a fixed-size state, such as
* maximized or fullscreen, the request will be deferred until the window
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
* exits this state and becomes resizable again.
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* To change the fullscreen mode of a window, use
* SDL_SetWindowFullscreenMode()
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* On some windowing systems, this request is asynchronous and the new window
* size may not have have been applied immediately upon the return of this
* function. If an immediate change is required, call SDL_SyncWindow() to
* block until the changes have taken effect.
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
* When the window size changes, an SDL_EVENT_WINDOW_RESIZED event will be
* emitted with the new window dimensions. Note that the new dimensions may
* not match the exact size requested, as some windowing systems can restrict
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* the window size in certain scenarios (e.g. constraining the size of the
* content area to remain within the usable desktop bounds). Additionally, as
* this is just a request, it can be denied by the windowing system.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to change
SDL 3.0 is going to be high DPI aware and officially separates screen… (#7145) * SDL 3.0 is going to be high DPI aware and officially separates screen coordinates from client pixel area The public APIs to disable high DPI support have been removed Work in progress on https://github.com/libsdl-org/SDL/issues/7134
2023-01-25 09:23:17 +00:00
* \param w the width of the window, must be > 0
* \param h the height of the window, must be > 0
[SDL3] Cleanup void functions (#7253) Some functions that do call SDL_SetError but return void changed to instead return non-zero in case of errors.
2023-02-06 16:53:52 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Updated some header comments and iOS documentation to better clarify high-dpi / retina support and screen-coordinate sizes versus pixel sizes.
2016-01-01 01:16:43 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetWindowSize
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
* \sa SDL_SetWindowFullscreenMode
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
* \sa SDL_SyncWindow
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowSize(SDL_Window *window, int w, int h);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
* Get the size of a window's client area.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* NULL can safely be passed as the `w` or `h` parameter if the width or
* height value is not desired.
Updated some header comments and iOS documentation to better clarify high-dpi / retina support and screen-coordinate sizes versus pixel sizes.
2016-01-01 01:16:43 +00:00
*
Sync SDL3 wiki -> header
2023-05-17 19:59:14 +00:00
* The window pixel size may differ from its window coordinate size if the
* window is on a high pixel density display. Use SDL_GetWindowSizeInPixels()
* or SDL_GetRenderOutputSize() to get the real client area size in pixels.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to query the width and height from
SDL 3.0 is going to be high DPI aware and officially separates screen… (#7145) * SDL 3.0 is going to be high DPI aware and officially separates screen coordinates from client pixel area The public APIs to disable high DPI support have been removed Work in progress on https://github.com/libsdl-org/SDL/issues/7134
2023-01-25 09:23:17 +00:00
* \param w a pointer filled in with the width of the window, may be NULL
* \param h a pointer filled in with the height of the window, may be NULL
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
Renderer logical size is now implemented as a render target This fixes rounding errors with coordinate scaling and gives more flexibility in the presentation, as well as making it easy to maintain device independent resolution as windows move between different pixel density displays. By default when a renderer is created, it will match the window size so window coordinates and render coordinates are 1-1. Mouse and touch events are no longer filtered to change their coordinates, instead you can call SDL_ConvertEventToRenderCoordinates() to explicitly map event coordinates into the rendering viewport. SDL_RenderWindowToLogical() and SDL_RenderLogicalToWindow() have been renamed SDL_RenderCoordinatesFromWindow() and SDL_RenderCoordinatesToWindow() and take floating point coordinates in both directions. The viewport, clipping state, and scale for render targets are now persistent and will remain set whenever they are active.
2023-02-03 20:25:46 +00:00
* \sa SDL_GetRenderOutputSize
SDL 3.0 is going to be high DPI aware and officially separates screen… (#7145) * SDL 3.0 is going to be high DPI aware and officially separates screen coordinates from client pixel area The public APIs to disable high DPI support have been removed Work in progress on https://github.com/libsdl-org/SDL/issues/7134
2023-01-25 09:23:17 +00:00
* \sa SDL_GetWindowSizeInPixels
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_SetWindowSize
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GetWindowSize(SDL_Window *window, int *w, int *h);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
Added SDL_GetWindowBordersSize(). This is currently only implemented for X11. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:29:06 +00:00
/**
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
* Get the size of a window's borders (decorations) around the client area.
Added SDL_GetWindowBordersSize(). This is currently only implemented for X11. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:29:06 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Note: If this function fails (returns -1), the size values will be
* initialized to 0, 0, 0, 0 (if a non-NULL pointer is provided), as if the
* window in question was borderless.
Added SDL_GetWindowBordersSize(). This is currently only implemented for X11. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:29:06 +00:00
*
include: Document timing issue with SDL_GetWindowBordersSize
2021-05-04 15:23:54 +00:00
* Note: This function may fail on systems where the window has not yet been
* decorated by the display server (for example, immediately after calling
* SDL_CreateWindow). It is recommended that you wait at least until the
* window has been presented and composited, so that the window system has a
* chance to decorate the window and provide the border dimensions to SDL.
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* This function also returns -1 if getting the information is not supported.
Added SDL_GetWindowBordersSize(). This is currently only implemented for X11. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:29:06 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to query the size values of the border
* (decorations) from
* \param top pointer to variable for storing the size of the top border; NULL
* is permitted
* \param left pointer to variable for storing the size of the left border;
* NULL is permitted
* \param bottom pointer to variable for storing the size of the bottom
* border; NULL is permitted
* \param right pointer to variable for storing the size of the right border;
* NULL is permitted
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \sa SDL_GetWindowSize
Added SDL_GetWindowBordersSize(). This is currently only implemented for X11. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:29:06 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GetWindowBordersSize(SDL_Window *window, int *top, int *left, int *bottom, int *right);
Added SDL_GetWindowBordersSize(). This is currently only implemented for X11. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:29:06 +00:00
Adding SDL_GetWindowSizeInPixels for window size in pixels (#6112)
2022-08-24 18:25:13 +00:00
/**
SDL 3.0 is going to be high DPI aware and officially separates screen… (#7145) * SDL 3.0 is going to be high DPI aware and officially separates screen coordinates from client pixel area The public APIs to disable high DPI support have been removed Work in progress on https://github.com/libsdl-org/SDL/issues/7134
2023-01-25 09:23:17 +00:00
* Get the size of a window's client area, in pixels.
Adding SDL_GetWindowSizeInPixels for window size in pixels (#6112)
2022-08-24 18:25:13 +00:00
*
* \param window the window from which the drawable size should be queried
* \param w a pointer to variable for storing the width in pixels, may be NULL
* \param h a pointer to variable for storing the height in pixels, may be
* NULL
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Adding SDL_GetWindowSizeInPixels for window size in pixels (#6112)
2022-08-24 18:25:13 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Adding SDL_GetWindowSizeInPixels for window size in pixels (#6112)
2022-08-24 18:25:13 +00:00
*
* \sa SDL_CreateWindow
* \sa SDL_GetWindowSize
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GetWindowSizeInPixels(SDL_Window *window, int *w, int *h);
Adding SDL_GetWindowSizeInPixels for window size in pixels (#6112)
2022-08-24 18:25:13 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
* Set the minimum size of a window's client area.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to change
Allow passing 0 to SDL_SetWindowMinimumSize() and SDL_SetWindowMaximumSize() to indicate no limit
2023-03-15 23:13:56 +00:00
* \param min_w the minimum width of the window, or 0 for no limit
* \param min_h the minimum height of the window, or 0 for no limit
[SDL3] Cleanup void functions (#7253) Some functions that do call SDL_SetError but return void changed to instead return non-zero in case of errors.
2023-02-06 16:53:52 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetWindowMinimumSize
* \sa SDL_SetWindowMaximumSize
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowMinimumSize(SDL_Window *window, int min_w, int min_h);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
* Get the minimum size of a window's client area.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to query
* \param w a pointer filled in with the minimum width of the window, may be
* NULL
* \param h a pointer filled in with the minimum height of the window, may be
* NULL
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetWindowMaximumSize
* \sa SDL_SetWindowMinimumSize
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GetWindowMinimumSize(SDL_Window *window, int *w, int *h);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
* Set the maximum size of a window's client area.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to change
Allow passing 0 to SDL_SetWindowMinimumSize() and SDL_SetWindowMaximumSize() to indicate no limit
2023-03-15 23:13:56 +00:00
* \param max_w the maximum width of the window, or 0 for no limit
* \param max_h the maximum height of the window, or 0 for no limit
[SDL3] Cleanup void functions (#7253) Some functions that do call SDL_SetError but return void changed to instead return non-zero in case of errors.
2023-02-06 16:53:52 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetWindowMaximumSize
* \sa SDL_SetWindowMinimumSize
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowMaximumSize(SDL_Window *window, int max_w, int max_h);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Updated SDL high DPI support We have gotten feedback that abstracting the coordinate system based on the display scale is unexpected and it is difficult to adapt existing applications to the proposed API. The new approach is to provide the coordinate systems that people expect, but provide additional information that will help applications properly handle high DPI situations. The concepts needed for high DPI support are documented in README-highdpi.md. An example of automatically adapting the content to display scale changes can be found in SDL_test_common.c, where auto_scale_content is checked. Also, the SDL_WINDOW_ALLOW_HIGHDPI window flag has been replaced by the SDL_HINT_VIDEO_ENABLE_HIGH_PIXEL_DENSITY hint. Fixes https://github.com/libsdl-org/SDL/issues/7709
2023-05-16 23:29:52 +00:00
* Get the maximum size of a window's client area.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to query
* \param w a pointer filled in with the maximum width of the window, may be
* NULL
* \param h a pointer filled in with the maximum height of the window, may be
* NULL
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetWindowMinimumSize
* \sa SDL_SetWindowMaximumSize
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GetWindowMaximumSize(SDL_Window *window, int *w, int *h);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Set the border state of a window.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* This will add or remove the window's `SDL_WINDOW_BORDERLESS` flag and add
* or remove the border from the actual window. This is a no-op if the
* window's border already matches the requested state.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* You can't change the border state of a fullscreen window.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window of which to change the border state
* \param bordered SDL_FALSE to remove border, SDL_TRUE to add border
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \sa SDL_GetWindowFlags
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowBordered(SDL_Window *window, SDL_bool bordered);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
Added SDL_SetWindowResizable(). (thanks, Ethan!)
2016-09-30 02:52:41 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Set the user-resizable state of a window.
Added SDL_SetWindowResizable(). (thanks, Ethan!)
2016-09-30 02:52:41 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* This will add or remove the window's `SDL_WINDOW_RESIZABLE` flag and
* allow/disallow user resizing of the window. This is a no-op if the window's
* resizable state already matches the requested state.
Added SDL_SetWindowResizable(). (thanks, Ethan!)
2016-09-30 02:52:41 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* You can't change the resizable state of a fullscreen window.
Added SDL_SetWindowResizable(). (thanks, Ethan!)
2016-09-30 02:52:41 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window of which to change the resizable state
* \param resizable SDL_TRUE to allow resizing, SDL_FALSE to disallow
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Added SDL_SetWindowResizable(). (thanks, Ethan!)
2016-09-30 02:52:41 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \sa SDL_GetWindowFlags
Added SDL_SetWindowResizable(). (thanks, Ethan!)
2016-09-30 02:52:41 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowResizable(SDL_Window *window, SDL_bool resizable);
Added SDL_SetWindowResizable(). (thanks, Ethan!)
2016-09-30 02:52:41 +00:00
Add SDL_SetWindowAlwaysOnTop()
2021-04-19 11:13:38 +00:00
/**
Update description of SDL_SetWindowAlwaysOnTop
2021-09-17 19:24:10 +00:00
* Set the window to always be above the others.
Add SDL_SetWindowAlwaysOnTop()
2021-04-19 11:13:38 +00:00
*
Sync wiki -> header
2021-09-18 14:19:04 +00:00
* This will add or remove the window's `SDL_WINDOW_ALWAYS_ON_TOP` flag. This
* will bring the window to the front and keep the window above the rest.
Add SDL_SetWindowAlwaysOnTop()
2021-04-19 11:13:38 +00:00
*
Update description of SDL_SetWindowAlwaysOnTop
2021-09-17 19:24:10 +00:00
* \param window The window of which to change the always on top state
Sync wiki -> header
2021-09-18 14:19:04 +00:00
* \param on_top SDL_TRUE to set the window always on top, SDL_FALSE to
* disable
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Add SDL_SetWindowAlwaysOnTop()
2021-04-19 11:13:38 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Update description of SDL_SetWindowAlwaysOnTop
2021-09-17 19:24:10 +00:00
*
* \sa SDL_GetWindowFlags
Add SDL_SetWindowAlwaysOnTop()
2021-04-19 11:13:38 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowAlwaysOnTop(SDL_Window *window, SDL_bool on_top);
include: manually ran wikiheaders.pl and cleaned up the obvious issues.
2021-10-09 00:22:48 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Show a window.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to show
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_HideWindow
* \sa SDL_RaiseWindow
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_ShowWindow(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Hide a window.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to hide
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_ShowWindow
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_HideWindow(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Raise a window above other windows and set the input focus.
*
* \param window the window to raise
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_RaiseWindow(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
* Request that the window be made as large as possible.
*
* Non-resizable windows can't be maximized. The window must have the
* SDL_WINDOW_RESIZABLE flag set, or this will have no effect.
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* On some windowing systems this request is asynchronous and the new window
* state may not have have been applied immediately upon the return of this
* function. If an immediate change is required, call SDL_SyncWindow() to
* block until the changes have taken effect.
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* When the window state changes, an SDL_EVENT_WINDOW_MAXIMIZED event will be
* emitted. Note that, as this is just a request, the windowing system can
* deny the state change.
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* When maximizing a window, whether the constraints set via
* SDL_SetWindowMaximumSize() are honored depends on the policy of the window
* manager. Win32 and macOS enforce the constraints when maximizing, while X11
* and Wayland window managers may vary.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to maximize
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_MinimizeWindow
* \sa SDL_RestoreWindow
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
* \sa SDL_SyncWindow
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_MaximizeWindow(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
* Request that the window be minimized to an iconic representation.
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* On some windowing systems this request is asynchronous and the new window
* state may not have have been applied immediately upon the return of this
* function. If an immediate change is required, call SDL_SyncWindow() to
* block until the changes have taken effect.
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* When the window state changes, an SDL_EVENT_WINDOW_MINIMIZED event will be
* emitted. Note that, as this is just a request, the windowing system can
* deny the state change.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to minimize
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_MaximizeWindow
* \sa SDL_RestoreWindow
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
* \sa SDL_SyncWindow
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_MinimizeWindow(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* Request that the size and position of a minimized or maximized window be
* restored.
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* On some windowing systems this request is asynchronous and the new window
* state may not have have been applied immediately upon the return of this
* function. If an immediate change is required, call SDL_SyncWindow() to
* block until the changes have taken effect.
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* When the window state changes, an SDL_EVENT_WINDOW_RESTORED event will be
* emitted. Note that, as this is just a request, the windowing system can
* deny the state change.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to restore
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
Sync wiki -> header.
2021-07-14 21:07:04 +00:00
* \sa SDL_MaximizeWindow
* \sa SDL_MinimizeWindow
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
* \sa SDL_SyncWindow
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_RestoreWindow(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
* Request that the window's fullscreen state be changed.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL3 wiki -> header
2024-01-18 12:07:19 +00:00
* By default a window in fullscreen state uses borderless fullscreen desktop
* mode, but a specific exclusive display mode can be set using
* SDL_SetWindowFullscreenMode().
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* On some windowing systems this request is asynchronous and the new
* fullscreen state may not have have been applied immediately upon the return
* of this function. If an immediate change is required, call SDL_SyncWindow()
* to block until the changes have taken effect.
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
* When the window state changes, an SDL_EVENT_WINDOW_ENTER_FULLSCREEN or
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* SDL_EVENT_WINDOW_LEAVE_FULLSCREEN event will be emitted. Note that, as this
* is just a request, it can be denied by the windowing system.
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to change
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
* \param fullscreen SDL_TRUE for fullscreen mode, SDL_FALSE for windowed mode
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Windows default to fullscreen desktop mode if they don't pick an explicit video mode Rather than iterating over display modes using an index, there is a new function SDL_GetFullscreenDisplayModes() to get the list of available fullscreen modes on a display. { SDL_DisplayID display = SDL_GetPrimaryDisplay(); int num_modes = 0; SDL_DisplayMode **modes = SDL_GetFullscreenDisplayModes(display, &num_modes); if (modes) { for (i = 0; i < num_modes; ++i) { SDL_DisplayMode *mode = modes[i]; SDL_Log("Display %" SDL_PRIu32 " mode %d: %dx%d@%gHz, %d%% scale\n", display, i, mode->pixel_w, mode->pixel_h, mode->refresh_rate, (int)(mode->display_scale * 100.0f)); } SDL_free(modes); } } SDL_GetDesktopDisplayMode() and SDL_GetCurrentDisplayMode() return pointers to display modes rather than filling in application memory. Windows now have an explicit fullscreen mode that is set, using SDL_SetWindowFullscreenMode(). The fullscreen mode for a window can be queried with SDL_GetWindowFullscreenMode(), which returns a pointer to the mode, or NULL if the window will be fullscreen desktop. SDL_SetWindowFullscreen() just takes a boolean value, setting the correct fullscreen state based on the selected mode.
2023-02-01 05:23:14 +00:00
* \sa SDL_GetWindowFullscreenMode
* \sa SDL_SetWindowFullscreenMode
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
* \sa SDL_SyncWindow
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowFullscreen(SDL_Window *window, SDL_bool fullscreen);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
/**
* Block until any pending window state is finalized.
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* On asynchronous windowing systems, this acts as a synchronization barrier
* for pending window state. It will attempt to wait until any pending window
* state has been applied and is guaranteed to return within finite time. Note
* that for how long it can potentially block depends on the underlying window
* system, as window state changes may involve somewhat lengthy animations
* that must complete before the window is in its final requested state.
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
* On windowing systems where changes are immediate, this does nothing.
*
Sync SDL3 wiki -> header
2023-12-07 18:27:25 +00:00
* \param window the window for which to wait for the pending state to be
* applied
* \returns 0 on success, a positive value if the operation timed out before
* the window was in the requested state, or a negative error code on
* failure; call SDL_GetError() for more information.
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_SetWindowSize
* \sa SDL_SetWindowPosition
* \sa SDL_SetWindowFullscreen
* \sa SDL_MinimizeWindow
* \sa SDL_MaximizeWindow
* \sa SDL_RestoreWindow
Sync SDL3 wiki -> header
2024-05-13 07:19:15 +00:00
* \sa SDL_HINT_VIDEO_SYNC_WINDOW_OPERATIONS
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SyncWindow(SDL_Window *window);
video: Implement asynchronous windowing SDL window size, state, and position functions have been considered immediate, with their effects assuming to have taken effect upon successful return of the function. However, several windowing systems handle these requests asynchronously, resulting in the functions blocking until the changes have taken effect, potentially for long periods of time. Additionally, some windowing systems treat these as requests, and can potentially deny or fulfill the request in a manner differently than the application expects, such as not allowing a window to be positioned or sized beyond desktop borders, prohibiting fullscreen, and so on. With these changes, applications can make requests of the window manager that do not block, with the understanding that an associated event will be sent if the request is fulfilled. Currently, size, position, maximize, minimize, and fullscreen calls are handled as asynchronous requests, with events being returned if the request is honored. If the application requires that the change take effect immediately, it can call the new SDL_SyncWindow function, which will attempt to block until the request is fulfilled, or some arbitrary timeout period elapses, the duration of which depends not only on the windowing system, but on the operation requested as well (e.g. a 100ms timeout is fine for most X11 events, but maximizing a window can take considerably longer for some reason). There is also a new hint 'SDL_VIDEO_SYNC_ALL_WINDOW_OPS' that will mimic the old behavior by synchronizing after every window operation with, again, the understanding that using this may result in the associated calls blocking for a relatively long period. The deferred model also results in the window size and position getters not reporting false coordinates anymore, as they only forward what the window manager reports vs allowing applications to set arbitrary values, and fullscreen enter/leave events that were initiated via the window manager update the window state appropriately, where they didn't before. Care was taken to ensure that order of operations is maintained, and that requests are not ignored or dropped. This does require some implicit internal synchronization in the various backends if many requests are made in a short period, as some state and behavior depends on other bits of state that need to be known at that particular point in time, but this isn't something that typical applications will hit, unless they are sending a lot of window state in a short time as the tests do. The automated tests developed to test the previous behavior also resulted in previously undefined behavior being defined and normalized across platforms, particularly when it comes to the sizing and positioning of windows when they are in a fixed-size state, such as maximized or fullscreen. Size and position requests made when the window is not in a movable or resizable state will be deferred until it can be applied, so no requests are lost. These changes fix another long-standing issue with renderers recreating maximized windows, where the original non-maximized size was lost, resulting in the window being restored to the wrong size. All automated video tests pass across all platforms. Overall, the "make a request/get an event" model better reflects how most windowing systems work, and some backends avoid spending significant time blocking while waiting for operations to complete.
2023-10-25 19:09:55 +00:00
Make it clear that you can't mix 2D rendering and the window surface API Also added functions to query and destroy the window surface so you can switch between modes if you want. See https://github.com/pygame-community/pygame-ce/issues/2190 for more details.
2023-06-10 15:39:20 +00:00
/**
* Return whether the window has a surface associated with it.
*
Fix comments
2023-06-22 13:42:51 +00:00
* \param window the window to query
Sync SDL3 wiki -> header
2023-06-10 15:42:15 +00:00
* \returns SDL_TRUE if there is a surface associated with the window, or
* SDL_FALSE otherwise.
Make it clear that you can't mix 2D rendering and the window surface API Also added functions to query and destroy the window surface so you can switch between modes if you want. See https://github.com/pygame-community/pygame-ce/issues/2190 for more details.
2023-06-10 15:39:20 +00:00
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_GetWindowSurface
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_bool SDLCALL SDL_WindowHasSurface(SDL_Window *window);
Make it clear that you can't mix 2D rendering and the window surface API Also added functions to query and destroy the window surface so you can switch between modes if you want. See https://github.com/pygame-community/pygame-ce/issues/2190 for more details.
2023-06-10 15:39:20 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the SDL surface associated with the window.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* A new surface will be created with the optimal format for the window, if
* necessary. This surface will be freed when the window is destroyed. Do not
* free this surface.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* This surface will be invalidated if the window is resized. After resizing a
* window this function must be called again to return a valid surface.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* You may not combine this with 3D or the rendering API on this window.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* This function is affected by `SDL_HINT_FRAMEBUFFER_ACCELERATION`.
*
* \param window the window to query
* \returns the surface associated with the window, or NULL on failure; call
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
Make it clear that you can't mix 2D rendering and the window surface API Also added functions to query and destroy the window surface so you can switch between modes if you want. See https://github.com/pygame-community/pygame-ce/issues/2190 for more details.
2023-06-10 15:39:20 +00:00
* \sa SDL_DestroyWindowSurface
Renamed SDL_HasWindowSurface to SDL_WindowHasSurface Fixes https://github.com/libsdl-org/SDL/issues/9034
2024-02-10 00:46:58 +00:00
* \sa SDL_WindowHasSurface
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_UpdateWindowSurface
* \sa SDL_UpdateWindowSurfaceRects
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_Surface *SDLCALL SDL_GetWindowSurface(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Copy the window surface to the screen.
*
* This is the function you use to reflect any changes to the surface on the
* screen.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* This function is equivalent to the SDL 1.2 API SDL_Flip().
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to update
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetWindowSurface
* \sa SDL_UpdateWindowSurfaceRects
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_UpdateWindowSurface(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Copy areas of the window surface to the screen.
*
* This is the function you use to reflect changes to portions of the surface
* on the screen.
*
* This function is equivalent to the SDL 1.2 API SDL_UpdateRects().
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
docs: Note SDL_UpdateWindowSurfaceRects can update beyond specified areas. Reference Issue #8825.
2024-01-16 20:26:13 +00:00
* Note that this function will update _at least_ the rectangles specified,
* but this is only intended as an optimization; in practice, this might
Sync SDL3 wiki -> header
2024-01-16 20:27:25 +00:00
* update more of the screen (or all of the screen!), depending on what method
* SDL uses to send pixels to the system.
docs: Note SDL_UpdateWindowSurfaceRects can update beyond specified areas. Reference Issue #8825.
2024-01-16 20:26:13 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to update
* \param rects an array of SDL_Rect structures representing areas of the
Handle DPI scaling in SDL_GetWindowSurface Fixes DPI awareness of testdrawchessboard (previously, the surface was being created in points instead of pixels, resulting in the demo app only drawing in a corner of the screen on High-DPI displays) *_CreateWindowFramebuffer()/*_UpdateWindowFramebuffer(): are updated to use SDL_GetWindowSizeInPixels instead of SDL_GetWindowSize() or window->w/window->h. Most of the _CreateWindowFramebuffer backends are untested except for Windows. Fixes #7047
2023-01-12 02:45:01 +00:00
* surface to copy, in pixels
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param numrects the number of rectangles
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetWindowSurface
* \sa SDL_UpdateWindowSurface
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_UpdateWindowSurfaceRects(SDL_Window *window, const SDL_Rect *rects, int numrects);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
Make it clear that you can't mix 2D rendering and the window surface API Also added functions to query and destroy the window surface so you can switch between modes if you want. See https://github.com/pygame-community/pygame-ce/issues/2190 for more details.
2023-06-10 15:39:20 +00:00
/**
* Destroy the surface associated with the window.
*
* \param window the window to update
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_GetWindowSurface
Renamed SDL_HasWindowSurface to SDL_WindowHasSurface Fixes https://github.com/libsdl-org/SDL/issues/9034
2024-02-10 00:46:58 +00:00
* \sa SDL_WindowHasSurface
Make it clear that you can't mix 2D rendering and the window surface API Also added functions to query and destroy the window surface so you can switch between modes if you want. See https://github.com/pygame-community/pygame-ce/issues/2190 for more details.
2023-06-10 15:39:20 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_DestroyWindowSurface(SDL_Window *window);
Make it clear that you can't mix 2D rendering and the window surface API Also added functions to query and destroy the window surface so you can switch between modes if you want. See https://github.com/pygame-community/pygame-ce/issues/2190 for more details.
2023-06-10 15:39:20 +00:00
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Set a window's keyboard grab mode.
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
*
Improve documentation for input grabbing functions
2021-11-25 13:49:57 +00:00
* Keyboard grab enables capture of system keyboard shortcuts like Alt+Tab or
* the Meta/Super key. Note that not all system keyboard shortcuts can be
* captured by applications (one example is Ctrl+Alt+Del on Windows).
*
* This is primarily intended for specialized applications such as VNC clients
* or VM frontends. Normal games should not use keyboard grab.
*
* When keyboard grab is enabled, SDL will continue to handle Alt+Tab when the
Sync wiki -> header
2021-11-25 13:53:04 +00:00
* window is full-screen to ensure the user is not trapped in your
* application. If you have a custom keyboard shortcut to exit fullscreen
* mode, you may suppress this behavior with
* `SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED`.
Improve documentation for input grabbing functions
2021-11-25 13:49:57 +00:00
*
Sync wiki -> header.
2021-07-14 21:07:04 +00:00
* If the caller enables a grab while another window is currently grabbed, the
* other window loses its grab in favor of the caller's window.
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window The window for which the keyboard grab mode should be set.
* \param grabbed This is SDL_TRUE to grab keyboard, and SDL_FALSE to release.
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-09-17 19:12:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetWindowKeyboardGrab
* \sa SDL_SetWindowMouseGrab
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowKeyboardGrab(SDL_Window *window, SDL_bool grabbed);
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Set a window's mouse grab mode.
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
*
Improve documentation for input grabbing functions
2021-11-25 13:49:57 +00:00
* Mouse grab confines the mouse cursor to the window.
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window The window for which the mouse grab mode should be set.
Sync wiki -> header
2022-03-27 17:11:05 +00:00
* \param grabbed This is SDL_TRUE to grab mouse, and SDL_FALSE to release.
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GetWindowMouseGrab
* \sa SDL_SetWindowKeyboardGrab
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowMouseGrab(SDL_Window *window, SDL_bool grabbed);
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get a window's keyboard grab mode.
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to query
* \returns SDL_TRUE if keyboard is grabbed, and SDL_FALSE otherwise.
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_SetWindowKeyboardGrab
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_bool SDLCALL SDL_GetWindowKeyboardGrab(SDL_Window *window);
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get a window's mouse grab mode.
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to query
doxygen: Fix all the "\returns" so they work as part of complete sentences.
2021-07-14 18:15:30 +00:00
* \returns SDL_TRUE if mouse is grabbed, and SDL_FALSE otherwise.
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_SetWindowKeyboardGrab
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_bool SDLCALL SDL_GetWindowMouseGrab(SDL_Window *window);
Expose separate keyboard and mouse grab support This adds SDL_SetWindowKeyboardGrab(), SDL_GetWindowKeyboardGrab(), SDL_SetWindowMouseGrab(), SDL_GetWindowMouseGrab(), and new SDL_WINDOW_KEYBOARD_GRABBED flag. It also updates the test harness to exercise this functionality and makes a minor fix to X11 that I missed in https://hg.libsdl.org/SDL/rev/02a2d609369b To fit in with this new support, SDL_WINDOW_INPUT_CAPTURE has been renamed to SDL_WINDOW_MOUSE_CAPTURE with the old name remaining as an alias for backwards compatibility with older code.
2021-01-27 01:16:17 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the window that currently has an input grab enabled.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \returns the window if input is grabbed or NULL otherwise.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Remove legacy SDL2 input grab API
2024-03-24 23:35:40 +00:00
* \sa SDL_SetWindowMouseGrab
* \sa SDL_SetWindowKeyboardGrab
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_Window *SDLCALL SDL_GetGrabbedWindow(void);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
Added SDL_GetWindowMouseRect() Also guarantee that we won't get mouse movement outside the confining area, even if the OS implementation allows it (e.g. macOS)
2021-11-09 05:34:48 +00:00
/**
* Confines the cursor to the specified area of a window.
*
* Note that this does NOT grab the cursor, it only defines the area a cursor
* is restricted to when the window has mouse focus.
*
* \param window The window that will be associated with the barrier.
* \param rect A rectangle area in window-relative coordinates. If NULL the
Sync wiki -> header
2021-11-10 20:21:01 +00:00
* barrier for the specified window will be destroyed.
Added SDL_GetWindowMouseRect() Also guarantee that we won't get mouse movement outside the confining area, even if the OS implementation allows it (e.g. macOS)
2021-11-09 05:34:48 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-11-10 21:05:03 +00:00
*
Added SDL_GetWindowMouseRect() Also guarantee that we won't get mouse movement outside the confining area, even if the OS implementation allows it (e.g. macOS)
2021-11-09 05:34:48 +00:00
* \sa SDL_GetWindowMouseRect
Improve documentation for input grabbing functions
2021-11-25 13:49:57 +00:00
* \sa SDL_SetWindowMouseGrab
Added SDL_GetWindowMouseRect() Also guarantee that we won't get mouse movement outside the confining area, even if the OS implementation allows it (e.g. macOS)
2021-11-09 05:34:48 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowMouseRect(SDL_Window *window, const SDL_Rect *rect);
Added SDL_GetWindowMouseRect() Also guarantee that we won't get mouse movement outside the confining area, even if the OS implementation allows it (e.g. macOS)
2021-11-09 05:34:48 +00:00
/**
* Get the mouse confinement rectangle of a window.
*
* \param window The window to query
Sync wiki -> header
2021-11-10 20:21:01 +00:00
* \returns A pointer to the mouse confinement rectangle of a window, or NULL
* if there isn't one.
Added SDL_GetWindowMouseRect() Also guarantee that we won't get mouse movement outside the confining area, even if the OS implementation allows it (e.g. macOS)
2021-11-09 05:34:48 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-11-10 21:05:03 +00:00
*
Added SDL_GetWindowMouseRect() Also guarantee that we won't get mouse movement outside the confining area, even if the OS implementation allows it (e.g. macOS)
2021-11-09 05:34:48 +00:00
* \sa SDL_SetWindowMouseRect
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC const SDL_Rect *SDLCALL SDL_GetWindowMouseRect(SDL_Window *window);
Added SDL_GetWindowMouseRect() Also guarantee that we won't get mouse movement outside the confining area, even if the OS implementation allows it (e.g. macOS)
2021-11-09 05:34:48 +00:00
Added SDL_SetWindowOpacity() and SDL_GetWindowOpacity(). This is currently implemented for X11, Cocoa, Windows, and DirectFB. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:46:10 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Set the opacity for a window.
Added SDL_SetWindowOpacity() and SDL_GetWindowOpacity(). This is currently implemented for X11, Cocoa, Windows, and DirectFB. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:46:10 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* The parameter `opacity` will be clamped internally between 0.0f
* (transparent) and 1.0f (opaque).
vulkan: Initial Vulkan support! This work was done by Jacob Lifshay and Mark Callow; I'm just merging it into revision control.
2017-08-28 02:15:57 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* This function also returns -1 if setting the opacity isn't supported.
Added SDL_SetWindowOpacity() and SDL_GetWindowOpacity(). This is currently implemented for X11, Cocoa, Windows, and DirectFB. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:46:10 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window which will be made transparent or opaque
* \param opacity the opacity value (0.0f - transparent, 1.0f - opaque)
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \sa SDL_GetWindowOpacity
Added SDL_SetWindowOpacity() and SDL_GetWindowOpacity(). This is currently implemented for X11, Cocoa, Windows, and DirectFB. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:46:10 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowOpacity(SDL_Window *window, float opacity);
Added SDL_SetWindowOpacity() and SDL_GetWindowOpacity(). This is currently implemented for X11, Cocoa, Windows, and DirectFB. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:46:10 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the opacity of a window.
*
* If transparency isn't supported on this platform, opacity will be reported
* as 1.0f without error.
Added SDL_SetWindowOpacity() and SDL_GetWindowOpacity(). This is currently implemented for X11, Cocoa, Windows, and DirectFB. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:46:10 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* The parameter `opacity` is ignored if it is NULL.
Added SDL_SetWindowOpacity() and SDL_GetWindowOpacity(). This is currently implemented for X11, Cocoa, Windows, and DirectFB. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:46:10 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* This function also returns -1 if an invalid window was provided.
Added SDL_SetWindowOpacity() and SDL_GetWindowOpacity(). This is currently implemented for X11, Cocoa, Windows, and DirectFB. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:46:10 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to get the current opacity value from
Fixed header documentation errors
2021-03-26 21:34:58 +00:00
* \param out_opacity the float filled in (0.0f - transparent, 1.0f - opaque)
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Added SDL_SetWindowOpacity() and SDL_GetWindowOpacity(). This is currently implemented for X11, Cocoa, Windows, and DirectFB. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:46:10 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \sa SDL_SetWindowOpacity
Added SDL_SetWindowOpacity() and SDL_GetWindowOpacity(). This is currently implemented for X11, Cocoa, Windows, and DirectFB. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:46:10 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GetWindowOpacity(SDL_Window *window, float *out_opacity);
Added SDL_SetWindowOpacity() and SDL_GetWindowOpacity(). This is currently implemented for X11, Cocoa, Windows, and DirectFB. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:46:10 +00:00
Added SDL_SetWindowModalFor(). This is currently only implemented for X11. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2015-04-21 13:45:58 +00:00
/**
Add support for modal windows to more platforms - Adds support for modal windows to Win32, Mac, and Haiku, and enhances functionality on Wayland and X11, which previous set only the parent window, but not the modal state. - Windows can be declared modal at creation time, and the modal state can be toggled at any time via SDL_SetWindowModalFor() (tested with UE5 through sdl2-compat). - Allows dynamic unparenting/reparenting of windows. - Includes a modal window test.
2024-04-03 20:44:03 +00:00
* Set the window as a modal to a parent window.
*
Sync SDL3 wiki -> header
2024-04-30 17:48:27 +00:00
* If the window is already modal to an existing window, it will be reparented
* to the new owner. Setting the parent window to null unparents the modal
* window and removes modal status.
Add support for modal windows to more platforms - Adds support for modal windows to Win32, Mac, and Haiku, and enhances functionality on Wayland and X11, which previous set only the parent window, but not the modal state. - Windows can be declared modal at creation time, and the modal state can be toggled at any time via SDL_SetWindowModalFor() (tested with UE5 through sdl2-compat). - Allows dynamic unparenting/reparenting of windows. - Includes a modal window test.
2024-04-03 20:44:03 +00:00
*
Sync SDL3 wiki -> header
2024-04-30 17:48:27 +00:00
* Setting a window as modal to a parent that is a descendent of the modal
* window results in undefined behavior.
Added SDL_SetWindowModalFor(). This is currently only implemented for X11. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2015-04-21 13:45:58 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param modal_window the window that should be set modal
* \param parent_window the parent window for the modal window
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
vulkan: Initial Vulkan support! This work was done by Jacob Lifshay and Mark Callow; I'm just merging it into revision control.
2017-08-28 02:15:57 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Added SDL_SetWindowModalFor(). This is currently only implemented for X11. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2015-04-21 13:45:58 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowModalFor(SDL_Window *modal_window, SDL_Window *parent_window);
Added SDL_SetWindowModalFor(). This is currently only implemented for X11. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2015-04-21 13:45:58 +00:00
Added SDL_SetWindowInputFocus(). This is currently only implemented for X11. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:28:56 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Explicitly set input focus to the window.
Added SDL_SetWindowInputFocus(). This is currently only implemented for X11. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:28:56 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* You almost certainly want SDL_RaiseWindow() instead of this function. Use
* this with caution, as you might give focus to a window that is completely
* obscured by other windows.
Added SDL_SetWindowInputFocus(). This is currently only implemented for X11. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:28:56 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window that should get the input focus
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
vulkan: Initial Vulkan support! This work was done by Jacob Lifshay and Mark Callow; I'm just merging it into revision control.
2017-08-28 02:15:57 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \sa SDL_RaiseWindow
Added SDL_SetWindowInputFocus(). This is currently only implemented for X11. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:28:56 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowInputFocus(SDL_Window *window);
Added SDL_SetWindowInputFocus(). This is currently only implemented for X11. This patch is based on work in Unreal Engine 4's fork of SDL, compliments of Epic Games.
2016-01-05 07:28:56 +00:00
Add SDL_WINDOW_NOT_FOCUSABLE flag to set that the window should not be able to gain key focus - Also adds SDL_SetWindowFocusable() to set/clear flag on existing windows
2023-08-31 03:29:51 +00:00
/**
* Set whether the window may have input focus.
*
* \param window the window to set focusable state
Sync SDL3 wiki -> header
2023-08-31 03:26:13 +00:00
* \param focusable SDL_TRUE to allow input focus, SDL_FALSE to not allow
* input focus
Add SDL_WINDOW_NOT_FOCUSABLE flag to set that the window should not be able to gain key focus - Also adds SDL_SetWindowFocusable() to set/clear flag on existing windows
2023-08-31 03:29:51 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
*
* \since This function is available since SDL 3.0.0.
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowFocusable(SDL_Window *window, SDL_bool focusable);
Add SDL_WINDOW_NOT_FOCUSABLE flag to set that the window should not be able to gain key focus - Also adds SDL_SetWindowFocusable() to set/clear flag on existing windows
2023-08-31 03:29:51 +00:00
Add a function to display the system menu for a window Add SDL_ShowWindowSystemMenu() to display the system-level menu for windows. Typically, this is done by right-clicking on the system provided window decorations, however, if an application is rendering its own client-side decorations, there is currently no way to display it. This menu is provided by the system and can provide privileged desktop functionality such as moving or pinning a window to a specific workspace or display, setting the always-on-top property, or taking screenshots. In many cases, there are no APIs which allow applications to perform these actions manually. Implemented for Wayland via functionality provided by the xdg_toplevel protocol, Win32 via the undocumented message 0x313 (typically called WM_POPUPSYSTEMMENU), and X11 via the "_GTK_SHOW_WINDOW_MENU" atom (supported in GNOME and KDE).
2023-07-30 15:24:24 +00:00
/**
* Display the system-level window menu.
*
* This default window menu is provided by the system and on some platforms
* provides functionality for setting or changing privileged state on the
* window, such as moving it between workspaces or displays, or toggling the
* always-on-top property.
*
Sync SDL3 wiki -> header
2023-08-04 17:40:16 +00:00
* On platforms or desktops where this is unsupported, this function does
* nothing.
Add a function to display the system menu for a window Add SDL_ShowWindowSystemMenu() to display the system-level menu for windows. Typically, this is done by right-clicking on the system provided window decorations, however, if an application is rendering its own client-side decorations, there is currently no way to display it. This menu is provided by the system and can provide privileged desktop functionality such as moving or pinning a window to a specific workspace or display, setting the always-on-top property, or taking screenshots. In many cases, there are no APIs which allow applications to perform these actions manually. Implemented for Wayland via functionality provided by the xdg_toplevel protocol, Win32 via the undocumented message 0x313 (typically called WM_POPUPSYSTEMMENU), and X11 via the "_GTK_SHOW_WINDOW_MENU" atom (supported in GNOME and KDE).
2023-07-30 15:24:24 +00:00
*
* \param window the window for which the menu will be displayed
Sync SDL3 wiki -> header
2023-08-04 17:40:16 +00:00
* \param x the x coordinate of the menu, relative to the origin (top-left) of
* the client area
* \param y the y coordinate of the menu, relative to the origin (top-left) of
* the client area
Add a function to display the system menu for a window Add SDL_ShowWindowSystemMenu() to display the system-level menu for windows. Typically, this is done by right-clicking on the system provided window decorations, however, if an application is rendering its own client-side decorations, there is currently no way to display it. This menu is provided by the system and can provide privileged desktop functionality such as moving or pinning a window to a specific workspace or display, setting the always-on-top property, or taking screenshots. In many cases, there are no APIs which allow applications to perform these actions manually. Implemented for Wayland via functionality provided by the xdg_toplevel protocol, Win32 via the undocumented message 0x313 (typically called WM_POPUPSYSTEMMENU), and X11 via the "_GTK_SHOW_WINDOW_MENU" atom (supported in GNOME and KDE).
2023-07-30 15:24:24 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
*
* \since This function is available since SDL 3.0.0.
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_ShowWindowSystemMenu(SDL_Window *window, int x, int y);
Add a function to display the system menu for a window Add SDL_ShowWindowSystemMenu() to display the system-level menu for windows. Typically, this is done by right-clicking on the system provided window decorations, however, if an application is rendering its own client-side decorations, there is currently no way to display it. This menu is provided by the system and can provide privileged desktop functionality such as moving or pinning a window to a specific workspace or display, setting the always-on-top property, or taking screenshots. In many cases, there are no APIs which allow applications to perform these actions manually. Implemented for Wayland via functionality provided by the xdg_toplevel protocol, Win32 via the undocumented message 0x313 (typically called WM_POPUPSYSTEMMENU), and X11 via the "_GTK_SHOW_WINDOW_MENU" atom (supported in GNOME and KDE).
2023-07-30 15:24:24 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Possible return values from the SDL_HitTest callback.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
include: Add `\since` to all documentation that was missing it.
2024-04-11 17:34:29 +00:00
* \since This enum is available since SDL 3.0.0.
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_HitTest
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
typedef enum SDL_HitTestResult
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
{
include: A ton of little documentation tweaks, fixes, and improvements. This is just stuff I noticed while working on the wikiheaders updates. A thorough pass over all the docs would not be terrible, and maybe a simple script to check for consistency (does everything have a `\since` on it? etc) might be nice, too.
2024-04-09 02:36:57 +00:00
SDL_HITTEST_NORMAL, /**< Region is normal. No special properties. */
SDL_HITTEST_DRAGGABLE, /**< Region can drag entire window. */
SDL_HITTEST_RESIZE_TOPLEFT, /**< Region is the resizable top-left corner border. */
SDL_HITTEST_RESIZE_TOP, /**< Region is the resizable top border. */
SDL_HITTEST_RESIZE_TOPRIGHT, /**< Region is the resizable top-right corner border. */
SDL_HITTEST_RESIZE_RIGHT, /**< Region is the resizable right border. */
SDL_HITTEST_RESIZE_BOTTOMRIGHT, /**< Region is the resizable bottom-right corner border. */
SDL_HITTEST_RESIZE_BOTTOM, /**< Region is the resizable bottom border. */
SDL_HITTEST_RESIZE_BOTTOMLEFT, /**< Region is the resizable bottom-left corner border. */
SDL_HITTEST_RESIZE_LEFT /**< Region is the resizable left border. */
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
} SDL_HitTestResult;
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Callback used for hit-testing.
*
* \param win the SDL_Window where hit-testing was set on
* \param area an SDL_Point which should be hit-tested
* \param data what was passed as `callback_data` to SDL_SetWindowHitTest()
Add missing \returns, change "return" to "returns" to have same naming
2023-02-10 21:26:35 +00:00
* \returns an SDL_HitTestResult value.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_SetWindowHitTest
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
typedef SDL_HitTestResult (SDLCALL *SDL_HitTest)(SDL_Window *win,
const SDL_Point *area,
void *data);
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Provide a callback that decides if a window region has special properties.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Normally windows are dragged and resized by decorations provided by the
* system window manager (a title bar, borders, etc), but for some apps, it
* makes sense to drag them from somewhere else inside the window itself; for
* example, one might have a borderless window that wants to be draggable from
* any part, or simulate its own title bar, etc.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* This function lets the app provide a callback that designates pieces of a
* given window as special. This callback is run during event processing if we
* need to tell the OS to treat a region of the window specially; the use of
* this callback is known as "hit testing."
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Mouse input may not be delivered to your application if it is within a
* special area; the OS will often apply that input to moving the window or
* resizing the window and not deliver it to the application.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Specifying NULL for a callback disables hit-testing. Hit-testing is
* disabled by default.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Platforms that don't support this functionality will return -1
* unconditionally, even if you're attempting to disable hit-testing.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Your callback may fire at any time, and its firing does not indicate any
* specific behavior (for example, on Windows, this certainly might fire when
* the OS is deciding whether to drag your window, but it fires for lots of
* other reasons, too, some unrelated to anything you probably care about _and
* when the mouse isn't actually at the location it is testing_). Since this
* can fire at any time, you should try to keep your callback efficient,
* devoid of allocations, etc.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to set hit-testing on
* \param callback the function to call when doing a hit-test
* \param callback_data an app-defined void pointer passed to **callback**
Update `\returns` to the generic form
2023-02-12 09:09:42 +00:00
* \returns 0 on success or a negative error code on failure; call
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowHitTest(SDL_Window *window, SDL_HitTest callback, void *callback_data);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
Re-added a simplified version of SDL_SetWindowShape() In order to handle mouse click transparency this needs to be implemented inside SDL
2024-02-09 15:09:59 +00:00
/**
* Set the shape of a transparent window.
*
Sync SDL3 wiki -> header
2024-02-10 00:05:26 +00:00
* This sets the alpha channel of a transparent window and any fully
* transparent areas are also transparent to mouse clicks. If you are using
* something besides the SDL render API, then you are responsible for setting
* the alpha channel of the window yourself.
Re-added a simplified version of SDL_SetWindowShape() In order to handle mouse click transparency this needs to be implemented inside SDL
2024-02-09 15:09:59 +00:00
*
Sync SDL3 wiki -> header
2024-02-10 15:09:26 +00:00
* The shape is copied inside this function, so you can free it afterwards. If
* your shape surface changes, you should call SDL_SetWindowShape() again to
* update the window.
Clarify the lifetime of the shape surface in SDL_SetWindowShape()
2024-02-10 15:08:28 +00:00
*
Re-added a simplified version of SDL_SetWindowShape() In order to handle mouse click transparency this needs to be implemented inside SDL
2024-02-09 15:09:59 +00:00
* The window must have been created with the SDL_WINDOW_TRANSPARENT flag.
*
* \param window the window
Sync SDL3 wiki -> header
2024-02-10 00:05:26 +00:00
* \param shape the surface representing the shape of the window, or NULL to
* remove any current shape
Re-added a simplified version of SDL_SetWindowShape() In order to handle mouse click transparency this needs to be implemented inside SDL
2024-02-09 15:09:59 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
*
* \since This function is available since SDL 3.0.0.
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_SetWindowShape(SDL_Window *window, SDL_Surface *shape);
Re-added a simplified version of SDL_SetWindowShape() In order to handle mouse click transparency this needs to be implemented inside SDL
2024-02-09 15:09:59 +00:00
Implement bare minimum for SDL_FlashWindow
2021-06-04 17:55:30 +00:00
/**
doxygen: Tweak SDL_FlashWindow brief description. So "e.g." doesn't look like the end of the sentence to wikiheaders.pl.
2021-07-14 12:01:55 +00:00
* Request a window to demand attention from the user.
Implement bare minimum for SDL_FlashWindow
2021-06-04 17:55:30 +00:00
*
Changed SDL_FlashWindow() so it doesn't take a flash count, and added the hint SDL_HINT_WINDOW_FLASH_COUNT to control behavior on Windows
2021-07-24 19:11:27 +00:00
* \param window the window to be flashed
Fixed the parameter documentation
2021-07-27 21:23:40 +00:00
* \param operation the flash operation
Implement bare minimum for SDL_FlashWindow
2021-06-04 17:55:30 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Sync wiki -> header
2021-09-17 19:10:07 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Implement bare minimum for SDL_FlashWindow
2021-06-04 17:55:30 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_FlashWindow(SDL_Window *window, SDL_FlashOperation operation);
Implement bare minimum for SDL_FlashWindow
2021-06-04 17:55:30 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
Sync SDL3 wiki -> header
2024-03-27 18:02:23 +00:00
* Destroy a window.
*
Sync SDL3 wiki -> header
2024-04-30 17:48:27 +00:00
* Any popups or modal windows owned by the window will be recursively
* destroyed as well.
Add support for modal windows to more platforms - Adds support for modal windows to Win32, Mac, and Haiku, and enhances functionality on Wayland and X11, which previous set only the parent window, but not the modal state. - Windows can be declared modal at creation time, and the modal state can be toggled at any time via SDL_SetWindowModalFor() (tested with UE5 through sdl2-compat). - Allows dynamic unparenting/reparenting of windows. - Includes a modal window test.
2024-04-03 20:44:03 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* If `window` is NULL, this function will return immediately after setting
* the SDL error message to "Invalid window". See SDL_GetError().
*
* \param window the window to destroy
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
SDL_CreateWindowWithPosition() and SDL_CreateWindowFrom() have been replaced with SDL_CreateWindowWithProperties() This is a more general interface that can be extended in the future as needed.
2023-11-13 19:29:30 +00:00
* \sa SDL_CreatePopupWindow
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_CreateWindow
SDL_CreateWindowWithPosition() and SDL_CreateWindowFrom() have been replaced with SDL_CreateWindowWithProperties() This is a more general interface that can be extended in the future as needed.
2023-11-13 19:29:30 +00:00
* \sa SDL_CreateWindowWithProperties
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC void SDLCALL SDL_DestroyWindow(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Check whether the screensaver is currently enabled.
*
include: Removed some SDL2 references in the documentation.
2024-04-13 13:23:22 +00:00
* The screensaver is disabled by default.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* The default can also be changed using `SDL_HINT_VIDEO_ALLOW_SCREENSAVER`.
*
* \returns SDL_TRUE if the screensaver is enabled, SDL_FALSE if it is
* disabled.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \sa SDL_DisableScreenSaver
* \sa SDL_EnableScreenSaver
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_bool SDLCALL SDL_ScreenSaverEnabled(void);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Allow the screen to be blanked by a screen saver.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
SDL_*SceenSaver(): change return value to int. // add SDL_Unsupported() errors
2023-02-09 14:34:43 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \sa SDL_DisableScreenSaver
SDL API renaming: *Is* functions Feedback from @icculus: "IsTablet" uses "is" as a form of "to be" ...like, the actual question is of its nature. The rest is just a superfluous word in the question and it flows as better English with if (RectEmpty) than if (IsRectEmpty) Fixes https://github.com/libsdl-org/SDL/issues/6932
2022-12-29 03:34:01 +00:00
* \sa SDL_ScreenSaverEnabled
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_EnableScreenSaver(void);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Prevent the screen from being blanked by a screen saver.
*
* If you disable the screensaver, it is automatically re-enabled when SDL
* quits.
*
Sync SDL3 wiki -> header
2024-04-30 10:45:12 +00:00
* The screensaver is disabled by default, but this may by changed by
* SDL_HINT_VIDEO_ALLOW_SCREENSAVER.
Sync SDL wiki -> header
2022-10-09 15:44:07 +00:00
*
SDL_*SceenSaver(): change return value to int. // add SDL_Unsupported() errors
2023-02-09 14:34:43 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_EnableScreenSaver
SDL API renaming: *Is* functions Feedback from @icculus: "IsTablet" uses "is" as a form of "to be" ...like, the actual question is of its nature. The rest is just a superfluous word in the question and it flows as better English with if (RectEmpty) than if (IsRectEmpty) Fixes https://github.com/libsdl-org/SDL/issues/6932
2022-12-29 03:34:01 +00:00
* \sa SDL_ScreenSaverEnabled
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_DisableScreenSaver(void);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
* \name OpenGL support functions
*/
/* @{ */
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Dynamically load an OpenGL library.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* This should be done after initializing the video driver, but before
* creating any OpenGL windows. If no OpenGL library is loaded, the default
* library will be loaded upon creation of the first OpenGL window.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* If you do this, you need to retrieve all of the GL functions used in your
* program from the dynamic library using SDL_GL_GetProcAddress().
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param path the platform dependent OpenGL library name, or NULL to open the
* default OpenGL library
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GL_GetProcAddress
* \sa SDL_GL_UnloadLibrary
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GL_LoadLibrary(const char *path);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get an OpenGL function by name.
*
* If the GL library is loaded at runtime with SDL_GL_LoadLibrary(), then all
* GL functions must be retrieved this way. Usually this is used to retrieve
* function pointers to OpenGL extensions.
*
* There are some quirks to looking up OpenGL functions that require some
* extra care from the application. If you code carefully, you can handle
* these quirks without any platform-specific code, though:
headers: Fix up bullet lists, now that wikiheaders.pl can handle them.
2021-03-24 14:47:03 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* - On Windows, function pointers are specific to the current GL context;
Sync wiki -> header.
2021-07-14 21:07:04 +00:00
* this means you need to have created a GL context and made it current
* before calling SDL_GL_GetProcAddress(). If you recreate your context or
* create a second context, you should assume that any existing function
* pointers aren't valid to use with it. This is (currently) a
* Windows-specific limitation, and in practice lots of drivers don't suffer
* this limitation, but it is still the way the wgl API is documented to
* work and you should expect crashes if you don't respect it. Store a copy
* of the function pointers that comes and goes with context lifespan.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* - On X11, function pointers returned by this function are valid for any
Sync wiki -> header.
2021-07-14 21:07:04 +00:00
* context, and can even be looked up before a context is created at all.
* This means that, for at least some common OpenGL implementations, if you
* look up a function that doesn't exist, you'll get a non-NULL result that
* is _NOT_ safe to call. You must always make sure the function is actually
* available for a given GL context before calling it, by checking for the
* existence of the appropriate extension with SDL_GL_ExtensionSupported(),
* or verifying that the version of OpenGL you're using offers the function
* as core functionality.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* - Some OpenGL drivers, on all platforms, *will* return NULL if a function
Sync wiki -> header.
2021-07-14 21:07:04 +00:00
* isn't supported, but you can't count on this behavior. Check for
* extensions you use, and if you get a NULL anyway, act as if that
* extension wasn't available. This is probably a bug in the driver, but you
* can code defensively for this scenario anyhow.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* - Just because you're on Linux/Unix, don't assume you'll be using X11.
Sync wiki -> header.
2021-07-14 21:07:04 +00:00
* Next-gen display servers are waiting to replace it, and may or may not
* make the same promises about function pointers.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* - OpenGL function pointers must be declared `APIENTRY` as in the example
Sync wiki -> header.
2021-07-14 21:07:04 +00:00
* code. This will ensure the proper calling convention is followed on
* platforms where this matters (Win32) thereby avoiding stack corruption.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \param proc the name of an OpenGL function
* \returns a pointer to the named OpenGL function. The returned pointer
* should be cast to the appropriate function signature.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GL_ExtensionSupported
* \sa SDL_GL_LoadLibrary
* \sa SDL_GL_UnloadLibrary
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_FunctionPointer SDLCALL SDL_GL_GetProcAddress(const char *proc);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
egl: implement public functions to obtain internal EGL handles These functions allow applications to call EGL functions against the SDL EGL context. For example, applications can use an EGL API loader via SDL_EGL_GetCurrentDisplay and SDL_EGL_GetProcAddress, and can call functions such as eglQuerySurface against the internal EGLSurface and EGLDisplay.
2022-08-26 02:44:35 +00:00
/**
* Get an EGL library function by name.
*
* If an EGL library is loaded, this function allows applications to get entry
* points for EGL functions. This is useful to provide to an EGL API and
* extension loader.
*
* \param proc the name of an EGL function
Sync SDL3 wiki -> header
2022-11-23 19:03:15 +00:00
* \returns a pointer to the named EGL function. The returned pointer should
* be cast to the appropriate function signature.
egl: implement public functions to obtain internal EGL handles These functions allow applications to call EGL functions against the SDL EGL context. For example, applications can use an EGL API loader via SDL_EGL_GetCurrentDisplay and SDL_EGL_GetProcAddress, and can call functions such as eglQuerySurface against the internal EGLSurface and EGLDisplay.
2022-08-26 02:44:35 +00:00
*
Sync SDL3 wiki -> header
2022-11-23 19:59:15 +00:00
* \since This function is available since SDL 3.0.0.
*
egl: implement public functions to obtain internal EGL handles These functions allow applications to call EGL functions against the SDL EGL context. For example, applications can use an EGL API loader via SDL_EGL_GetCurrentDisplay and SDL_EGL_GetProcAddress, and can call functions such as eglQuerySurface against the internal EGLSurface and EGLDisplay.
2022-08-26 02:44:35 +00:00
* \sa SDL_GL_GetCurrentEGLDisplay
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_FunctionPointer SDLCALL SDL_EGL_GetProcAddress(const char *proc);
egl: implement public functions to obtain internal EGL handles These functions allow applications to call EGL functions against the SDL EGL context. For example, applications can use an EGL API loader via SDL_EGL_GetCurrentDisplay and SDL_EGL_GetProcAddress, and can call functions such as eglQuerySurface against the internal EGLSurface and EGLDisplay.
2022-08-26 02:44:35 +00:00
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Unload the OpenGL library previously loaded by SDL_GL_LoadLibrary().
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GL_LoadLibrary
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC void SDLCALL SDL_GL_UnloadLibrary(void);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Check if an OpenGL extension is supported for the current context.
*
* This function operates on the current GL context; you must have created a
* context and it must be current before calling this function. Do not assume
* that all contexts you create will have the same set of extensions
* available, or that recreating an existing context will offer the same
* extensions again.
*
* While it's probably not a massive overhead, this function is not an O(1)
* operation. Check the extensions you care about after creating the GL
* context and save that information somewhere instead of calling the function
* every time you need to know.
*
* \param extension the name of the extension to check
* \returns SDL_TRUE if the extension is supported, SDL_FALSE otherwise.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_bool SDLCALL SDL_GL_ExtensionSupported(const char *extension);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Reset all previously set OpenGL context attributes to their default values.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \sa SDL_GL_GetAttribute
* \sa SDL_GL_SetAttribute
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC void SDLCALL SDL_GL_ResetAttributes(void);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Set an OpenGL window attribute before window creation.
*
Sync wiki -> header.
2021-07-14 21:07:04 +00:00
* This function sets the OpenGL attribute `attr` to `value`. The requested
* attributes should be set before creating an OpenGL window. You should use
* SDL_GL_GetAttribute() to check the values after creating the OpenGL
* context, since the values obtained can differ from the requested ones.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \param attr an SDL_GLattr enum value specifying the OpenGL attribute to set
* \param value the desired value for the attribute
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Fixed bug 3720 - SDL_GL_GetAttribute doesn't check for initialized video driver Simon Hug SDL_GL_GetAttribute doesn't check if a video driver has been initialized and will access the SDL_VideoDevice pointer, which is NULL at that point. I think all of the attributes require an initialized driver, so a simple NULL check should fix it. Patch is attached.
2017-07-31 19:57:15 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GL_GetAttribute
* \sa SDL_GL_ResetAttributes
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GL_SetAttribute(SDL_GLattr attr, int value);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the actual value for an attribute from the current context.
Fixed bug 3720 - SDL_GL_GetAttribute doesn't check for initialized video driver Simon Hug SDL_GL_GetAttribute doesn't check if a video driver has been initialized and will access the SDL_VideoDevice pointer, which is NULL at that point. I think all of the attributes require an initialized driver, so a simple NULL check should fix it. Patch is attached.
2017-07-31 19:57:15 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param attr an SDL_GLattr enum value specifying the OpenGL attribute to get
* \param value a pointer filled in with the current value of `attr`
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GL_ResetAttributes
* \sa SDL_GL_SetAttribute
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GL_GetAttribute(SDL_GLattr attr, int *value);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Create an OpenGL context for an OpenGL window, and make it current.
*
* Windows users new to OpenGL should note that, for historical reasons, GL
* functions added after OpenGL version 1.1 are not available by default.
* Those functions must be loaded at run-time, either with an OpenGL
* extension-handling library or with SDL_GL_GetProcAddress() and its related
* functions.
*
* SDL_GLContext is an alias for `void *`. It's opaque to the application.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \param window the window to associate with the context
Sync wiki -> header.
2021-07-14 21:07:04 +00:00
* \returns the OpenGL context associated with `window` or NULL on error; call
* SDL_GetError() for more details.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GL_DeleteContext
* \sa SDL_GL_MakeCurrent
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_GLContext SDLCALL SDL_GL_CreateContext(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Set up an OpenGL context for rendering into an OpenGL window.
*
* The context must have been created with a compatible window.
*
* \param window the window to associate with the context
* \param context the OpenGL context to associate with the window
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GL_CreateContext
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GL_MakeCurrent(SDL_Window *window, SDL_GLContext context);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the currently active OpenGL window.
*
* \returns the currently active OpenGL window on success or NULL on failure;
* call SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_Window *SDLCALL SDL_GL_GetCurrentWindow(void);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the currently active OpenGL context.
*
* \returns the currently active OpenGL context or NULL on failure; call
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \sa SDL_GL_MakeCurrent
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_GLContext SDLCALL SDL_GL_GetCurrentContext(void);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
egl: implement public functions to obtain internal EGL handles These functions allow applications to call EGL functions against the SDL EGL context. For example, applications can use an EGL API loader via SDL_EGL_GetCurrentDisplay and SDL_EGL_GetProcAddress, and can call functions such as eglQuerySurface against the internal EGLSurface and EGLDisplay.
2022-08-26 02:44:35 +00:00
/**
* Get the currently active EGL display.
*
* \returns the currently active EGL display or NULL on failure; call
* SDL_GetError() for more information.
Sync SDL3 wiki -> header
2022-11-23 19:59:15 +00:00
*
* \since This function is available since SDL 3.0.0.
egl: implement public functions to obtain internal EGL handles These functions allow applications to call EGL functions against the SDL EGL context. For example, applications can use an EGL API loader via SDL_EGL_GetCurrentDisplay and SDL_EGL_GetProcAddress, and can call functions such as eglQuerySurface against the internal EGLSurface and EGLDisplay.
2022-08-26 02:44:35 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_EGLDisplay SDLCALL SDL_EGL_GetCurrentEGLDisplay(void);
egl: implement public functions to obtain internal EGL handles These functions allow applications to call EGL functions against the SDL EGL context. For example, applications can use an EGL API loader via SDL_EGL_GetCurrentDisplay and SDL_EGL_GetProcAddress, and can call functions such as eglQuerySurface against the internal EGLSurface and EGLDisplay.
2022-08-26 02:44:35 +00:00
/**
* Get the currently active EGL config.
*
* \returns the currently active EGL config or NULL on failure; call
* SDL_GetError() for more information.
Sync SDL3 wiki -> header
2022-11-23 19:59:15 +00:00
*
* \since This function is available since SDL 3.0.0.
egl: implement public functions to obtain internal EGL handles These functions allow applications to call EGL functions against the SDL EGL context. For example, applications can use an EGL API loader via SDL_EGL_GetCurrentDisplay and SDL_EGL_GetProcAddress, and can call functions such as eglQuerySurface against the internal EGLSurface and EGLDisplay.
2022-08-26 02:44:35 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_EGLConfig SDLCALL SDL_EGL_GetCurrentEGLConfig(void);
egl: implement public functions to obtain internal EGL handles These functions allow applications to call EGL functions against the SDL EGL context. For example, applications can use an EGL API loader via SDL_EGL_GetCurrentDisplay and SDL_EGL_GetProcAddress, and can call functions such as eglQuerySurface against the internal EGLSurface and EGLDisplay.
2022-08-26 02:44:35 +00:00
/**
* Get the EGL surface associated with the window.
*
Add missing '\param' documentation
2023-02-12 08:40:39 +00:00
* \param window the window to query
egl: implement public functions to obtain internal EGL handles These functions allow applications to call EGL functions against the SDL EGL context. For example, applications can use an EGL API loader via SDL_EGL_GetCurrentDisplay and SDL_EGL_GetProcAddress, and can call functions such as eglQuerySurface against the internal EGLSurface and EGLDisplay.
2022-08-26 02:44:35 +00:00
* \returns the EGLSurface pointer associated with the window, or NULL on
* failure.
Sync SDL3 wiki -> header
2022-11-23 19:59:15 +00:00
*
* \since This function is available since SDL 3.0.0.
egl: implement public functions to obtain internal EGL handles These functions allow applications to call EGL functions against the SDL EGL context. For example, applications can use an EGL API loader via SDL_EGL_GetCurrentDisplay and SDL_EGL_GetProcAddress, and can call functions such as eglQuerySurface against the internal EGLSurface and EGLDisplay.
2022-08-26 02:44:35 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC SDL_EGLSurface SDLCALL SDL_EGL_GetWindowEGLSurface(SDL_Window *window);
egl: implement public functions to obtain internal EGL handles These functions allow applications to call EGL functions against the SDL EGL context. For example, applications can use an EGL API loader via SDL_EGL_GetCurrentDisplay and SDL_EGL_GetProcAddress, and can call functions such as eglQuerySurface against the internal EGLSurface and EGLDisplay.
2022-08-26 02:44:35 +00:00
egl: implement callbacks for defining custom EGL attributes Depending on the underlying EGL library, it may be desirable to conditionally set some specific EGL attributes depending on available extensions and other application state. SDL's EGL usage makes this a little bit complicated because: - there are multiple functions used to set up a working EGL context - some of these functions take different types of EGL attributes (EGLAttrib vs EGLint) - the EGL extension list before creating an EGLDisplay differs from the extension list after (i.e. display vs client extensions) - all of the above happens in a single SDL_CreateWindow call This leaves no place for the application to discover what EGL extensions are available and provide custom attribute lists. Until now, if a developer wants to add a custom EGL attribute for eglGetPlatformDisplay, eglCreateWindowSurface or eglCreateContext, they needed to patch SDL itself. This is very undesirable, since such developers would have to disable the SDL dynapi in order to maintain compatibility with their needs. This patch implements some callbacks which developers can use to dynamically generate custom EGL attributes for SDL to use during SDL_CreateWindow.
2022-08-26 05:41:06 +00:00
/**
* Sets the callbacks for defining custom EGLAttrib arrays for EGL
* initialization.
*
* Each callback should return a pointer to an EGL attribute array terminated
* with EGL_NONE. Callbacks may return NULL pointers to signal an error, which
* will cause the SDL_CreateWindow process to fail gracefully.
*
* The arrays returned by each callback will be appended to the existing
* attribute arrays defined by SDL.
*
* NOTE: These callback pointers will be reset after SDL_GL_ResetAttributes.
*
* \param platformAttribCallback Callback for attributes to pass to
* eglGetPlatformDisplay.
* \param surfaceAttribCallback Callback for attributes to pass to
* eglCreateSurface.
* \param contextAttribCallback Callback for attributes to pass to
* eglCreateContext.
Sync SDL3 wiki -> header
2022-11-23 19:59:15 +00:00
*
* \since This function is available since SDL 3.0.0.
egl: implement callbacks for defining custom EGL attributes Depending on the underlying EGL library, it may be desirable to conditionally set some specific EGL attributes depending on available extensions and other application state. SDL's EGL usage makes this a little bit complicated because: - there are multiple functions used to set up a working EGL context - some of these functions take different types of EGL attributes (EGLAttrib vs EGLint) - the EGL extension list before creating an EGLDisplay differs from the extension list after (i.e. display vs client extensions) - all of the above happens in a single SDL_CreateWindow call This leaves no place for the application to discover what EGL extensions are available and provide custom attribute lists. Until now, if a developer wants to add a custom EGL attribute for eglGetPlatformDisplay, eglCreateWindowSurface or eglCreateContext, they needed to patch SDL itself. This is very undesirable, since such developers would have to disable the SDL dynapi in order to maintain compatibility with their needs. This patch implements some callbacks which developers can use to dynamically generate custom EGL attributes for SDL to use during SDL_CreateWindow.
2022-08-26 05:41:06 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC void SDLCALL SDL_EGL_SetEGLAttributeCallbacks(SDL_EGLAttribArrayCallback platformAttribCallback,
egl: implement callbacks for defining custom EGL attributes Depending on the underlying EGL library, it may be desirable to conditionally set some specific EGL attributes depending on available extensions and other application state. SDL's EGL usage makes this a little bit complicated because: - there are multiple functions used to set up a working EGL context - some of these functions take different types of EGL attributes (EGLAttrib vs EGLint) - the EGL extension list before creating an EGLDisplay differs from the extension list after (i.e. display vs client extensions) - all of the above happens in a single SDL_CreateWindow call This leaves no place for the application to discover what EGL extensions are available and provide custom attribute lists. Until now, if a developer wants to add a custom EGL attribute for eglGetPlatformDisplay, eglCreateWindowSurface or eglCreateContext, they needed to patch SDL itself. This is very undesirable, since such developers would have to disable the SDL dynapi in order to maintain compatibility with their needs. This patch implements some callbacks which developers can use to dynamically generate custom EGL attributes for SDL to use during SDL_CreateWindow.
2022-08-26 05:41:06 +00:00
SDL_EGLIntArrayCallback surfaceAttribCallback,
SDL_EGLIntArrayCallback contextAttribCallback);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Set the swap interval for the current OpenGL context.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Some systems allow specifying -1 for the interval, to enable adaptive
* vsync. Adaptive vsync works the same as vsync, but if you've already missed
* the vertical retrace for a given frame, it swaps buffers immediately, which
Sync wiki -> header.
2021-07-14 21:07:04 +00:00
* might be less jarring for the user during occasional framerate drops. If an
* application requests adaptive vsync and the system does not support it,
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* this function will fail and return -1. In such a case, you should probably
* retry the call with 1 for the interval.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Adaptive vsync is implemented for some glX drivers with
include/SDL_video.h: You can google it. This looks bad when reading Markdown as plain text, as one would do when reading the headers directly.
2022-05-25 14:46:06 +00:00
* GLX_EXT_swap_control_tear, and for some Windows drivers with
* WGL_EXT_swap_control_tear.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* Read more on the Khronos wiki:
* https://www.khronos.org/opengl/wiki/Swap_Interval#Adaptive_Vsync
*
* \param interval 0 for immediate updates, 1 for updates synchronized with
* the vertical retrace, -1 for adaptive vsync
Update `\returns` to the generic form
2023-02-12 09:09:42 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
* \sa SDL_GL_GetSwapInterval
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GL_SetSwapInterval(int interval);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Get the swap interval for the current OpenGL context.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* If the system can't determine the swap interval, or there isn't a valid
Handle error return value for SDL_GetSwapInterval
2023-01-01 16:20:41 +00:00
* current context, this function will set *interval to 0 as a safe default.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync wiki -> headers.
2023-01-25 17:58:29 +00:00
* \param interval Output interval value. 0 if there is no vertical retrace
* synchronization, 1 if the buffer swap is synchronized with
* the vertical retrace, and -1 if late swaps happen
* immediately instead of waiting for the next retrace
Update `\returns` to the generic form
2023-02-12 09:09:42 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GL_SetSwapInterval
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GL_GetSwapInterval(int *interval);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Update a window with OpenGL rendering.
*
* This is used with double-buffered OpenGL contexts, which are the default.
*
Sync wiki -> header.
2021-07-14 21:07:04 +00:00
* On macOS, make sure you bind 0 to the draw framebuffer before swapping the
* window, otherwise nothing will happen. If you aren't using
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* glBindFramebuffer(), this is the default and you won't have to do anything
* extra.
*
* \param window the window to change
SDL_GL_SwapWindow() returns an error code
2022-12-29 15:27:42 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GL_SwapWindow(SDL_Window *window);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* Delete an OpenGL context.
*
* \param context the OpenGL context to be deleted
Change return type from void to int, for functions that set an error (SDL_SetError(), SDL_OutOfMemory(), SDL_Unsupported(), SDL_InvalidParam()) Update prototype to forward errors to generic layer, for the functions: MoveCursor, WarpMouse, GL_DeleteContext, GetDisplayModes. Check invalid parameter in SDL_SetTextInputRect() generic layer.
2023-02-06 19:24:12 +00:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*
Sync SDL wiki -> header
2022-11-22 22:40:14 +00:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-27 01:36:05 +00:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 18:18:39 +00:00
* \sa SDL_GL_CreateContext
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
*/
Renamed DECLSPEC to SDL_DECLSPEC
2024-05-17 23:52:36 +00:00
extern SDL_DECLSPEC int SDLCALL SDL_GL_DeleteContext(SDL_GLContext context);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
/* @} *//* OpenGL support functions */
/* Ends C function definitions when using C++ */
#ifdef __cplusplus
}
#endif
include: Renamed begin_code.h and close_code.h to have SDL_ prefixes. Fixes #6864.
2022-12-22 16:38:59 +00:00
#include <SDL3/SDL_close_code.h>
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 15:33:46 +00:00
Renaming of guard header names to quiet -Wreserved-id-macro Patch contributed by Sylvain
2016-11-21 05:34:54 +00:00
#endif /* SDL_video_h_ */
Reference in New Issue Copy Permalink