geemili
/
SDL
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
SDL/include/SDL3/SDL_video.h

2529 lines
94 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 09:33:46 -06:00
/*
Simple DirectMedia Layer
Updated copyright for 2024
2024-01-01 14:15:26 -07: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 09:33:46 -06: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.
*/
/**
* \file SDL_video.h
*
docs: Remove Doxygen `\brief` tags. Doxygen and the wiki bridge don't need them; they'll both just use the first line/sentence instead. Fixes #8446.
2023-11-06 08:26:06 -07:00
* Header file for 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 09:33:46 -06:00
*/
Renaming of guard header names to quiet -Wreserved-id-macro Patch contributed by Sylvain
2016-11-20 22:34:54 -07: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 09:33:46 -06: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-26 21:43:38 -07:00
#include <SDL3/SDL_stdinc.h>
#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 17:59:51 -06: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-26 21:43:38 -07: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 09:33:46 -06:00
include: Renamed begin_code.h and close_code.h to have SDL_ prefixes. Fixes #6864.
2022-12-22 09:38:59 -07: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 09:33:46 -06: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 02:27:28 -07:00
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07:00
typedef Uint32 SDL_DisplayID;
Add SDL_WindowID type for SDL_Window id
2023-01-04 02:27:28 -07:00
typedef Uint32 SDL_WindowID;
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 01:01:34 -07:00
/**
docs: Remove Doxygen `\brief` tags. Doxygen and the wiki bridge don't need them; they'll both just use the first line/sentence instead. Fixes #8446.
2023-11-06 08:26:06 -07:00
* 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 01:01:34 -07:00
*/
typedef enum
{
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-27 22:52:33 -06: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 01:01:34 -07: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 09:33:46 -06:00
/**
docs: Remove Doxygen `\brief` tags. Doxygen and the wiki bridge don't need them; they'll both just use the first line/sentence instead. Fixes #8446.
2023-11-06 08:26:06 -07:00
* The structure that defines a 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 09:33:46 -06: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-01-31 22:23:14 -07:00
* \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 09:33:46 -06:00
* \sa SDL_GetDesktopDisplayMode()
* \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-01-31 22:23:14 -07:00
* \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 09:33:46 -06:00
*/
typedef struct
{
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-01-31 22:23:14 -07:00
SDL_DisplayID displayID; /**< the display this mode is associated with */
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 09:33:46 -06:00
Uint32 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 17:29:52 -06: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 16:47:19 -07: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 09:33:46 -06: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 01:01:34 -07:00
/**
docs: Remove Doxygen `\brief` tags. Doxygen and the wiki bridge don't need them; they'll both just use the first line/sentence instead. Fixes #8446.
2023-11-06 08:26:06 -07:00
* Display orientation
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 01:01:34 -07:00
*/
typedef enum
{
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 09:33:46 -06:00
/**
docs: Remove Doxygen `\brief` tags. Doxygen and the wiki bridge don't need them; they'll both just use the first line/sentence instead. Fixes #8446.
2023-11-06 08:26:06 -07:00
* The type used to identify 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 09:33:46 -06: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 12:29:30 -07:00
* \sa SDL_CreateWindow
* \sa SDL_CreateWindowWithProperties
* \sa SDL_DestroyWindow
* \sa SDL_FlashWindow
* \sa SDL_GetWindowFlags
* \sa SDL_GetWindowGrab
* \sa SDL_GetWindowKeyboardGrab
* \sa SDL_GetWindowMouseGrab
* \sa SDL_GetWindowPosition
* \sa SDL_GetWindowSize
* \sa SDL_GetWindowTitle
* \sa SDL_HideWindow
* \sa SDL_MaximizeWindow
* \sa SDL_MinimizeWindow
* \sa SDL_RaiseWindow
* \sa SDL_RestoreWindow
* \sa SDL_SetWindowFullscreen
* \sa SDL_SetWindowGrab
* \sa SDL_SetWindowKeyboardGrab
* \sa SDL_SetWindowMouseGrab
* \sa SDL_SetWindowIcon
* \sa SDL_SetWindowPosition
* \sa SDL_SetWindowSize
* \sa SDL_SetWindowBordered
* \sa SDL_SetWindowResizable
* \sa SDL_SetWindowTitle
* \sa SDL_ShowWindow
* \sa SDL_ShowWindowSystemMenu
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 09:33:46 -06:00
*/
typedef struct SDL_Window SDL_Window;
/**
docs: Remove Doxygen `\brief` tags. Doxygen and the wiki bridge don't need them; they'll both just use the first line/sentence instead. Fixes #8446.
2023-11-06 08:26:06 -07:00
* The flags on 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 09:33:46 -06: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 12:29:30 -07: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 09:33:46 -06:00
*/
Fixed warning C4245: 'initializing': conversion from 'int' to 'Uint32', signed/unsigned mismatch in SDL_video.c
2023-12-29 10:28:28 -07:00
#define SDL_WINDOW_FULLSCREEN 0x00000001U /**< window is in fullscreen mode */
#define SDL_WINDOW_OPENGL 0x00000002U /**< window usable with OpenGL context */
#define SDL_WINDOW_OCCLUDED 0x00000004U /**< window is occluded */
#define SDL_WINDOW_HIDDEN 0x00000008U /**< 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 0x00000010U /**< no window decoration */
#define SDL_WINDOW_RESIZABLE 0x00000020U /**< window can be resized */
#define SDL_WINDOW_MINIMIZED 0x00000040U /**< window is minimized */
#define SDL_WINDOW_MAXIMIZED 0x00000080U /**< window is maximized */
#define SDL_WINDOW_MOUSE_GRABBED 0x00000100U /**< window has grabbed mouse input */
#define SDL_WINDOW_INPUT_FOCUS 0x00000200U /**< window has input focus */
#define SDL_WINDOW_MOUSE_FOCUS 0x00000400U /**< window has mouse focus */
#define SDL_WINDOW_EXTERNAL 0x00000800U /**< window not created by SDL */
#define SDL_WINDOW_HIGH_PIXEL_DENSITY 0x00002000U /**< window uses high pixel density back buffer if possible */
#define SDL_WINDOW_MOUSE_CAPTURE 0x00004000U /**< window has mouse captured (unrelated to MOUSE_GRABBED) */
#define SDL_WINDOW_ALWAYS_ON_TOP 0x00008000U /**< window should always be above others */
#define SDL_WINDOW_UTILITY 0x00020000U /**< window should be treated as a utility window, not showing in the task bar and window list */
#define SDL_WINDOW_TOOLTIP 0x00040000U /**< window should be treated as a tooltip */
#define SDL_WINDOW_POPUP_MENU 0x00080000U /**< window should be treated as a popup menu */
#define SDL_WINDOW_KEYBOARD_GRABBED 0x00100000U /**< window has grabbed keyboard input */
#define SDL_WINDOW_VULKAN 0x10000000U /**< window usable for Vulkan surface */
#define SDL_WINDOW_METAL 0x20000000U /**< window usable for Metal view */
#define SDL_WINDOW_TRANSPARENT 0x40000000U /**< window with transparent buffer */
#define SDL_WINDOW_NOT_FOCUSABLE 0x80000000U /**< 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 09:33:46 -06:00
/**
docs: Remove Doxygen `\brief` tags. Doxygen and the wiki bridge don't need them; they'll both just use the first line/sentence instead. Fixes #8446.
2023-11-06 08:26:06 -07:00
* Used to indicate that you don't care what the window position is.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 09:33:46 -06: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 14:35:36 -06: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 09:33:46 -06: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)
/**
docs: Remove Doxygen `\brief` tags. Doxygen and the wiki bridge don't need them; they'll both just use the first line/sentence instead. Fixes #8446.
2023-11-06 08:26:06 -07:00
* Used to indicate that the window position should be centered.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 09:33:46 -06: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 14:35:36 -06: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 09:33:46 -06: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 14:41:55 -06:00
/**
docs: Remove Doxygen `\brief` tags. Doxygen and the wiki bridge don't need them; they'll both just use the first line/sentence instead. Fixes #8446.
2023-11-06 08:26:06 -07:00
* Window flash operation
Added a window flash operation to be explicit about window flash behavior
2021-07-24 14:41:55 -06:00
*/
typedef enum
{
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-15 22:43:37 -06: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 14:41:55 -06: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 09:33:46 -06:00
/**
docs: Remove Doxygen `\brief` tags. Doxygen and the wiki bridge don't need them; they'll both just use the first line/sentence instead. Fixes #8446.
2023-11-06 08:26:06 -07:00
* An opaque handle to an 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 09:33:46 -06: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-25 20:44:35 -06:00
/**
docs: Remove Doxygen `\brief` tags. Doxygen and the wiki bridge don't need them; they'll both just use the first line/sentence instead. Fixes #8446.
2023-11-06 08:26:06 -07:00
* Opaque EGL types.
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-25 20:44:35 -06: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-25 23:41:06 -06:00
typedef intptr_t SDL_EGLAttrib;
typedef int SDL_EGLint;
/**
docs: Remove Doxygen `\brief` tags. Doxygen and the wiki bridge don't need them; they'll both just use the first line/sentence instead. Fixes #8446.
2023-11-06 08:26:06 -07:00
* EGL attribute initialization callback types.
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-25 23:41:06 -06: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-25 20:44:35 -06: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 09:33:46 -06:00
/**
docs: Remove Doxygen `\brief` tags. Doxygen and the wiki bridge don't need them; they'll both just use the first line/sentence instead. Fixes #8446.
2023-11-06 08:26:06 -07:00
* OpenGL configuration attributes
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 09:33:46 -06:00
*/
typedef enum
{
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 13:02:03 -06:00
SDL_GL_CONTEXT_RELEASE_BEHAVIOR,
opengl: add support for GL_KHR_no_error. This is completely untested! Fixes Bugzilla #3721.
2017-08-24 19:30:53 -06:00
SDL_GL_CONTEXT_RESET_NOTIFICATION,
SDL_video: Added SDL_GL_FLOATBUFFERS to allow Cocoa GL contexts to use EDR
2022-07-06 13:12:30 -06: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-25 21:29:41 -06: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 09:33:46 -06:00
} SDL_GLattr;
typedef enum
{
SDL_GL_CONTEXT_PROFILE_CORE = 0x0001,
SDL_GL_CONTEXT_PROFILE_COMPATIBILITY = 0x0002,
Fixed comments in headers for doxygen output.
2017-06-04 15:15:39 -06: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 09:33:46 -06:00
} SDL_GLprofile;
typedef enum
{
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;
typedef enum
{
SDL_GL_CONTEXT_RELEASE_BEHAVIOR_NONE = 0x0000,
SDL_GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH = 0x0001
} SDL_GLcontextReleaseFlag;
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 13:02:03 -06:00
typedef enum
{
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 09:33:46 -06:00
/* Function prototypes */
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
extern DECLSPEC int SDLCALL SDL_GetNumVideoDrivers(void);
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
extern DECLSPEC const char *SDLCALL SDL_GetVideoDriver(int index);
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
extern DECLSPEC const char *SDLCALL SDL_GetCurrentVideoDriver(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 01:01:34 -07:00
/**
* Get the current system theme
*
* \returns the current system theme, light, dark, or unknown
*
* \since This function is available since SDL 3.0.0.
*/
extern DECLSPEC SDL_SystemTheme SDLCALL SDL_GetSystemTheme(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 09:33:46 -06:00
/**
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07:00
* Get a list of currently connected displays.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07:00
* \param count a pointer filled in with the number of displays returned
Sync SDL3 wiki -> header
2023-01-29 20:26:14 -07: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 14:30:55 -07:00
*
* \since This function is available since SDL 3.0.0.
*/
extern DECLSPEC SDL_DisplayID *SDLCALL SDL_GetDisplays(int *count);
/**
* Return the primary display.
*
Sync SDL3 wiki -> header
2023-01-29 20:26:14 -07: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 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07: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 09:33:46 -06:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07: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 09:33:46 -06:00
*/
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07:00
extern 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 09:33:46 -06:00
Added display properties
2023-11-07 10:58:49 -07:00
/**
* Get the properties associated with a display.
*
* \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
*/
extern DECLSPEC SDL_PropertiesID SDLCALL SDL_GetDisplayProperties(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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07:00
* \param displayID the instance ID of the display to query
Sync SDL3 wiki -> header
2023-01-29 20:26:14 -07: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07: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 09:33:46 -06:00
*/
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07:00
extern 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 09:33:46 -06: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 17:29:52 -06:00
* Get the desktop area represented by a display.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07: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 09:33:46 -06:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07:00
* \param displayID the instance ID of the display to query
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07: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 09:33:46 -06:00
*/
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07:00
extern 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 09:33:46 -06:00
Added SDL_GetDisplayUsableBounds().
2016-01-04 21:52:40 -07:00
/**
Sync wiki -> headers.
2023-01-25 10:58:29 -07: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 12:18:39 -06: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 14:30:55 -07:00
* \param displayID the instance ID of the display to query
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-04 21:52:40 -07:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Added SDL_GetDisplayUsableBounds().
2016-01-04 21:52:40 -07:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \sa SDL_GetDisplayBounds
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07:00
* \sa SDL_GetDisplays
Added SDL_GetDisplayUsableBounds().
2016-01-04 21:52:40 -07:00
*/
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07:00
extern DECLSPEC int SDLCALL SDL_GetDisplayUsableBounds(SDL_DisplayID displayID, SDL_Rect *rect);
Added SDL_GetDisplayUsableBounds().
2016-01-04 21:52:40 -07: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 01:52:40 -06: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
*/
Fixed display orientation function names for SDL 3.0 convention
2023-06-17 10:28:27 -06:00
extern 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 01:52:40 -06: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-22 22:48:28 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-22 22:48:28 -06:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07:00
* \param displayID the instance ID of the display to query
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-22 22:48:28 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07: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-22 22:48:28 -06:00
*/
Fixed display orientation function names for SDL 3.0 convention
2023-06-17 10:28:27 -06:00
extern 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-22 22:48:28 -06: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 17:29:52 -06:00
/**
* Get the content scale of a display.
*
Sync SDL3 wiki -> header
2023-05-17 13:59:14 -06: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 17:29:52 -06:00
*
* \param displayID the instance ID of the display to query
Sync SDL3 wiki -> header
2023-05-17 13:59:14 -06: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 17:29:52 -06:00
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_GetDisplays
*/
extern DECLSPEC float SDLCALL SDL_GetDisplayContentScale(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 09:33:46 -06: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-01-31 22:23:14 -07: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 09:49:41 -07: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 17:29:52 -06: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-01-31 22:23:14 -07: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 17:29:52 -06: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 09:33:46 -06:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07: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-01-31 22:23:14 -07:00
* \param count a pointer filled in with the number of displays returned
Sync wiki -> headers.
2023-02-24 09:49:41 -07: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 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07: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 09:33:46 -06: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-01-31 22:23:14 -07:00
extern 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 09:33:46 -06: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-01-31 22:23:14 -07: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 09:33:46 -06: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-01-31 22:23:14 -07: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 12:18:39 -06:00
*
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07: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-01-31 22:23:14 -07: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 09:49:41 -07: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 07:45:16 -06:00
* \param include_high_density_modes Boolean to include high density modes in
* the search
Sync wiki -> headers.
2023-02-24 09:49:41 -07: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 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06: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-01-31 22:23:14 -07: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 09:33:46 -06:00
*/
SDL_GetClosestFullscreenDisplayMode() now takes a boolean whether to include high density modes Also changed the match to prioritize resolution over refresh rate
2023-05-18 13:15:23 -06:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 14:30:55 -07: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-01-31 22:23:14 -07: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 12:18:39 -06:00
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-01-31 22:23:14 -07: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 09:33:46 -06: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-01-31 22:23:14 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 14:30:55 -07: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-01-31 22:23:14 -07: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 12:18:39 -06:00
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \sa SDL_GetDesktopDisplayMode
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07: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 09:33:46 -06: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-01-31 22:23:14 -07:00
extern 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 09:33:46 -06: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 12:26:52 -06: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 17:29:52 -06: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 12:26:52 -06:00
*
* \param point the point to query
Sync SDL3 wiki -> header
2023-01-29 20:26:14 -07: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 12:26:52 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
SDL_video.h: Added \since info to new APIs.
2022-08-09 07:05:08 -06: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 12:26:52 -06:00
* \sa SDL_GetDisplayBounds
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07: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 12:26:52 -06:00
*/
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07:00
extern 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 12:26:52 -06: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 17:29:52 -06: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 12:26:52 -06:00
*
* \param rect the rect to query
Sync SDL3 wiki -> header
2023-01-29 20:26:14 -07: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 12:26:52 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
SDL_video.h: Added \since info to new APIs.
2022-08-09 07:05:08 -06: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 12:26:52 -06:00
* \sa SDL_GetDisplayBounds
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07: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 12:26:52 -06:00
*/
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07:00
extern 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 12:26:52 -06: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 09:33:46 -06:00
/**
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07:00
* Get the display associated with a window.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
*
* \param window the window to query
Sync SDL3 wiki -> header
2023-01-29 20:26:14 -07: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \sa SDL_GetDisplayBounds
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07: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 09:33:46 -06:00
*/
Displays are now referenced by instance ID instead of index
2023-01-29 14:30:55 -07:00
extern 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 09:33:46 -06: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 17:39:15 -06:00
/**
* Get the pixel density of a window.
*
Sync SDL3 wiki -> header
2023-05-17 18:55:15 -06: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 17:39:15 -06:00
*
* \param window the window to query
Sync SDL3 wiki -> header
2023-05-17 18:55:15 -06: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 17:39:15 -06:00
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_GetWindowDisplayScale
*/
extern DECLSPEC float SDLCALL SDL_GetWindowPixelDensity(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 17:29:52 -06:00
/**
* Get the content display scale relative to a window's pixel size.
*
Sync SDL3 wiki -> header
2023-05-17 13:59:14 -06: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 17:29:52 -06:00
*
Sync SDL3 wiki -> header
2023-05-17 13:59:14 -06: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 17:29:52 -06:00
*
* \param window the window to query
Sync SDL3 wiki -> header
2023-05-17 13:59:14 -06: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 17:29:52 -06:00
*
* \since This function is available since SDL 3.0.0.
*/
extern DECLSPEC float SDLCALL SDL_GetWindowDisplayScale(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 09:33:46 -06: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-01-31 22:23:14 -07: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06: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 12:18:39 -06:00
* \param window the window to affect
Sync wiki -> headers.
2023-02-24 09:49:41 -07:00
* \param mode a pointer to the display mode to use, which can be NULL for
* desktop mode, or one of the fullscreen modes returned by
* SDL_GetFullscreenDisplayModes().
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06: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-01-31 22:23:14 -07:00
* \sa SDL_GetWindowFullscreenMode
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 13:09:55 -06: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 09:33:46 -06: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-01-31 22:23:14 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \param window the window 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-01-31 22:23:14 -07:00
* \returns a pointer to the fullscreen mode to use or NULL for desktop mode
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06: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-01-31 22:23:14 -07:00
* \sa SDL_SetWindowFullscreenMode
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06: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-01-31 22:23:14 -07:00
extern 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 09:33:46 -06: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-21 18:37:20 -06:00
/**
* Get the raw ICC profile data for the screen the window is currently on.
Sync wiki -> header
2021-10-21 18:39:04 -06: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-21 18:37:20 -06:00
* Data returned should be freed with SDL_free.
Sync wiki -> header
2021-10-21 18:39:04 -06: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-21 18:37:20 -06:00
* \param window the window to query
* \param size the size of the ICC profile
Sync wiki -> header
2021-10-21 18:39:04 -06:00
* \returns the raw ICC profile data on success or NULL on failure; call
* SDL_GetError() for more information.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07: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-21 18:37:20 -06: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 02:23:17 -07:00
extern 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-21 18:37:20 -06: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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-26 19:36:05 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07: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 09:33:46 -06: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 02:23:17 -07:00
extern 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 09:33:46 -06: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-03-31 18:07:38 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06: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 12:30:28 -07:00
* - `SDL_WINDOW_FULLSCREEN`: fullscreen window at desktop resolution
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 10:55:27 -07:00
* - `SDL_WINDOW_MOUSE_GRABBED`: window has grabbed mouse focus
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
*
Remove SDL_WINDOW_SHOW flag, as redundant with SDL_WINDOW_HIDDEN
2022-12-28 12:17:55 -07: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 12:18:39 -06: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 13:59:14 -06: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 13:25:46 -07:00
* SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED event.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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.
*
* 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 17:29:52 -06: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 12:18:39 -06: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 12:16:05 -07: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 12:29:30 -07:00
* \sa SDL_CreateWindowWithProperties
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
SDL_CreateWindow() has been simplified and no longer takes a window position.
2023-03-05 15:44:38 -07:00
extern DECLSPEC SDL_Window *SDLCALL SDL_CreateWindow(const char *title, int w, int h, Uint32 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 09:33:46 -06: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 12:16:05 -07:00
/**
* Create a child popup window of the specified parent window.
*
Sync SDL3 wiki -> header
2023-03-13 11:57:18 -06: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 08:22:19 -07: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 12:29:30 -07:00
*
* - 'SDL_WINDOW_MINIMIZED'
* - 'SDL_WINDOW_MAXIMIZED'
* - 'SDL_WINDOW_FULLSCREEN'
* - 'SDL_WINDOW_BORDERLESS'
Sync SDL3 wiki -> header
2023-03-10 16:52:18 -07: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 11:57:18 -06: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 11:46:06 -06: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 12:16:05 -07: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 17:29:52 -06: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 12:16:05 -07: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 17:29:52 -06:00
* of the parent window
* \param w the width of the window
* \param h the height of the window
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 11:46:06 -06:00
* \param flags SDL_WINDOW_TOOLTIP or SDL_WINDOW_POPUP MENU, and zero or more
* 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 12:16:05 -07: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 12:29:30 -07: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 12:16:05 -07:00
* \sa SDL_DestroyWindow
Added SDL_GetWindowParent() to get the parent of popup windows
2023-03-13 12:20:42 -06: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 12:16:05 -07:00
*/
extern DECLSPEC SDL_Window *SDLCALL SDL_CreatePopupWindow(SDL_Window *parent, int offset_x, int offset_y, int w, int h, Uint32 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 09:33:46 -06: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 12:29:30 -07: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-12 22:37:00 -07:00
*
* These are the supported properties:
Sync wiki -> headers.
2023-11-13 11:03:42 -07:00
*
Sync SDL3 wiki -> header
2024-01-08 10:34:23 -07:00
* - `SDL_PROPERTY_WINDOW_CREATE_ALWAYS_ON_TOP_BOOLEAN`: true if the window
* should be always on top
* - `SDL_PROPERTY_WINDOW_CREATE_BORDERLESS_BOOLEAN`: true if the window has
* no window decoration
* - `SDL_PROPERTY_WINDOW_CREATE_FOCUSABLE_BOOLEAN`: true if the window should
* accept keyboard input (defaults true)
* - `SDL_PROPERTY_WINDOW_CREATE_FULLSCREEN_BOOLEAN`: true if the window
* should start in fullscreen mode at desktop resolution
* - `SDL_PROPERTY_WINDOW_CREATE_HEIGHT_NUMBER`: the height of the window
* - `SDL_PROPERTY_WINDOW_CREATE_HIDDEN_BOOLEAN`: true if the window should
* start hidden
* - `SDL_PROPERTY_WINDOW_CREATE_HIGH_PIXEL_DENSITY_BOOLEAN`: true if the
* window uses a high pixel density buffer if possible
* - `SDL_PROPERTY_WINDOW_CREATE_MAXIMIZED_BOOLEAN`: true if the window should
* start maximized
* - `SDL_PROPERTY_WINDOW_CREATE_MENU_BOOLEAN`: true if the window is a popup
* menu
* - `SDL_PROPERTY_WINDOW_CREATE_METAL_BOOLEAN`: true if the window will be
* used with Metal rendering
* - `SDL_PROPERTY_WINDOW_CREATE_MINIMIZED_BOOLEAN`: true if the window should
* start minimized
* - `SDL_PROPERTY_WINDOW_CREATE_MOUSE_GRABBED_BOOLEAN`: true if the window
* starts with grabbed mouse focus
* - `SDL_PROPERTY_WINDOW_CREATE_OPENGL_BOOLEAN`: true if the window will be
* used with OpenGL rendering
* - `SDL_PROPERTY_WINDOW_CREATE_PARENT_POINTER`: an SDL_Window that will be
* the parent of this window, required for windows with the "toolip" and
* "menu" properties
* - `SDL_PROPERTY_WINDOW_CREATE_RESIZABLE_BOOLEAN`: true if the window should
* be resizable
* - `SDL_PROPERTY_WINDOW_CREATE_TITLE_STRING`: the title of the window, in
* UTF-8 encoding
* - `SDL_PROPERTY_WINDOW_CREATE_TRANSPARENT_BOOLEAN`: true if the window show
* transparent in the areas with alpha of 0
* - `SDL_PROPERTY_WINDOW_CREATE_TOOLTIP_BOOLEAN`: true if the window is a
* tooltip
* - `SDL_PROPERTY_WINDOW_CREATE_UTILITY_BOOLEAN`: true if the window is a
* utility window, not showing in the task bar and window list
* - `SDL_PROPERTY_WINDOW_CREATE_VULKAN_BOOLEAN`: true if the window will be
* used with Vulkan rendering
* - `SDL_PROPERTY_WINDOW_CREATE_WIDTH_NUMBER`: the width of the window
* - `SDL_PROPERTY_WINDOW_CREATE_X_NUMBER`: the x position of the window, or
* `SDL_WINDOWPOS_CENTERED`, defaults to `SDL_WINDOWPOS_UNDEFINED`. This is
* relative to the parent for windows with the "parent" property set.
* - `SDL_PROPERTY_WINDOW_CREATE_Y_NUMBER`: the y position of the window, or
* `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-12 22:37:00 -07:00
*
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 10:13:18 -07:00
* These are additional supported properties on macOS:
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07:00
*
include: Remove string literals from properties documentation. I'm going to let the wiki bridge clean up the word wrapping for me, here. :)
2024-01-08 10:33:29 -07:00
* - `SDL_PROPERTY_WINDOW_CREATE_COCOA_WINDOW_POINTER`: the
Sync SDL3 wiki -> header
2024-01-08 10:16:19 -07:00
* `(__unsafe_unretained)` NSWindow associated with the window, if you want
* to wrap an existing window.
include: Remove string literals from properties documentation. I'm going to let the wiki bridge clean up the word wrapping for me, here. :)
2024-01-08 10:33:29 -07:00
* - `SDL_PROPERTY_WINDOW_CREATE_COCOA_VIEW_POINTER`: the
Sync SDL3 wiki -> header
2024-01-08 10:16:19 -07:00
* `(__unsafe_unretained)` NSView associated with the window, defaults to
* `[window contentView]`
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07: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 13:37:38 -07:00
* These are additional supported properties on Wayland:
*
* - `SDL_PROPERTY_WINDOW_CREATE_WAYLAND_SURFACE_ROLE_CUSTOM_BOOLEAN` - true
* if the application wants to use the Wayland surface for a custom role and
* does not want it attached to an XDG toplevel window. See
* docs/README-wayland.md for more information on using custom surfaces.
*
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 10:13:18 -07:00
* These are additional supported properties on Windows:
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07:00
*
Sync SDL3 wiki -> header
2024-01-08 10:34:23 -07:00
* - `SDL_PROPERTY_WINDOW_CREATE_WIN32_HWND_POINTER`: the HWND associated with
* the window, if you want to wrap an existing window.
* - `SDL_PROPERTY_WINDOW_CREATE_WIN32_PIXEL_FORMAT_HWND_POINTER`: optional,
* another window to share pixel format with, useful for OpenGL windows
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07:00
*
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 10:13:18 -07:00
* These are additional supported properties with X11:
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07:00
*
Sync SDL3 wiki -> header
2024-01-08 10:34:23 -07:00
* - `SDL_PROPERTY_WINDOW_CREATE_X11_WINDOW_NUMBER`: the X11 Window associated
* with the window, if you want to wrap an existing window.
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07:00
*
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 10:13:18 -07:00
* The window is implicitly shown if the "hidden" property is not set.
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07:00
*
* Windows with the "tooltip" and "menu" properties are popup windows and have
* the behaviors and guidelines outlined in `SDL_CreatePopupWindow()`.
*
* \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.
*
* \sa SDL_CreateWindow
* \sa SDL_DestroyWindow
*/
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 12:29:30 -07:00
extern 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 09:33:46 -06: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 13:37:38 -07:00
#define SDL_PROPERTY_WINDOW_CREATE_ALWAYS_ON_TOP_BOOLEAN "always-on-top"
#define SDL_PROPERTY_WINDOW_CREATE_BORDERLESS_BOOLEAN "borderless"
#define SDL_PROPERTY_WINDOW_CREATE_FOCUSABLE_BOOLEAN "focusable"
#define SDL_PROPERTY_WINDOW_CREATE_FULLSCREEN_BOOLEAN "fullscreen"
#define SDL_PROPERTY_WINDOW_CREATE_HEIGHT_NUMBER "height"
#define SDL_PROPERTY_WINDOW_CREATE_HIDDEN_BOOLEAN "hidden"
#define SDL_PROPERTY_WINDOW_CREATE_HIGH_PIXEL_DENSITY_BOOLEAN "high-pixel-density"
#define SDL_PROPERTY_WINDOW_CREATE_MAXIMIZED_BOOLEAN "maximized"
#define SDL_PROPERTY_WINDOW_CREATE_MENU_BOOLEAN "menu"
#define SDL_PROPERTY_WINDOW_CREATE_METAL_BOOLEAN "metal"
#define SDL_PROPERTY_WINDOW_CREATE_MINIMIZED_BOOLEAN "minimized"
#define SDL_PROPERTY_WINDOW_CREATE_MOUSE_GRABBED_BOOLEAN "mouse-grabbed"
#define SDL_PROPERTY_WINDOW_CREATE_OPENGL_BOOLEAN "opengl"
#define SDL_PROPERTY_WINDOW_CREATE_PARENT_POINTER "parent"
#define SDL_PROPERTY_WINDOW_CREATE_RESIZABLE_BOOLEAN "resizable"
#define SDL_PROPERTY_WINDOW_CREATE_TITLE_STRING "title"
#define SDL_PROPERTY_WINDOW_CREATE_TRANSPARENT_BOOLEAN "transparent"
#define SDL_PROPERTY_WINDOW_CREATE_TOOLTIP_BOOLEAN "tooltip"
#define SDL_PROPERTY_WINDOW_CREATE_UTILITY_BOOLEAN "utility"
#define SDL_PROPERTY_WINDOW_CREATE_VULKAN_BOOLEAN "vulkan"
#define SDL_PROPERTY_WINDOW_CREATE_WIDTH_NUMBER "width"
#define SDL_PROPERTY_WINDOW_CREATE_X_NUMBER "x"
#define SDL_PROPERTY_WINDOW_CREATE_Y_NUMBER "y"
#define SDL_PROPERTY_WINDOW_CREATE_COCOA_WINDOW_POINTER "cocoa.window"
#define SDL_PROPERTY_WINDOW_CREATE_COCOA_VIEW_POINTER "cocoa.view"
#define SDL_PROPERTY_WINDOW_CREATE_WAYLAND_SURFACE_ROLE_CUSTOM_BOOLEAN "wayland.surface_role_custom"
#define SDL_PROPERTY_WINDOW_CREATE_WIN32_HWND_POINTER "win32.hwnd"
#define SDL_PROPERTY_WINDOW_CREATE_WIN32_PIXEL_FORMAT_HWND_POINTER "win32.pixel_format_hwnd"
#define SDL_PROPERTY_WINDOW_CREATE_X11_WINDOW_NUMBER "x11.window"
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 10:13:18 -07: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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06: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 02:23:17 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:07:04 -06: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 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06: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 02:23:17 -07:00
extern 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 09:33:46 -06:00
Added SDL_GetWindowParent() to get the parent of popup windows
2023-03-13 12:20:42 -06:00
/**
* Get parent of a window.
*
* \param window the window to query
Sync SDL3 wiki -> header
2023-03-13 12:22:16 -06: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 12:20:42 -06:00
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_CreatePopupWindow
*/
extern DECLSPEC SDL_Window *SDLCALL SDL_GetWindowParent(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 17:59:51 -06:00
/**
* Get the properties associated with a window.
*
Note that the SDL window properties are read-only
2023-11-13 14:58:33 -07:00
* The following read-only properties are provided by SDL:
Sync wiki -> headers.
2023-11-13 11:03:42 -07:00
*
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07:00
* On Android:
*
Sync SDL3 wiki -> header
2024-01-08 10:34:23 -07:00
* - `SDL_PROPERTY_WINDOW_ANDROID_WINDOW_POINTER`: the ANativeWindow
* associated with the window
* - `SDL_PROPERTY_WINDOW_ANDROID_SURFACE_POINTER`: the EGLSurface associated
* with the window
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07:00
*
* On iOS:
*
Sync SDL3 wiki -> header
2024-01-08 10:34:23 -07:00
* - `SDL_PROPERTY_WINDOW_UIKIT_WINDOW_POINTER`: the `(__unsafe_unretained)`
* UIWindow associated with the window
* - `SDL_PROPERTY_WINDOW_UIKIT_METAL_VIEW_TAG_NUMBER`: the NSInteger tag
* assocated with metal views on the window
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07:00
*
* On KMS/DRM:
*
Sync SDL3 wiki -> header
2024-01-08 10:34:23 -07:00
* - `SDL_PROPERTY_WINDOW_KMSDRM_DEVICE_INDEX_NUMBER`: the device index
* associated with the window (e.g. the X in /dev/dri/cardX)
* - `SDL_PROPERTY_WINDOW_KMSDRM_DRM_FD_NUMBER`: the DRM FD associated with
* the window
* - `SDL_PROPERTY_WINDOW_KMSDRM_GBM_DEVICE_POINTER`: the GBM device
* associated with the window
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07:00
*
* On macOS:
*
Sync SDL3 wiki -> header
2024-01-08 10:34:23 -07:00
* - `SDL_PROPERTY_WINDOW_COCOA_WINDOW_POINTER`: the `(__unsafe_unretained)`
* NSWindow associated with the window
* - `SDL_PROPERTY_WINDOW_COCOA_METAL_VIEW_TAG_NUMBER`: the NSInteger tag
* assocated with metal views on the window
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07:00
*
* On Vivante:
*
Sync SDL3 wiki -> header
2024-01-08 10:34:23 -07:00
* - `SDL_PROPERTY_WINDOW_VIVANTE_DISPLAY_POINTER`: the EGLNativeDisplayType
* associated with the window
* - `SDL_PROPERTY_WINDOW_VIVANTE_WINDOW_POINTER`: the EGLNativeWindowType
* associated with the window
* - `SDL_PROPERTY_WINDOW_VIVANTE_SURFACE_POINTER`: the EGLSurface associated
* with the window
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07:00
*
* On UWP:
*
Sync SDL3 wiki -> header
2024-01-08 10:34:23 -07:00
* - `SDL_PROPERTY_WINDOW_WINRT_WINDOW_POINTER`: the IInspectable CoreWindow
* associated with the window
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07:00
*
* On Windows:
*
Sync SDL3 wiki -> header
2024-01-08 10:34:23 -07:00
* - `SDL_PROPERTY_WINDOW_WIN32_HWND_POINTER`: the HWND associated with the
* window
* - `SDL_PROPERTY_WINDOW_WIN32_HDC_POINTER`: the HDC associated with the
* window
* - `SDL_PROPERTY_WINDOW_WIN32_INSTANCE_POINTER`: the HINSTANCE associated
* with the window
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07:00
*
* On Wayland:
*
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 10:13:18 -07:00
* Note: The `xdg_*` window objects do not internally persist across window
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07: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-08 10:34:23 -07:00
* - `SDL_PROPERTY_WINDOW_WAYLAND_DISPLAY_POINTER`: the wl_display associated
Sync SDL3 wiki -> header
2024-01-08 10:16:19 -07:00
* with the window
Sync SDL3 wiki -> header
2024-01-08 10:34:23 -07:00
* - `SDL_PROPERTY_WINDOW_WAYLAND_SURFACE_POINTER`: the wl_surface associated
* with the window
* - `SDL_PROPERTY_WINDOW_WAYLAND_EGL_WINDOW_POINTER`: the wl_egl_window
* associated with the window
* - `SDL_PROPERTY_WINDOW_WAYLAND_XDG_SURFACE_POINTER`: the xdg_surface
* associated with the window
* - `SDL_PROPERTY_WINDOW_WAYLAND_XDG_TOPLEVEL_POINTER`: the xdg_toplevel role
* associated with the window
* - `SDL_PROPERTY_WINDOW_WAYLAND_XDG_POPUP_POINTER`: the xdg_popup role
* associated with the window
* - `SDL_PROPERTY_WINDOW_WAYLAND_XDG_POSITIONER_POINTER`: the xdg_positioner
* associated with the window, in popup mode
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 10:13:18 -07:00
*
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07:00
* On X11:
*
Sync SDL3 wiki -> header
2024-01-08 10:34:23 -07:00
* - `SDL_PROPERTY_WINDOW_X11_DISPLAY_POINTER`: the X11 Display associated
* with the window
* - `SDL_PROPERTY_WINDOW_X11_SCREEN_NUMBER`: the screen number associated
* with the window
* - `SDL_PROPERTY_WINDOW_X11_WINDOW_NUMBER`: the X11 Window associated with
* the window
Sync SDL3 wiki -> header
2024-01-07 18:02:25 -07: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
* \sa SDL_SetProperty
*/
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 17:59:51 -06:00
extern DECLSPEC SDL_PropertiesID SDLCALL SDL_GetWindowProperties(SDL_Window *window);
include: Attempt to make new properties documentation wiki bridge friendly.
2024-01-08 10:13:18 -07:00
#define SDL_PROPERTY_WINDOW_ANDROID_WINDOW_POINTER "SDL.window.android.window"
#define SDL_PROPERTY_WINDOW_ANDROID_SURFACE_POINTER "SDL.window.android.surface"
#define SDL_PROPERTY_WINDOW_UIKIT_WINDOW_POINTER "SDL.window.uikit.window"
#define SDL_PROPERTY_WINDOW_UIKIT_METAL_VIEW_TAG_NUMBER "SDL.window.uikit.metal_view_tag"
#define SDL_PROPERTY_WINDOW_KMSDRM_DEVICE_INDEX_NUMBER "SDL.window.kmsdrm.dev_index"
#define SDL_PROPERTY_WINDOW_KMSDRM_DRM_FD_NUMBER "SDL.window.kmsdrm.drm_fd"
#define SDL_PROPERTY_WINDOW_KMSDRM_GBM_DEVICE_POINTER "SDL.window.kmsdrm.gbm_dev"
#define SDL_PROPERTY_WINDOW_COCOA_WINDOW_POINTER "SDL.window.cocoa.window"
#define SDL_PROPERTY_WINDOW_COCOA_METAL_VIEW_TAG_NUMBER "SDL.window.cocoa.metal_view_tag"
#define SDL_PROPERTY_WINDOW_VIVANTE_DISPLAY_POINTER "SDL.window.vivante.display"
#define SDL_PROPERTY_WINDOW_VIVANTE_WINDOW_POINTER "SDL.window.vivante.window"
#define SDL_PROPERTY_WINDOW_VIVANTE_SURFACE_POINTER "SDL.window.vivante.surface"
#define SDL_PROPERTY_WINDOW_WINRT_WINDOW_POINTER "SDL.window.winrt.window"
#define SDL_PROPERTY_WINDOW_WIN32_HWND_POINTER "SDL.window.win32.hwnd"
#define SDL_PROPERTY_WINDOW_WIN32_HDC_POINTER "SDL.window.win32.hdc"
#define SDL_PROPERTY_WINDOW_WIN32_INSTANCE_POINTER "SDL.window.win32.instance"
#define SDL_PROPERTY_WINDOW_WAYLAND_DISPLAY_POINTER "SDL.window.wayland.display"
#define SDL_PROPERTY_WINDOW_WAYLAND_SURFACE_POINTER "SDL.window.wayland.surface"
#define SDL_PROPERTY_WINDOW_WAYLAND_EGL_WINDOW_POINTER "SDL.window.wayland.egl_window"
#define SDL_PROPERTY_WINDOW_WAYLAND_XDG_SURFACE_POINTER "SDL.window.wayland.xdg_surface"
#define SDL_PROPERTY_WINDOW_WAYLAND_XDG_TOPLEVEL_POINTER "SDL.window.wayland.xdg_toplevel"
#define SDL_PROPERTY_WINDOW_WAYLAND_XDG_POPUP_POINTER "SDL.window.wayland.xdg_popup"
#define SDL_PROPERTY_WINDOW_WAYLAND_XDG_POSITIONER_POINTER "SDL.window.wayland.xdg_positioner"
#define SDL_PROPERTY_WINDOW_X11_DISPLAY_POINTER "SDL.window.x11.display"
#define SDL_PROPERTY_WINDOW_X11_SCREEN_NUMBER "SDL.window.x11.screen"
#define SDL_PROPERTY_WINDOW_X11_WINDOW_NUMBER "SDL.window.x11.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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \sa SDL_CreateWindow
* \sa SDL_HideWindow
* \sa SDL_MaximizeWindow
* \sa SDL_MinimizeWindow
* \sa SDL_SetWindowFullscreen
* \sa SDL_SetWindowGrab
* \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 09:33:46 -06: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 02:23:17 -07:00
extern DECLSPEC Uint32 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:53:52 -07: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 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
[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 09:53:52 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06: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 02:23:17 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:53:52 -07:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07: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 09:33:46 -06:00
*/
[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 09:53:52 -07:00
extern 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 09:33:46 -06: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 13:09:55 -06:00
* Request that the window's position be set.
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06:00
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06:00
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06:00
*
* When the window position changes, an SDL_EVENT_WINDOW_MOVED event will be
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \param window the window to reposition
Sync wiki -> headers.
2023-01-25 10:58:29 -07: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 12:24:12 -07: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 13:09:55 -06: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 09:33:46 -06:00
*/
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 12:24:12 -07:00
extern 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 09:33:46 -06: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 17:29:52 -06: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 09:33:46 -06:00
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 02:23:17 -07: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 12:24:12 -07: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 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
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 12:24:12 -07:00
extern 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 09:33:46 -06: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 13:09:55 -06: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 09:33:46 -06:00
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06:00
* exits this state and becomes resizable again.
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06:00
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06: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 11:27:25 -07: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 02:23:17 -07: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 09:53:52 -07: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.
2015-12-31 18:16:43 -07:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-01-31 22:23:14 -07: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 13:09:55 -06: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 09:33:46 -06:00
*/
[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 09:53:52 -07:00
extern 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 09:33:46 -06: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 17:29:52 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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.
2015-12-31 18:16:43 -07:00
*
Sync SDL3 wiki -> header
2023-05-17 13:59:14 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 02:23:17 -07: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 12:24:12 -07: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 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06: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 13:25:46 -07: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 02:23:17 -07:00
* \sa SDL_GetWindowSizeInPixels
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
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 12:24:12 -07:00
extern 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 09:33:46 -06: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 00:29:06 -07: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 17:29:52 -06: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 00:29:06 -07:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 00:29:06 -07:00
*
include: Document timing issue with SDL_GetWindowBordersSize
2021-05-04 09:23:54 -06: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 12:18:39 -06: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 00:29:06 -07:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 00:29:06 -07: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 02:23:17 -07:00
extern 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 00:29:06 -07:00
Adding SDL_GetWindowSizeInPixels for window size in pixels (#6112)
2022-08-24 12:25:13 -06: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 02:23:17 -07:00
* Get the size of a window's client area, in pixels.
Adding SDL_GetWindowSizeInPixels for window size in pixels (#6112)
2022-08-24 12:25:13 -06: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 12:24:12 -07: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 12:25:13 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Adding SDL_GetWindowSizeInPixels for window size in pixels (#6112)
2022-08-24 12:25:13 -06:00
*
* \sa SDL_CreateWindow
* \sa SDL_GetWindowSize
*/
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 12:24:12 -07:00
extern DECLSPEC int SDLCALL SDL_GetWindowSizeInPixels(SDL_Window *window, int *w, int *h);
Adding SDL_GetWindowSizeInPixels for window size in pixels (#6112)
2022-08-24 12:25:13 -06: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 09:33:46 -06: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 17:29:52 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \param window the window to change
Allow passing 0 to SDL_SetWindowMinimumSize() and SDL_SetWindowMaximumSize() to indicate no limit
2023-03-15 17:13:56 -06: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 09:53:52 -07: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
[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 09:53:52 -07:00
extern 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 09:33:46 -06: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 17:29:52 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 12:24:12 -07: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
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 12:24:12 -07:00
extern 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 09:33:46 -06: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 17:29:52 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \param window the window to change
Allow passing 0 to SDL_SetWindowMinimumSize() and SDL_SetWindowMaximumSize() to indicate no limit
2023-03-15 17:13:56 -06: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 09:53:52 -07: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
[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 09:53:52 -07:00
extern 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 09:33:46 -06: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 17:29:52 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 12:24:12 -07: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
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 12:24:12 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 12:24:12 -07: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
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 12:24:12 -07:00
extern 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 09:33:46 -06:00
Added SDL_SetWindowResizable(). (thanks, Ethan!)
2016-09-29 20:52:41 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* Set the user-resizable state of a window.
Added SDL_SetWindowResizable(). (thanks, Ethan!)
2016-09-29 20:52:41 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-29 20:52:41 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* You can't change the resizable state of a fullscreen window.
Added SDL_SetWindowResizable(). (thanks, Ethan!)
2016-09-29 20:52:41 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 12:24:12 -07: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-29 20:52:41 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
*
* \sa SDL_GetWindowFlags
Added SDL_SetWindowResizable(). (thanks, Ethan!)
2016-09-29 20:52:41 -06:00
*/
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 12:24:12 -07:00
extern DECLSPEC int SDLCALL SDL_SetWindowResizable(SDL_Window *window, SDL_bool resizable);
Added SDL_SetWindowResizable(). (thanks, Ethan!)
2016-09-29 20:52:41 -06:00
Add SDL_SetWindowAlwaysOnTop()
2021-04-19 05:13:38 -06:00
/**
Update description of SDL_SetWindowAlwaysOnTop
2021-09-17 13:24:10 -06:00
* Set the window to always be above the others.
Add SDL_SetWindowAlwaysOnTop()
2021-04-19 05:13:38 -06:00
*
Sync wiki -> header
2021-09-18 08:19:04 -06: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 05:13:38 -06:00
*
Update description of SDL_SetWindowAlwaysOnTop
2021-09-17 13:24:10 -06:00
* \param window The window of which to change the always on top state
Sync wiki -> header
2021-09-18 08:19:04 -06: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 12:24:12 -07:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Add SDL_SetWindowAlwaysOnTop()
2021-04-19 05:13:38 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Update description of SDL_SetWindowAlwaysOnTop
2021-09-17 13:24:10 -06:00
*
* \sa SDL_GetWindowFlags
Add SDL_SetWindowAlwaysOnTop()
2021-04-19 05:13:38 -06:00
*/
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 12:24:12 -07:00
extern 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-08 18:22:48 -06: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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 12:24:12 -07: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 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
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 12:24:12 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 12:24:12 -07: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 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
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 12:24:12 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 12:24:12 -07:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07: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 09:33:46 -06:00
*/
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 12:24:12 -07:00
extern 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 09:33:46 -06: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 13:09:55 -06: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 11:27:25 -07: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 13:09:55 -06:00
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06:00
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 12:24:12 -07: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 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 13:09:55 -06: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 09:33:46 -06:00
*/
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 12:24:12 -07:00
extern 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 09:33:46 -06: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 13:09:55 -06:00
* Request that the window be minimized to an iconic representation.
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06:00
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 12:24:12 -07: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 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 13:09:55 -06: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 09:33:46 -06:00
*/
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 12:24:12 -07:00
extern 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 09:33:46 -06:00
/**
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06:00
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06:00
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 12:24:12 -07: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 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
Sync wiki -> header.
2021-07-14 15:07:04 -06: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 13:09:55 -06: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 09:33:46 -06:00
*/
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 12:24:12 -07:00
extern 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 09:33:46 -06: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 13:09:55 -06: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 09:33:46 -06:00
*
Sync wiki -> headers.
2023-02-24 09:49:41 -07:00
* By default a window in fullscreen state uses fullscreen desktop mode, but a
* specific 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 09:33:46 -06:00
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06:00
*
* When the window state changes, an SDL_EVENT_WINDOW_ENTER_FULLSCREEN or
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-01-31 22:23:14 -07: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 12:18:39 -06: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-01-31 22:23:14 -07: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 13:09:55 -06: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 09:33:46 -06: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-01-31 22:23:14 -07:00
extern 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 09:33:46 -06: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 13:09:55 -06:00
/**
* Block until any pending window state is finalized.
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06:00
*
* On windowing systems where changes are immediate, this does nothing.
*
Sync SDL3 wiki -> header
2023-12-07 11:27:25 -07: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 13:09:55 -06: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
*/
extern DECLSPEC int SDLCALL SDL_SyncWindow(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 09:39:20 -06:00
/**
* Return whether the window has a surface associated with it.
*
Fix comments
2023-06-22 07:42:51 -06:00
* \param window the window to query
Sync SDL3 wiki -> header
2023-06-10 09:42:15 -06: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 09:39:20 -06:00
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_GetWindowSurface
*/
extern DECLSPEC SDL_bool SDLCALL SDL_HasWindowSurface(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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06: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 09:39:20 -06:00
* \sa SDL_DestroyWindowSurface
* \sa SDL_HasWindowSurface
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06: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 02:23:17 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06: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 02:23:17 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-11 19:45:01 -07:00
* surface to copy, in pixels
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06: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 02:23:17 -07:00
extern 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 09:33:46 -06: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 09:39:20 -06: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
* \sa SDL_HasWindowSurface
*/
extern DECLSPEC int SDLCALL SDL_DestroyWindowSurface(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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* Set a window's input grab 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 09:33:46 -06:00
*
Improve documentation for input grabbing functions
2021-11-25 06:49:57 -07:00
* When input is grabbed, the mouse is confined to the window. This function
* will also grab the keyboard if `SDL_HINT_GRAB_KEYBOARD` is set. To grab the
* keyboard without also grabbing the mouse, use 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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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.
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \param window the window for which the input grab mode should be set
* \param grabbed SDL_TRUE to grab input or SDL_FALSE to release input
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 12:24:12 -07: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-26 18:16:17 -07:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \sa SDL_GetGrabbedWindow
* \sa SDL_GetWindowGrab
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 09:33:46 -06:00
*/
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 12:24:12 -07:00
extern DECLSPEC int SDLCALL SDL_SetWindowGrab(SDL_Window *window, SDL_bool grabbed);
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 09:33:46 -06: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-26 18:16:17 -07:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-26 18:16:17 -07:00
*
Improve documentation for input grabbing functions
2021-11-25 06:49:57 -07: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 06:53:04 -07: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 06:49:57 -07:00
*
Sync wiki -> header.
2021-07-14 15:07:04 -06: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-26 18:16:17 -07:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 12:24:12 -07: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-26 18:16:17 -07:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-09-17 13:12:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \sa SDL_GetWindowKeyboardGrab
* \sa SDL_SetWindowMouseGrab
* \sa SDL_SetWindowGrab
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-26 18:16:17 -07:00
*/
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 12:24:12 -07:00
extern 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-26 18:16:17 -07:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-26 18:16:17 -07:00
*
Improve documentation for input grabbing functions
2021-11-25 06:49:57 -07:00
* Mouse grab confines the mouse cursor to the window.
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \param window The window for which the mouse grab mode should be set.
Sync wiki -> header
2022-03-27 11:11:05 -06: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 12:24:12 -07: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-26 18:16:17 -07:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \sa SDL_GetWindowMouseGrab
* \sa SDL_SetWindowKeyboardGrab
* \sa SDL_SetWindowGrab
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-26 18:16:17 -07:00
*/
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 12:24:12 -07:00
extern 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-26 18:16:17 -07: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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* Get a window's input grab 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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \param window the window to query
* \returns SDL_TRUE if input is grabbed, SDL_FALSE 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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \sa SDL_SetWindowGrab
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 09:33:46 -06: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 02:23:17 -07:00
extern DECLSPEC SDL_bool SDLCALL SDL_GetWindowGrab(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 09:33:46 -06: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-26 18:16:17 -07:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-26 18:16:17 -07:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-26 18:16:17 -07:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \sa SDL_SetWindowKeyboardGrab
* \sa SDL_GetWindowGrab
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-26 18:16:17 -07: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 02:23:17 -07:00
extern 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-26 18:16:17 -07:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-26 18:16:17 -07:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \param window the window to query
doxygen: Fix all the "\returns" so they work as part of complete sentences.
2021-07-14 12:15:30 -06: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-26 18:16:17 -07:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \sa SDL_SetWindowKeyboardGrab
* \sa SDL_GetWindowGrab
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-26 18:16:17 -07: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 02:23:17 -07:00
extern 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-26 18:16:17 -07: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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
*
* \sa SDL_GetWindowGrab
* \sa SDL_SetWindowGrab
Fixed crash if initialization of EGL failed but was tried again later. The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
2015-06-21 09:33:46 -06: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 02:23:17 -07:00
extern 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 09:33:46 -06: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-08 22:34:48 -07: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 13:21:01 -07: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-08 22:34:48 -07: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-11-10 14:05:03 -07: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-08 22:34:48 -07:00
* \sa SDL_GetWindowMouseRect
Improve documentation for input grabbing functions
2021-11-25 06:49:57 -07: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-08 22:34:48 -07: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 02:23:17 -07:00
extern 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-08 22:34:48 -07:00
/**
* Get the mouse confinement rectangle of a window.
*
* \param window The window to query
Sync wiki -> header
2021-11-10 13:21:01 -07: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-08 22:34:48 -07:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-11-10 14:05:03 -07: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-08 22:34:48 -07:00
* \sa SDL_SetWindowMouseRect
*/
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 02:23:17 -07:00
extern 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-08 22:34:48 -07: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 00:46:10 -07:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 00:46:10 -07:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-27 20:15:57 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 00:46:10 -07:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 00:46:10 -07: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 02:23:17 -07:00
extern 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 00:46:10 -07:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 00:46:10 -07:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 00:46:10 -07:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 00:46:10 -07:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \param window the window to get the current opacity value from
Fixed header documentation errors
2021-03-26 15:34:58 -06: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 12:18:39 -06: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 00:46:10 -07:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 00:46:10 -07: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 02:23:17 -07:00
extern 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 00:46:10 -07: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 07:45:58 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* Set the window as a modal for another 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 07:45:58 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-27 20:15:57 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07: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 07:45:58 -06: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 02:23:17 -07:00
extern 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 07:45:58 -06: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 00:28:56 -07:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 00:28:56 -07:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 00:28:56 -07:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-27 20:15:57 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 00:28:56 -07: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 02:23:17 -07:00
extern 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 00:28:56 -07: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-30 21:29:51 -06:00
/**
* Set whether the window may have input focus.
*
* \param window the window to set focusable state
Sync SDL3 wiki -> header
2023-08-30 21:26:13 -06: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-30 21:29:51 -06: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.
*/
extern DECLSPEC int SDLCALL SDL_SetWindowFocusable(SDL_Window *window, SDL_bool focusable);
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 09:24:24 -06: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 11:40:16 -06: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 09:24:24 -06:00
*
* \param window the window for which the menu will be displayed
Sync SDL3 wiki -> header
2023-08-04 11:40:16 -06: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 09:24:24 -06: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.
*/
extern DECLSPEC int SDLCALL SDL_ShowWindowSystemMenu(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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
typedef enum
{
SDL_HITTEST_NORMAL, /**< Region is normal. No special properties. */
SDL_HITTEST_DRAGGABLE, /**< Region can drag entire window. */
SDL_HITTEST_RESIZE_TOPLEFT,
SDL_HITTEST_RESIZE_TOP,
SDL_HITTEST_RESIZE_TOPRIGHT,
SDL_HITTEST_RESIZE_RIGHT,
SDL_HITTEST_RESIZE_BOTTOMRIGHT,
SDL_HITTEST_RESIZE_BOTTOM,
SDL_HITTEST_RESIZE_BOTTOMLEFT,
SDL_HITTEST_RESIZE_LEFT
} SDL_HitTestResult;
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 14:26:35 -07: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06: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 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 02:09:42 -07: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 12:18:39 -06:00
* SDL_GetError() for more information.
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07: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 09:33:46 -06: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 02:23:17 -07:00
extern 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 09:33:46 -06:00
Implement bare minimum for SDL_FlashWindow
2021-06-04 11:55:30 -06: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 06:01:55 -06:00
* Request a window to demand attention from the user.
Implement bare minimum for SDL_FlashWindow
2021-06-04 11:55:30 -06: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 13:11:27 -06:00
* \param window the window to be flashed
Fixed the parameter documentation
2021-07-27 15:23:40 -06:00
* \param operation the flash operation
Implement bare minimum for SDL_FlashWindow
2021-06-04 11:55:30 -06:00
* \returns 0 on success or a negative error code on failure; call
* SDL_GetError() for more information.
Sync wiki -> header
2021-09-17 13:10:07 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Implement bare minimum for SDL_FlashWindow
2021-06-04 11:55:30 -06: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 02:23:17 -07:00
extern DECLSPEC int SDLCALL SDL_FlashWindow(SDL_Window *window, SDL_FlashOperation operation);
Implement bare minimum for SDL_FlashWindow
2021-06-04 11:55:30 -06: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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* Destroy a window.
*
* 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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06: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 12:29:30 -07:00
* \sa SDL_CreatePopupWindow
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 12:29:30 -07: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 09:33:46 -06:00
*/
Remove returns int from Destroy/Close/Unlock functions
2023-02-09 08:53:47 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* Check whether the screensaver is currently enabled.
*
* The screensaver is disabled by default since SDL 2.0.2. Before SDL 2.0.2
* the screensaver was enabled 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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
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-28 20:34:01 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
SDL_*SceenSaver(): change return value to int. // add SDL_Unsupported() errors
2023-02-09 07:34:43 -07: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-28 20:34:01 -07: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 09:33:46 -06:00
*/
SDL_*SceenSaver(): change return value to int. // add SDL_Unsupported() errors
2023-02-09 07:34:43 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 SDL wiki -> header
2022-10-09 09:44:07 -06:00
* The screensaver is disabled by default since SDL 2.0.2. Before SDL 2.0.2
* the screensaver was enabled by default.
*
SDL_*SceenSaver(): change return value to int. // add SDL_Unsupported() errors
2023-02-09 07:34:43 -07: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 15:40:14 -07: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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-28 20:34:01 -07: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 09:33:46 -06:00
*/
SDL_*SceenSaver(): change return value to int. // add SDL_Unsupported() errors
2023-02-09 07:34:43 -07:00
extern 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 09:33:46 -06:00
/**
* \name OpenGL support functions
*/
/* @{ */
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
extern DECLSPEC int SDLCALL SDL_GL_LoadLibrary(const char *path);
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 08:47:03 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* - On Windows, function pointers are specific to the current GL context;
Sync wiki -> header.
2021-07-14 15:07:04 -06: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 12:18:39 -06:00
* - On X11, function pointers returned by this function are valid for any
Sync wiki -> header.
2021-07-14 15:07:04 -06: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 12:18:39 -06:00
* - Some OpenGL drivers, on all platforms, *will* return NULL if a function
Sync wiki -> header.
2021-07-14 15:07:04 -06: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 12:18:39 -06:00
* - Just because you're on Linux/Unix, don't assume you'll be using X11.
Sync wiki -> header.
2021-07-14 15:07:04 -06: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 12:18:39 -06:00
* - OpenGL function pointers must be declared `APIENTRY` as in the example
Sync wiki -> header.
2021-07-14 15:07:04 -06: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 12:18:39 -06: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
Functions which return function pointers now return SDL_FunctionPointer instead of void* This fixes the clang warning "Cast between pointer-to-function and pointer-to-object is an extension" You can define SDL_FUNCTION_POINTER_IS_VOID_POINTER in your project to restore the previous behavior. Fixes https://github.com/libsdl-org/SDL/issues/2866
2023-01-09 15:55:12 -07:00
extern 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 09:33:46 -06: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-25 20:44:35 -06: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 12:03:15 -07: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-25 20:44:35 -06:00
*
Sync SDL3 wiki -> header
2022-11-23 12:59:15 -07: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-25 20:44:35 -06:00
* \sa SDL_GL_GetCurrentEGLDisplay
*/
Functions which return function pointers now return SDL_FunctionPointer instead of void* This fixes the clang warning "Cast between pointer-to-function and pointer-to-object is an extension" You can define SDL_FUNCTION_POINTER_IS_VOID_POINTER in your project to restore the previous behavior. Fixes https://github.com/libsdl-org/SDL/issues/2866
2023-01-09 15:55:12 -07:00
extern 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-25 20:44:35 -06: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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
extern DECLSPEC void SDLCALL SDL_GL_UnloadLibrary(void);
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:40:14 -07: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 09:33:46 -06: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 02:23:17 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* Reset all previously set OpenGL context attributes to their default values.
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
extern DECLSPEC void SDLCALL SDL_GL_ResetAttributes(void);
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* Set an OpenGL window attribute before window creation.
*
Sync wiki -> header.
2021-07-14 15:07:04 -06: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 12:18:39 -06: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 13:57:15 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
extern DECLSPEC int SDLCALL SDL_GL_SetAttribute(SDL_GLattr attr, int value);
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 13:57:15 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
extern DECLSPEC int SDLCALL SDL_GL_GetAttribute(SDL_GLattr attr, int *value);
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06:00
* \param window the window to associate with the context
Sync wiki -> header.
2021-07-14 15:07:04 -06: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 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06: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 02:23:17 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06: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 02:23:17 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:40:14 -07: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 09:33:46 -06: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 02:23:17 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
extern DECLSPEC SDL_GLContext SDLCALL SDL_GL_GetCurrentContext(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-25 20:44:35 -06: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 12:59:15 -07: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-25 20:44:35 -06:00
*/
extern DECLSPEC SDL_EGLDisplay SDLCALL SDL_EGL_GetCurrentEGLDisplay(void);
/**
* 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 12:59:15 -07: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-25 20:44:35 -06:00
*/
extern DECLSPEC SDL_EGLConfig SDLCALL SDL_EGL_GetCurrentEGLConfig(void);
/**
* Get the EGL surface associated with the window.
*
Add missing '\param' documentation
2023-02-12 01:40:39 -07: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-25 20:44:35 -06:00
* \returns the EGLSurface pointer associated with the window, or NULL on
* failure.
Sync SDL3 wiki -> header
2022-11-23 12:59:15 -07: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-25 20:44:35 -06: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 02:23:17 -07:00
extern 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-25 20:44:35 -06: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-25 23:41:06 -06: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 12:59:15 -07: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-25 23:41:06 -06:00
*/
extern DECLSPEC void SDLCALL SDL_EGL_SetEGLAttributeCallbacks(SDL_EGLAttribArrayCallback platformAttribCallback,
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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:07:04 -06: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 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 08:46:06 -06: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 12:18:39 -06: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 02:09:42 -07: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 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
extern DECLSPEC int SDLCALL SDL_GL_SetSwapInterval(int interval);
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:20:41 -07: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 12:18:39 -06:00
*
Sync wiki -> headers.
2023-01-25 10:58:29 -07: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 02:09:42 -07: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 12:18:39 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07: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 09:33:46 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
Handle error return value for SDL_GetSwapInterval
2023-01-01 09:20:41 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 15:07:04 -06: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 12:18:39 -06: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 08:27:42 -07: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 15:40:14 -07: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 09:33:46 -06: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 02:23:17 -07:00
extern 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 09:33:46 -06:00
/**
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 12:24:12 -07: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 09:33:46 -06:00
*
Sync SDL wiki -> header
2022-11-22 15:40:14 -07:00
* \since This function is available since SDL 3.0.0.
Sync wiki -> header
2021-10-26 19:36:05 -06:00
*
First shot at merging the wiki documentation into the headers.
2021-03-21 12:18:39 -06: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 09:33:46 -06:00
*/
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 12:24:12 -07:00
extern 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 09:33:46 -06: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 09:38:59 -07: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 09:33:46 -06:00
Renaming of guard header names to quiet -Wreserved-id-macro Patch contributed by Sylvain
2016-11-20 22:34:54 -07:00
#endif /* SDL_video_h_ */