SDL 2.0
SDL_video.c File Reference
#include "../SDL_internal.h"
#include "SDL.h"
#include "SDL_video.h"
#include "SDL_sysvideo.h"
#include "SDL_blit.h"
#include "SDL_pixels_c.h"
#include "SDL_rect_c.h"
#include "../events/SDL_events_c.h"
#include "../timer/SDL_timer_c.h"
#include "SDL_syswm.h"
#include "SDL_opengles2.h"
#include "x11/SDL_x11messagebox.h"
+ Include dependency graph for SDL_video.c:

Go to the source code of this file.

Data Structures

struct  SDL_WindowTextureData
 

Macros

#define GL_CONTEXT_RELEASE_BEHAVIOR_KHR   0x82FB
 
#define CHECK_WINDOW_MAGIC(window, retval)
 
#define CHECK_DISPLAY_INDEX(displayIndex, retval)
 
#define FULLSCREEN_MASK   (SDL_WINDOW_FULLSCREEN_DESKTOP | SDL_WINDOW_FULLSCREEN)
 
#define SDL_WINDOWTEXTUREDATA   "_SDL_WindowTextureData"
 
#define CREATE_FLAGS    (SDL_WINDOW_OPENGL | SDL_WINDOW_BORDERLESS | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_ALWAYS_ON_TOP | SDL_WINDOW_SKIP_TASKBAR | SDL_WINDOW_POPUP_MENU | SDL_WINDOW_UTILITY | SDL_WINDOW_TOOLTIP | SDL_WINDOW_VULKAN | SDL_WINDOW_MINIMIZED)
 
#define GL_NUM_EXTENSIONS   0x821D
 
#define NOT_A_VULKAN_WINDOW   "The specified window isn't a Vulkan window"
 

Functions

static SDL_bool ShouldUseTextureFramebuffer ()
 
static int SDL_CreateWindowTexture (SDL_VideoDevice *unused, SDL_Window *window, Uint32 *format, void **pixels, int *pitch)
 
static int SDL_UpdateWindowTexture (SDL_VideoDevice *unused, SDL_Window *window, const SDL_Rect *rects, int numrects)
 
static void SDL_DestroyWindowTexture (SDL_VideoDevice *unused, SDL_Window *window)
 
static int cmpmodes (const void *A, const void *B)
 
static int SDL_UninitializedVideo ()
 
int SDL_GetNumVideoDrivers (void)
 Get the number of video drivers compiled into SDL. More...
 
const char * SDL_GetVideoDriver (int index)
 Get the name of a built in video driver. More...
 
int SDL_VideoInit (const char *driver_name)
 Initialize the video subsystem, optionally specifying a video driver. More...
 
const char * SDL_GetCurrentVideoDriver ()
 Returns the name of the currently initialized video driver. More...
 
SDL_VideoDeviceSDL_GetVideoDevice (void)
 
int SDL_AddBasicVideoDisplay (const SDL_DisplayMode *desktop_mode)
 
int SDL_AddVideoDisplay (const SDL_VideoDisplay *display)
 
int SDL_GetNumVideoDisplays (void)
 Returns the number of available video displays. More...
 
int SDL_GetIndexOfDisplay (SDL_VideoDisplay *display)
 
voidSDL_GetDisplayDriverData (int displayIndex)
 
const char * SDL_GetDisplayName (int displayIndex)
 Get the name of a display in UTF-8 encoding. More...
 
int SDL_GetDisplayBounds (int displayIndex, SDL_Rect *rect)
 Get the desktop area represented by a display, with the primary display located at 0,0. More...
 
int SDL_GetDisplayUsableBounds (int displayIndex, SDL_Rect *rect)
 Get the usable desktop area represented by a display, with the primary display located at 0,0. More...
 
int SDL_GetDisplayDPI (int displayIndex, float *ddpi, float *hdpi, float *vdpi)
 Get the dots/pixels-per-inch for a display. More...
 
SDL_DisplayOrientation SDL_GetDisplayOrientation (int displayIndex)
 Get the orientation of a display. More...
 
SDL_bool SDL_AddDisplayMode (SDL_VideoDisplay *display, const SDL_DisplayMode *mode)
 
static int SDL_GetNumDisplayModesForDisplay (SDL_VideoDisplay *display)
 
int SDL_GetNumDisplayModes (int displayIndex)
 Returns the number of available display modes. More...
 
int SDL_GetDisplayMode (int displayIndex, int index, SDL_DisplayMode *mode)
 Fill in information about a specific display mode. More...
 
int SDL_GetDesktopDisplayMode (int displayIndex, SDL_DisplayMode *mode)
 Fill in information about the desktop display mode. More...
 
int SDL_GetCurrentDisplayMode (int displayIndex, SDL_DisplayMode *mode)
 Fill in information about the current display mode. More...
 
static SDL_DisplayModeSDL_GetClosestDisplayModeForDisplay (SDL_VideoDisplay *display, const SDL_DisplayMode *mode, SDL_DisplayMode *closest)
 
SDL_DisplayModeSDL_GetClosestDisplayMode (int displayIndex, const SDL_DisplayMode *mode, SDL_DisplayMode *closest)
 Get the closest match to the requested display mode. More...
 
static int SDL_SetDisplayModeForDisplay (SDL_VideoDisplay *display, const SDL_DisplayMode *mode)
 
SDL_VideoDisplaySDL_GetDisplay (int displayIndex)
 
int SDL_GetWindowDisplayIndex (SDL_Window *window)
 Get the display index associated with a window. More...
 
SDL_VideoDisplaySDL_GetDisplayForWindow (SDL_Window *window)
 
int SDL_SetWindowDisplayMode (SDL_Window *window, const SDL_DisplayMode *mode)
 Set the display mode used when a fullscreen window is visible. More...
 
int SDL_GetWindowDisplayMode (SDL_Window *window, SDL_DisplayMode *mode)
 Fill in information about the display mode used when a fullscreen window is visible. More...
 
Uint32 SDL_GetWindowPixelFormat (SDL_Window *window)
 Get the pixel format associated with the window. More...
 
static void SDL_RestoreMousePosition (SDL_Window *window)
 
static int SDL_UpdateFullscreenMode (SDL_Window *window, SDL_bool fullscreen)
 
static SDL_INLINE SDL_bool IsAcceptingDragAndDrop (void)
 
static SDL_INLINE void PrepareDragAndDropSupport (SDL_Window *window)
 
void SDL_ToggleDragAndDropSupport (void)
 
static void SDL_FinishWindowCreation (SDL_Window *window, Uint32 flags)
 
SDL_WindowSDL_CreateWindow (const char *title, int x, int y, int w, int h, Uint32 flags)
 Create a window with the specified position, dimensions, and flags. More...
 
SDL_WindowSDL_CreateWindowFrom (const void *data)
 Create an SDL window from an existing native window. More...
 
int SDL_RecreateWindow (SDL_Window *window, Uint32 flags)
 
SDL_bool SDL_HasWindows (void)
 
Uint32 SDL_GetWindowID (SDL_Window *window)
 Get the numeric ID of a window, for logging purposes. More...
 
SDL_WindowSDL_GetWindowFromID (Uint32 id)
 Get a window from a stored ID, or NULL if it doesn't exist. More...
 
Uint32 SDL_GetWindowFlags (SDL_Window *window)
 Get the window flags. More...
 
void SDL_SetWindowTitle (SDL_Window *window, const char *title)
 Set the title of a window, in UTF-8 format. More...
 
const char * SDL_GetWindowTitle (SDL_Window *window)
 Get the title of a window, in UTF-8 format. More...
 
void SDL_SetWindowIcon (SDL_Window *window, SDL_Surface *icon)
 Set the icon for a window. More...
 
voidSDL_SetWindowData (SDL_Window *window, const char *name, void *userdata)
 Associate an arbitrary named pointer with a window. More...
 
voidSDL_GetWindowData (SDL_Window *window, const char *name)
 Retrieve the data pointer associated with a window. More...
 
void SDL_SetWindowPosition (SDL_Window *window, int x, int y)
 Set the position of a window. More...
 
void SDL_GetWindowPosition (SDL_Window *window, int *x, int *y)
 Get the position of a window. More...
 
void SDL_SetWindowBordered (SDL_Window *window, SDL_bool bordered)
 Set the border state of a window. More...
 
void SDL_SetWindowResizable (SDL_Window *window, SDL_bool resizable)
 Set the user-resizable state of a window. More...
 
void SDL_SetWindowSize (SDL_Window *window, int w, int h)
 Set the size of a window's client area. More...
 
void SDL_GetWindowSize (SDL_Window *window, int *w, int *h)
 Get the size of a window's client area. More...
 
int SDL_GetWindowBordersSize (SDL_Window *window, int *top, int *left, int *bottom, int *right)
 Get the size of a window's borders (decorations) around the client area. More...
 
void SDL_SetWindowMinimumSize (SDL_Window *window, int min_w, int min_h)
 Set the minimum size of a window's client area. More...
 
void SDL_GetWindowMinimumSize (SDL_Window *window, int *min_w, int *min_h)
 Get the minimum size of a window's client area. More...
 
void SDL_SetWindowMaximumSize (SDL_Window *window, int max_w, int max_h)
 Set the maximum size of a window's client area. More...
 
void SDL_GetWindowMaximumSize (SDL_Window *window, int *max_w, int *max_h)
 Get the maximum size of a window's client area. More...
 
void SDL_ShowWindow (SDL_Window *window)
 Show a window. More...
 
void SDL_HideWindow (SDL_Window *window)
 Hide a window. More...
 
void SDL_RaiseWindow (SDL_Window *window)
 Raise a window above other windows and set the input focus. More...
 
void SDL_MaximizeWindow (SDL_Window *window)
 Make a window as large as possible. More...
 
static SDL_bool CanMinimizeWindow (SDL_Window *window)
 
void SDL_MinimizeWindow (SDL_Window *window)
 Minimize a window to an iconic representation. More...
 
void SDL_RestoreWindow (SDL_Window *window)
 Restore the size and position of a minimized or maximized window. More...
 
int SDL_SetWindowFullscreen (SDL_Window *window, Uint32 flags)
 Set a window's fullscreen state. More...
 
static SDL_SurfaceSDL_CreateWindowFramebuffer (SDL_Window *window)
 
SDL_SurfaceSDL_GetWindowSurface (SDL_Window *window)
 Get the SDL surface associated with the window. More...
 
int SDL_UpdateWindowSurface (SDL_Window *window)
 Copy the window surface to the screen. More...
 
int SDL_UpdateWindowSurfaceRects (SDL_Window *window, const SDL_Rect *rects, int numrects)
 Copy a number of rectangles on the window surface to the screen. More...
 
int SDL_SetWindowBrightness (SDL_Window *window, float brightness)
 Set the brightness (gamma correction) for a window. More...
 
float SDL_GetWindowBrightness (SDL_Window *window)
 Get the brightness (gamma correction) for a window. More...
 
int SDL_SetWindowOpacity (SDL_Window *window, float opacity)
 Set the opacity for a window. More...
 
int SDL_GetWindowOpacity (SDL_Window *window, float *out_opacity)
 Get the opacity of a window. More...
 
int SDL_SetWindowModalFor (SDL_Window *modal_window, SDL_Window *parent_window)
 Sets the window as a modal for another window (TODO: reconsider this function and/or its name) More...
 
int SDL_SetWindowInputFocus (SDL_Window *window)
 Explicitly sets input focus to the window. More...
 
int SDL_SetWindowGammaRamp (SDL_Window *window, const Uint16 *red, const Uint16 *green, const Uint16 *blue)
 Set the gamma ramp for a window. More...
 
int SDL_GetWindowGammaRamp (SDL_Window *window, Uint16 *red, Uint16 *green, Uint16 *blue)
 Get the gamma ramp for a window. More...
 
void SDL_UpdateWindowGrab (SDL_Window *window)
 
void SDL_SetWindowGrab (SDL_Window *window, SDL_bool grabbed)
 Set a window's input grab mode. More...
 
SDL_bool SDL_GetWindowGrab (SDL_Window *window)
 Get a window's input grab mode. More...
 
SDL_WindowSDL_GetGrabbedWindow (void)
 Get the window that currently has an input grab enabled. More...
 
void SDL_OnWindowShown (SDL_Window *window)
 
void SDL_OnWindowHidden (SDL_Window *window)
 
void SDL_OnWindowResized (SDL_Window *window)
 
void SDL_OnWindowMinimized (SDL_Window *window)
 
void SDL_OnWindowRestored (SDL_Window *window)
 
void SDL_OnWindowEnter (SDL_Window *window)
 
void SDL_OnWindowLeave (SDL_Window *window)
 
void SDL_OnWindowFocusGained (SDL_Window *window)
 
static SDL_bool ShouldMinimizeOnFocusLoss (SDL_Window *window)
 
void SDL_OnWindowFocusLost (SDL_Window *window)
 
SDL_WindowSDL_GetFocusWindow (void)
 
void SDL_DestroyWindow (SDL_Window *window)
 Destroy a window. More...
 
SDL_bool SDL_IsScreenSaverEnabled ()
 Returns whether the screensaver is currently enabled (default off). More...
 
void SDL_EnableScreenSaver ()
 Allow the screen to be blanked by a screensaver. More...
 
void SDL_DisableScreenSaver ()
 Prevent the screen from being blanked by a screensaver. More...
 
void SDL_VideoQuit (void)
 Shuts down the video subsystem. More...
 
int SDL_GL_LoadLibrary (const char *path)
 Dynamically load an OpenGL library. More...
 
voidSDL_GL_GetProcAddress (const char *proc)
 Get the address of an OpenGL function. More...
 
void SDL_GL_UnloadLibrary (void)
 Unload the OpenGL library previously loaded by SDL_GL_LoadLibrary(). More...
 
static SDL_INLINE SDL_bool isAtLeastGL3 (const char *verstr)
 
SDL_bool SDL_GL_ExtensionSupported (const char *extension)
 Return true if an OpenGL extension is supported for the current context. More...
 
void SDL_GL_DeduceMaxSupportedESProfile (int *major, int *minor)
 
void SDL_GL_ResetAttributes ()
 Reset all previously set OpenGL context attributes to their default values. More...
 
int SDL_GL_SetAttribute (SDL_GLattr attr, int value)
 Set an OpenGL window attribute before window creation. More...
 
int SDL_GL_GetAttribute (SDL_GLattr attr, int *value)
 Get the actual value for an attribute from the current context. More...
 
SDL_GLContext SDL_GL_CreateContext (SDL_Window *window)
 Create an OpenGL context for use with an OpenGL window, and make it current. More...
 
int SDL_GL_MakeCurrent (SDL_Window *window, SDL_GLContext ctx)
 Set up an OpenGL context for rendering into an OpenGL window. More...
 
SDL_WindowSDL_GL_GetCurrentWindow (void)
 Get the currently active OpenGL window. More...
 
SDL_GLContext SDL_GL_GetCurrentContext (void)
 Get the currently active OpenGL context. More...
 
void SDL_GL_GetDrawableSize (SDL_Window *window, int *w, int *h)
 Get the size of a window's underlying drawable in pixels (for use with glViewport). More...
 
int SDL_GL_SetSwapInterval (int interval)
 Set the swap interval for the current OpenGL context. More...
 
int SDL_GL_GetSwapInterval (void)
 Get the swap interval for the current OpenGL context. More...
 
void SDL_GL_SwapWindow (SDL_Window *window)
 Swap the OpenGL buffers for a window, if double-buffering is supported. More...
 
void SDL_GL_DeleteContext (SDL_GLContext context)
 Delete an OpenGL context. More...
 
SDL_bool SDL_GetWindowWMInfo (SDL_Window *window, struct SDL_SysWMinfo *info)
 This function allows access to driver-dependent window information. More...
 
void SDL_StartTextInput (void)
 Start accepting Unicode text input events. This function will show the on-screen keyboard if supported. More...
 
SDL_bool SDL_IsTextInputActive (void)
 Return whether or not Unicode text input events are enabled. More...
 
void SDL_StopTextInput (void)
 Stop receiving any text input events. This function will hide the on-screen keyboard if supported. More...
 
void SDL_SetTextInputRect (SDL_Rect *rect)
 Set the rectangle used to type Unicode text inputs. This is used as a hint for IME and on-screen keyboard placement. More...
 
SDL_bool SDL_HasScreenKeyboardSupport (void)
 Returns whether the platform has some screen keyboard support. More...
 
SDL_bool SDL_IsScreenKeyboardShown (SDL_Window *window)
 Returns whether the screen keyboard is shown for given window. More...
 
static SDL_bool SDL_MessageboxValidForDriver (const SDL_MessageBoxData *messageboxdata, SDL_SYSWM_TYPE drivertype)
 
int SDL_ShowMessageBox (const SDL_MessageBoxData *messageboxdata, int *buttonid)
 Create a modal message box. More...
 
int SDL_ShowSimpleMessageBox (Uint32 flags, const char *title, const char *message, SDL_Window *window)
 Create a simple modal message box. More...
 
SDL_bool SDL_ShouldAllowTopmost (void)
 
int SDL_SetWindowHitTest (SDL_Window *window, SDL_HitTest callback, void *userdata)
 Provide a callback that decides if a window region has special properties. More...
 
float SDL_ComputeDiagonalDPI (int hpix, int vpix, float hinches, float vinches)
 
void SDL_OnApplicationWillTerminate (void)
 
void SDL_OnApplicationDidReceiveMemoryWarning (void)
 
void SDL_OnApplicationWillResignActive (void)
 
void SDL_OnApplicationDidEnterBackground (void)
 
void SDL_OnApplicationWillEnterForeground (void)
 
void SDL_OnApplicationDidBecomeActive (void)
 
int SDL_Vulkan_LoadLibrary (const char *path)
 Dynamically load a Vulkan loader library. More...
 
voidSDL_Vulkan_GetVkGetInstanceProcAddr (void)
 Get the address of the vkGetInstanceProcAddr function. More...
 
void SDL_Vulkan_UnloadLibrary (void)
 Unload the Vulkan loader library previously loaded by SDL_Vulkan_LoadLibrary(). More...
 
SDL_bool SDL_Vulkan_GetInstanceExtensions (SDL_Window *window, unsigned *count, const char **names)
 
SDL_bool SDL_Vulkan_CreateSurface (SDL_Window *window, VkInstance instance, VkSurfaceKHR *surface)
 Create a Vulkan rendering surface for a window. More...
 
void SDL_Vulkan_GetDrawableSize (SDL_Window *window, int *w, int *h)
 Get the size of a window's underlying drawable in pixels (for use with setting viewport, scissor & etc). More...
 

Variables

static VideoBootStrapbootstrap []
 
static SDL_VideoDevice_this = NULL
 

Macro Definition Documentation

◆ CHECK_DISPLAY_INDEX

#define CHECK_DISPLAY_INDEX (   displayIndex,
  retval 
)
Value:
if (!_this) { \
SDL_UninitializedVideo(); \
return retval; \
} \
SDL_assert(_this->displays != NULL); \
SDL_assert(displayIndex >= 0 && displayIndex < _this->num_displays); \
if (displayIndex < 0 || displayIndex >= _this->num_displays) { \
SDL_SetError("displayIndex must be in the range 0 - %d", \
return retval; \
}
static SDL_VideoDevice * _this
Definition: SDL_video.c:118
#define NULL
Definition: begin_code.h:167
SDL_VideoDisplay * displays
Definition: SDL_sysvideo.h:316
SDL_bool retval

Definition at line 131 of file SDL_video.c.

◆ CHECK_WINDOW_MAGIC

#define CHECK_WINDOW_MAGIC (   window,
  retval 
)
Value:
if (!_this) { \
SDL_UninitializedVideo(); \
return retval; \
} \
SDL_assert(window && window->magic == &_this->window_magic); \
if (!window || window->magic != &_this->window_magic) { \
SDL_SetError("Invalid window"); \
return retval; \
}
EGLSurface EGLNativeWindowType * window
Definition: eglext.h:1025

Definition at line 120 of file SDL_video.c.

◆ CREATE_FLAGS

◆ FULLSCREEN_MASK

#define FULLSCREEN_MASK   (SDL_WINDOW_FULLSCREEN_DESKTOP | SDL_WINDOW_FULLSCREEN)

Definition at line 144 of file SDL_video.c.

◆ GL_CONTEXT_RELEASE_BEHAVIOR_KHR

#define GL_CONTEXT_RELEASE_BEHAVIOR_KHR   0x82FB

Definition at line 51 of file SDL_video.c.

◆ GL_NUM_EXTENSIONS

#define GL_NUM_EXTENSIONS   0x821D

◆ NOT_A_VULKAN_WINDOW

#define NOT_A_VULKAN_WINDOW   "The specified window isn't a Vulkan window"

Definition at line 4074 of file SDL_video.c.

◆ SDL_WINDOWTEXTUREDATA

#define SDL_WINDOWTEXTUREDATA   "_SDL_WindowTextureData"

Definition at line 155 of file SDL_video.c.

Function Documentation

◆ CanMinimizeWindow()

static SDL_bool CanMinimizeWindow ( SDL_Window window)
static

Definition at line 2216 of file SDL_video.c.

2217{
2218 if (!_this->MinimizeWindow) {
2219 return SDL_FALSE;
2220 }
2221 return SDL_TRUE;
2222}
@ SDL_TRUE
Definition: SDL_stdinc.h:164
@ SDL_FALSE
Definition: SDL_stdinc.h:163
void(* MinimizeWindow)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:227

References _this, SDL_VideoDevice::MinimizeWindow, SDL_FALSE, and SDL_TRUE.

Referenced by SDL_MinimizeWindow().

◆ cmpmodes()

static int cmpmodes ( const void A,
const void B 
)
static

Definition at line 416 of file SDL_video.c.

417{
418 const SDL_DisplayMode *a = (const SDL_DisplayMode *) A;
419 const SDL_DisplayMode *b = (const SDL_DisplayMode *) B;
420 if (a == b) {
421 return 0;
422 } else if (a->w != b->w) {
423 return b->w - a->w;
424 } else if (a->h != b->h) {
425 return b->h - a->h;
426 } else if (SDL_BITSPERPIXEL(a->format) != SDL_BITSPERPIXEL(b->format)) {
427 return SDL_BITSPERPIXEL(b->format) - SDL_BITSPERPIXEL(a->format);
428 } else if (SDL_PIXELLAYOUT(a->format) != SDL_PIXELLAYOUT(b->format)) {
429 return SDL_PIXELLAYOUT(b->format) - SDL_PIXELLAYOUT(a->format);
430 } else if (a->refresh_rate != b->refresh_rate) {
431 return b->refresh_rate - a->refresh_rate;
432 }
433 return 0;
434}
GLboolean GLboolean GLboolean b
GLboolean GLboolean GLboolean GLboolean a
#define SDL_BITSPERPIXEL(X)
Definition: SDL_pixels.h:127
#define SDL_PIXELLAYOUT(X)
Definition: SDL_pixels.h:126
The structure that defines a display mode.
Definition: SDL_video.h:54

References SDL_BITSPERPIXEL, SDL_PIXELLAYOUT, and SDL_DisplayMode::w.

Referenced by SDL_AddDisplayMode(), and SDL_GetNumDisplayModesForDisplay().

◆ IsAcceptingDragAndDrop()

static SDL_INLINE SDL_bool IsAcceptingDragAndDrop ( void  )
static

Definition at line 1351 of file SDL_video.c.

1352{
1355 return SDL_TRUE;
1356 }
1357 return SDL_FALSE;
1358}
@ SDL_DROPTEXT
Definition: SDL_events.h:142
@ SDL_DROPFILE
Definition: SDL_events.h:141
#define SDL_GetEventState(type)
Definition: SDL_events.h:772
#define SDL_ENABLE
Definition: SDL_events.h:759

References SDL_DROPFILE, SDL_DROPTEXT, SDL_ENABLE, SDL_FALSE, SDL_GetEventState, and SDL_TRUE.

Referenced by PrepareDragAndDropSupport(), and SDL_ToggleDragAndDropSupport().

◆ isAtLeastGL3()

static SDL_INLINE SDL_bool isAtLeastGL3 ( const char *  verstr)
static

Definition at line 2947 of file SDL_video.c.

2948{
2949 return (verstr && (SDL_atoi(verstr) >= 3));
2950}
#define SDL_atoi

References SDL_atoi.

Referenced by SDL_GL_ExtensionSupported(), and SDL_GL_GetAttribute().

◆ PrepareDragAndDropSupport()

static SDL_INLINE void PrepareDragAndDropSupport ( SDL_Window window)
static

Definition at line 1362 of file SDL_video.c.

1363{
1364 if (_this->AcceptDragAndDrop) {
1366 }
1367}
static SDL_INLINE SDL_bool IsAcceptingDragAndDrop(void)
Definition: SDL_video.c:1351
void(* AcceptDragAndDrop)(SDL_Window *window, SDL_bool accept)
Definition: SDL_sysvideo.h:309

References _this, SDL_VideoDevice::AcceptDragAndDrop, and IsAcceptingDragAndDrop().

Referenced by SDL_CreateWindowFrom(), and SDL_FinishWindowCreation().

◆ SDL_AddBasicVideoDisplay()

int SDL_AddBasicVideoDisplay ( const SDL_DisplayMode desktop_mode)

Definition at line 589 of file SDL_video.c.

590{
591 SDL_VideoDisplay display;
592
593 SDL_zero(display);
594 if (desktop_mode) {
595 display.desktop_mode = *desktop_mode;
596 }
597 display.current_mode = display.desktop_mode;
598
599 return SDL_AddVideoDisplay(&display);
600}
#define SDL_zero(x)
Definition: SDL_stdinc.h:416
int SDL_AddVideoDisplay(const SDL_VideoDisplay *display)
Definition: SDL_video.c:603
SDL_DisplayMode desktop_mode
Definition: SDL_sysvideo.h:131
SDL_DisplayMode current_mode
Definition: SDL_sysvideo.h:132

References SDL_VideoDisplay::current_mode, SDL_VideoDisplay::desktop_mode, SDL_AddVideoDisplay(), and SDL_zero.

◆ SDL_AddDisplayMode()

SDL_bool SDL_AddDisplayMode ( SDL_VideoDisplay display,
const SDL_DisplayMode mode 
)

Definition at line 751 of file SDL_video.c.

752{
753 SDL_DisplayMode *modes;
754 int i, nmodes;
755
756 /* Make sure we don't already have the mode in the list */
757 modes = display->display_modes;
758 nmodes = display->num_display_modes;
759 for (i = 0; i < nmodes; ++i) {
760 if (cmpmodes(mode, &modes[i]) == 0) {
761 return SDL_FALSE;
762 }
763 }
764
765 /* Go ahead and add the new mode */
766 if (nmodes == display->max_display_modes) {
767 modes =
768 SDL_realloc(modes,
769 (display->max_display_modes + 32) * sizeof(*modes));
770 if (!modes) {
771 return SDL_FALSE;
772 }
773 display->display_modes = modes;
774 display->max_display_modes += 32;
775 }
776 modes[nmodes] = *mode;
777 display->num_display_modes++;
778
779 /* Re-sort video modes */
780 SDL_qsort(display->display_modes, display->num_display_modes,
781 sizeof(SDL_DisplayMode), cmpmodes);
782
783 return SDL_TRUE;
784}
#define SDL_qsort
#define SDL_realloc
GLenum mode
static int cmpmodes(const void *A, const void *B)
Definition: SDL_video.c:416
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
SDL_DisplayMode * display_modes
Definition: SDL_sysvideo.h:130

References cmpmodes(), SDL_VideoDisplay::display_modes, i, SDL_VideoDisplay::max_display_modes, SDL_VideoDisplay::num_display_modes, SDL_FALSE, SDL_qsort, SDL_realloc, and SDL_TRUE.

◆ SDL_AddVideoDisplay()

int SDL_AddVideoDisplay ( const SDL_VideoDisplay display)

Definition at line 603 of file SDL_video.c.

604{
605 SDL_VideoDisplay *displays;
606 int index = -1;
607
608 displays =
610 (_this->num_displays + 1) * sizeof(*displays));
611 if (displays) {
613 displays[index] = *display;
614 displays[index].device = _this;
615 _this->displays = displays;
616
617 if (display->name) {
618 displays[index].name = SDL_strdup(display->name);
619 } else {
620 char name[32];
621
622 SDL_itoa(index, name, 10);
623 displays[index].name = SDL_strdup(name);
624 }
625 } else {
627 }
628 return index;
629}
#define SDL_strdup
#define SDL_itoa
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
GLuint index
GLuint const GLchar * name
SDL_VideoDevice * device
Definition: SDL_sysvideo.h:137

References _this, SDL_VideoDisplay::device, SDL_VideoDevice::displays, SDL_VideoDisplay::name, SDL_VideoDevice::num_displays, SDL_itoa, SDL_OutOfMemory, SDL_realloc, and SDL_strdup.

Referenced by SDL_AddBasicVideoDisplay(), and videoInit().

◆ SDL_ComputeDiagonalDPI()

float SDL_ComputeDiagonalDPI ( int  hpix,
int  vpix,
float  hinches,
float  vinches 
)

Definition at line 4015 of file SDL_video.c.

4016{
4017 float den2 = hinches * hinches + vinches * vinches;
4018 if (den2 <= 0.0f) {
4019 return 0.0f;
4020 }
4021
4022 return (float)(SDL_sqrt((double)hpix * (double)hpix + (double)vpix * (double)vpix) /
4023 SDL_sqrt((double)den2));
4024}
#define SDL_sqrt

References SDL_sqrt.

◆ SDL_CreateWindow()

SDL_Window * SDL_CreateWindow ( const char *  title,
int  x,
int  y,
int  w,
int  h,
Uint32  flags 
)

Create a window with the specified position, dimensions, and flags.

Parameters
titleThe title of the window, in UTF-8 encoding.
xThe x position of the window, SDL_WINDOWPOS_CENTERED, or SDL_WINDOWPOS_UNDEFINED.
yThe y position of the window, SDL_WINDOWPOS_CENTERED, or SDL_WINDOWPOS_UNDEFINED.
wThe width of the window, in screen coordinates.
hThe height of the window, in screen coordinates.
flagsThe flags for the window, a mask of any of the following: SDL_WINDOW_FULLSCREEN, SDL_WINDOW_OPENGL, SDL_WINDOW_HIDDEN, SDL_WINDOW_BORDERLESS, SDL_WINDOW_RESIZABLE, SDL_WINDOW_MAXIMIZED, SDL_WINDOW_MINIMIZED, SDL_WINDOW_INPUT_GRABBED, SDL_WINDOW_ALLOW_HIGHDPI, SDL_WINDOW_VULKAN.
Returns
The created window, or NULL if window creation failed.

If the window is created with the SDL_WINDOW_ALLOW_HIGHDPI flag, its size in pixels may differ from its size in screen coordinates on platforms with high-DPI support (e.g. iOS and Mac OS X). Use SDL_GetWindowSize() to query the client area's size in screen coordinates, and SDL_GL_GetDrawableSize(), SDL_Vulkan_GetDrawableSize(), or SDL_GetRendererOutputSize() to query the drawable size in pixels.

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.

Note
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.
See also
SDL_DestroyWindow()
SDL_GL_LoadLibrary()
SDL_Vulkan_LoadLibrary()

Definition at line 1405 of file SDL_video.c.

1406{
1408
1409 if (!_this) {
1410 /* Initialize the video system if needed */
1411 if (SDL_VideoInit(NULL) < 0) {
1412 return NULL;
1413 }
1414 }
1415
1416 if ((((flags & SDL_WINDOW_UTILITY) != 0) + ((flags & SDL_WINDOW_TOOLTIP) != 0) + ((flags & SDL_WINDOW_POPUP_MENU) != 0)) > 1) {
1417 SDL_SetError("Conflicting window flags specified");
1418 return NULL;
1419 }
1420
1421 /* Some platforms can't create zero-sized windows */
1422 if (w < 1) {
1423 w = 1;
1424 }
1425 if (h < 1) {
1426 h = 1;
1427 }
1428
1429 /* Some platforms blow up if the windows are too large. Raise it later? */
1430 if ((w > 16384) || (h > 16384)) {
1431 SDL_SetError("Window is too large.");
1432 return NULL;
1433 }
1434
1435 /* Some platforms have OpenGL enabled by default */
1436#if (SDL_VIDEO_OPENGL && __MACOSX__) || __IPHONEOS__ || __ANDROID__ || __NACL__
1437 if (!_this->is_dummy && !(flags & SDL_WINDOW_VULKAN)) {
1439 }
1440#endif
1441 if (flags & SDL_WINDOW_OPENGL) {
1442 if (!_this->GL_CreateContext) {
1443 SDL_SetError("OpenGL support is either not configured in SDL "
1444 "or not available in current SDL video driver "
1445 "(%s) or platform", _this->name);
1446 return NULL;
1447 }
1448 if (SDL_GL_LoadLibrary(NULL) < 0) {
1449 return NULL;
1450 }
1451 }
1452
1453 if (flags & SDL_WINDOW_VULKAN) {
1455 SDL_SetError("Vulkan support is either not configured in SDL "
1456 "or not available in current SDL video driver "
1457 "(%s) or platform", _this->name);
1458 return NULL;
1459 }
1460 if (flags & SDL_WINDOW_OPENGL) {
1461 SDL_SetError("Vulkan and OpenGL not supported on same window");
1462 return NULL;
1463 }
1464 if (SDL_Vulkan_LoadLibrary(NULL) < 0) {
1465 return NULL;
1466 }
1467 }
1468
1469 /* Unless the user has specified the high-DPI disabling hint, respect the
1470 * SDL_WINDOW_ALLOW_HIGHDPI flag.
1471 */
1474 flags &= ~SDL_WINDOW_ALLOW_HIGHDPI;
1475 }
1476 }
1477
1478 window = (SDL_Window *)SDL_calloc(1, sizeof(*window));
1479 if (!window) {
1481 return NULL;
1482 }
1483 window->magic = &_this->window_magic;
1484 window->id = _this->next_object_id++;
1485 window->x = x;
1486 window->y = y;
1487 window->w = w;
1488 window->h = h;
1492 int displayIndex;
1493 SDL_Rect bounds;
1494
1495 displayIndex = SDL_GetIndexOfDisplay(display);
1496 SDL_GetDisplayBounds(displayIndex, &bounds);
1498 window->x = bounds.x + (bounds.w - w) / 2;
1499 }
1501 window->y = bounds.y + (bounds.h - h) / 2;
1502 }
1503 }
1504 window->windowed.x = window->x;
1505 window->windowed.y = window->y;
1506 window->windowed.w = window->w;
1507 window->windowed.h = window->h;
1508
1511 int displayIndex;
1512 SDL_Rect bounds;
1513
1514 displayIndex = SDL_GetIndexOfDisplay(display);
1515 SDL_GetDisplayBounds(displayIndex, &bounds);
1516
1517 window->x = bounds.x;
1518 window->y = bounds.y;
1519 window->w = bounds.w;
1520 window->h = bounds.h;
1521 }
1522
1523 window->flags = ((flags & CREATE_FLAGS) | SDL_WINDOW_HIDDEN);
1524 window->last_fullscreen_flags = window->flags;
1525 window->opacity = 1.0f;
1526 window->brightness = 1.0f;
1527 window->next = _this->windows;
1529
1530 if (_this->windows) {
1532 }
1533 _this->windows = window;
1534
1537 return NULL;
1538 }
1539
1540 /* Clear minimized if not on windows, only windows handles it at create rather than FinishWindowCreation,
1541 * but it's important or window focus will get broken on windows!
1542 */
1543#if !defined(__WIN32__)
1544 if (window->flags & SDL_WINDOW_MINIMIZED) {
1545 window->flags &= ~SDL_WINDOW_MINIMIZED;
1546 }
1547#endif
1548
1549#if __WINRT__ && (NTDDI_VERSION < NTDDI_WIN10)
1550 /* HACK: WinRT 8.x apps can't choose whether or not they are fullscreen
1551 or not. The user can choose this, via OS-provided UI, but this can't
1552 be set programmatically.
1553
1554 Just look at what SDL's WinRT video backend code detected with regards
1555 to fullscreen (being active, or not), and figure out a return/error code
1556 from that.
1557 */
1558 flags = window->flags;
1559#endif
1560
1561 if (title) {
1562 SDL_SetWindowTitle(window, title);
1563 }
1565
1566 /* If the window was created fullscreen, make sure the mode code matches */
1568
1569 return window;
1570}
#define SDL_SetError
#define SDL_GetHintBoolean
#define SDL_calloc
#define SDL_HINT_VIDEO_HIGHDPI_DISABLED
If set to 1, then do not allow high-DPI windows. ("Retina" on Mac and iOS)
Definition: SDL_hints.h:652
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
GLbitfield flags
GLfloat GLfloat GLfloat GLfloat h
GLubyte GLubyte GLubyte GLubyte w
#define FULLSCREEN_VISIBLE(W)
Definition: SDL_sysvideo.h:116
int SDL_VideoInit(const char *driver_name)
Initialize the video subsystem, optionally specifying a video driver.
Definition: SDL_video.c:461
#define CREATE_FLAGS
Definition: SDL_video.c:1347
static int SDL_UpdateFullscreenMode(SDL_Window *window, SDL_bool fullscreen)
Definition: SDL_video.c:1183
void SDL_SetWindowTitle(SDL_Window *window, const char *title)
Set the title of a window, in UTF-8 format.
Definition: SDL_video.c:1749
static void SDL_FinishWindowCreation(SDL_Window *window, Uint32 flags)
Definition: SDL_video.c:1383
int SDL_GetDisplayBounds(int displayIndex, SDL_Rect *rect)
Get the desktop area represented by a display, with the primary display located at 0,...
Definition: SDL_video.c:673
int SDL_Vulkan_LoadLibrary(const char *path)
Dynamically load a Vulkan loader library.
Definition: SDL_video.c:4076
SDL_VideoDisplay * SDL_GetDisplayForWindow(SDL_Window *window)
Definition: SDL_video.c:1089
void SDL_DestroyWindow(SDL_Window *window)
Destroy a window.
Definition: SDL_video.c:2712
int SDL_GL_LoadLibrary(const char *path)
Dynamically load an OpenGL library.
Definition: SDL_video.c:2878
int SDL_GetIndexOfDisplay(SDL_VideoDisplay *display)
Definition: SDL_video.c:642
#define SDL_WINDOWPOS_ISCENTERED(X)
Definition: SDL_video.h:140
#define SDL_WINDOWPOS_ISUNDEFINED(X)
Definition: SDL_video.h:131
@ SDL_WINDOW_ALLOW_HIGHDPI
Definition: SDL_video.h:113
@ SDL_WINDOW_TOOLTIP
Definition: SDL_video.h:120
@ SDL_WINDOW_VULKAN
Definition: SDL_video.h:122
@ SDL_WINDOW_OPENGL
Definition: SDL_video.h:101
@ SDL_WINDOW_MINIMIZED
Definition: SDL_video.h:106
@ SDL_WINDOW_UTILITY
Definition: SDL_video.h:119
@ SDL_WINDOW_FULLSCREEN
Definition: SDL_video.h:100
@ SDL_WINDOW_HIDDEN
Definition: SDL_video.h:103
@ SDL_WINDOW_POPUP_MENU
Definition: SDL_video.h:121
A rectangle, with the origin at the upper left (integer).
Definition: SDL_rect.h:78
int h
Definition: SDL_rect.h:80
int w
Definition: SDL_rect.h:80
int y
Definition: SDL_rect.h:79
int x
Definition: SDL_rect.h:79
const char * name
Definition: SDL_sysvideo.h:152
int(* CreateSDLWindow)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:211
SDL_GLContext(* GL_CreateContext)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:258
SDL_bool is_dummy
Definition: SDL_sysvideo.h:313
SDL_bool(* Vulkan_CreateSurface)(_THIS, SDL_Window *window, VkInstance instance, VkSurfaceKHR *surface)
Definition: SDL_sysvideo.h:274
SDL_Window * windows
Definition: SDL_sysvideo.h:317
Uint32 next_object_id
Definition: SDL_sysvideo.h:320
The type used to identify a window.
Definition: SDL_sysvideo.h:74
SDL_bool is_destroying
Definition: SDL_sysvideo.h:101
SDL_Window * prev
Definition: SDL_sysvideo.h:113

References _this, CREATE_FLAGS, SDL_VideoDevice::CreateSDLWindow, FULLSCREEN_VISIBLE, SDL_VideoDevice::GL_CreateContext, SDL_Rect::h, SDL_Window::is_destroying, SDL_VideoDevice::is_dummy, SDL_VideoDevice::name, SDL_VideoDevice::next_object_id, NULL, SDL_Window::prev, SDL_calloc, SDL_DestroyWindow(), SDL_FALSE, SDL_FinishWindowCreation(), SDL_GetDisplayBounds(), SDL_GetDisplayForWindow(), SDL_GetHintBoolean, SDL_GetIndexOfDisplay(), SDL_GL_LoadLibrary(), SDL_HINT_VIDEO_HIGHDPI_DISABLED, SDL_OutOfMemory, SDL_SetError, SDL_SetWindowTitle(), SDL_UpdateFullscreenMode(), SDL_VideoInit(), SDL_Vulkan_LoadLibrary(), SDL_WINDOW_ALLOW_HIGHDPI, SDL_WINDOW_FULLSCREEN, SDL_WINDOW_HIDDEN, SDL_WINDOW_MINIMIZED, SDL_WINDOW_OPENGL, SDL_WINDOW_POPUP_MENU, SDL_WINDOW_TOOLTIP, SDL_WINDOW_UTILITY, SDL_WINDOW_VULKAN, SDL_WINDOWPOS_ISCENTERED, SDL_WINDOWPOS_ISUNDEFINED, SDL_VideoDevice::Vulkan_CreateSurface, SDL_Rect::w, SDL_VideoDevice::window_magic, SDL_VideoDevice::windows, SDL_Rect::x, and SDL_Rect::y.

Referenced by ShouldUseTextureFramebuffer().

◆ SDL_CreateWindowFramebuffer()

static SDL_Surface * SDL_CreateWindowFramebuffer ( SDL_Window window)
static

Definition at line 2285 of file SDL_video.c.

2286{
2287 Uint32 format;
2288 void *pixels;
2289 int pitch;
2290 int bpp;
2291 Uint32 Rmask, Gmask, Bmask, Amask;
2292
2294 return NULL;
2295 }
2296
2297 if (_this->CreateWindowFramebuffer(_this, window, &format, &pixels, &pitch) < 0) {
2298 return NULL;
2299 }
2300
2301 if (!SDL_PixelFormatEnumToMasks(format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
2302 return NULL;
2303 }
2304
2305 return SDL_CreateRGBSurfaceFrom(pixels, window->w, window->h, bpp, pitch, Rmask, Gmask, Bmask, Amask);
2306}
#define SDL_PixelFormatEnumToMasks
#define SDL_CreateRGBSurfaceFrom
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: SDL_opengl.h:1572
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
uint32_t Uint32
Definition: SDL_stdinc.h:203
int(* CreateWindowFramebuffer)(_THIS, SDL_Window *window, Uint32 *format, void **pixels, int *pitch)
Definition: SDL_sysvideo.h:236
int(* UpdateWindowFramebuffer)(_THIS, SDL_Window *window, const SDL_Rect *rects, int numrects)
Definition: SDL_sysvideo.h:237

References _this, SDL_VideoDevice::CreateWindowFramebuffer, NULL, SDL_CreateRGBSurfaceFrom, SDL_PixelFormatEnumToMasks, and SDL_VideoDevice::UpdateWindowFramebuffer.

Referenced by SDL_GetWindowSurface().

◆ SDL_CreateWindowFrom()

SDL_Window * SDL_CreateWindowFrom ( const void data)

Create an SDL window from an existing native window.

Parameters
dataA pointer to driver-dependent window creation data
Returns
The created window, or NULL if window creation failed.
See also
SDL_DestroyWindow()

Definition at line 1573 of file SDL_video.c.

1574{
1576
1577 if (!_this) {
1579 return NULL;
1580 }
1581 if (!_this->CreateSDLWindowFrom) {
1583 return NULL;
1584 }
1585 window = (SDL_Window *)SDL_calloc(1, sizeof(*window));
1586 if (!window) {
1588 return NULL;
1589 }
1590 window->magic = &_this->window_magic;
1591 window->id = _this->next_object_id++;
1592 window->flags = SDL_WINDOW_FOREIGN;
1593 window->last_fullscreen_flags = window->flags;
1594 window->is_destroying = SDL_FALSE;
1595 window->opacity = 1.0f;
1596 window->brightness = 1.0f;
1597 window->next = _this->windows;
1598 if (_this->windows) {
1600 }
1601 _this->windows = window;
1602
1605 return NULL;
1606 }
1607
1609
1610 return window;
1611}
#define SDL_Unsupported()
Definition: SDL_error.h:53
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: SDL_opengl.h:1974
static SDL_INLINE void PrepareDragAndDropSupport(SDL_Window *window)
Definition: SDL_video.c:1362
static int SDL_UninitializedVideo()
Definition: SDL_video.c:437
@ SDL_WINDOW_FOREIGN
Definition: SDL_video.h:112
int(* CreateSDLWindowFrom)(_THIS, SDL_Window *window, const void *data)
Definition: SDL_sysvideo.h:212

References _this, SDL_VideoDevice::CreateSDLWindowFrom, SDL_VideoDevice::next_object_id, NULL, PrepareDragAndDropSupport(), SDL_Window::prev, SDL_calloc, SDL_DestroyWindow(), SDL_FALSE, SDL_OutOfMemory, SDL_UninitializedVideo(), SDL_Unsupported, SDL_WINDOW_FOREIGN, SDL_VideoDevice::window_magic, and SDL_VideoDevice::windows.

◆ SDL_CreateWindowTexture()

static int SDL_CreateWindowTexture ( SDL_VideoDevice unused,
SDL_Window window,
Uint32 format,
void **  pixels,
int *  pitch 
)
static

Definition at line 256 of file SDL_video.c.

257{
259
261 if (!data) {
263 int i;
265
266 /* Check to see if there's a specific driver requested */
267 if (hint && *hint != '0' && *hint != '1' &&
268 SDL_strcasecmp(hint, "true") != 0 &&
269 SDL_strcasecmp(hint, "false") != 0 &&
270 SDL_strcasecmp(hint, "software") != 0) {
271 for (i = 0; i < SDL_GetNumRenderDrivers(); ++i) {
272 SDL_RendererInfo info;
274 if (SDL_strcasecmp(info.name, hint) == 0) {
276 break;
277 }
278 }
279 }
280
281 if (!renderer) {
282 for (i = 0; i < SDL_GetNumRenderDrivers(); ++i) {
283 SDL_RendererInfo info;
285 if (SDL_strcmp(info.name, "software") != 0) {
287 if (renderer) {
288 break;
289 }
290 }
291 }
292 }
293 if (!renderer) {
294 return SDL_SetError("No hardware accelerated renderers available");
295 }
296
297 /* Create the data after we successfully create the renderer (bug #1116) */
298 data = (SDL_WindowTextureData *)SDL_calloc(1, sizeof(*data));
299 if (!data) {
301 return SDL_OutOfMemory();
302 }
304
305 data->renderer = renderer;
306 }
307
308 /* Free any old texture and pixel data */
309 if (data->texture) {
310 SDL_DestroyTexture(data->texture);
311 data->texture = NULL;
312 }
313 SDL_free(data->pixels);
314 data->pixels = NULL;
315
316 {
317 SDL_RendererInfo info;
318 Uint32 i;
319
320 if (SDL_GetRendererInfo(data->renderer, &info) < 0) {
321 return -1;
322 }
323
324 /* Find the first format without an alpha channel */
325 *format = info.texture_formats[0];
326
327 for (i = 0; i < info.num_texture_formats; ++i) {
330 *format = info.texture_formats[i];
331 break;
332 }
333 }
334 }
335
336 data->texture = SDL_CreateTexture(data->renderer, *format,
338 window->w, window->h);
339 if (!data->texture) {
340 return -1;
341 }
342
343 /* Create framebuffer data */
344 data->bytes_per_pixel = SDL_BYTESPERPIXEL(*format);
345 data->pitch = (((window->w * data->bytes_per_pixel) + 3) & ~3);
346
347 {
348 /* Make static analysis happy about potential malloc(0) calls. */
349 const size_t allocsize = window->h * data->pitch;
350 data->pixels = SDL_malloc((allocsize > 0) ? allocsize : 1);
351 if (!data->pixels) {
352 return SDL_OutOfMemory();
353 }
354 }
355
356 *pixels = data->pixels;
357 *pitch = data->pitch;
358
359 /* Make sure we're not double-scaling the viewport */
360 SDL_RenderSetViewport(data->renderer, NULL);
361
362 return 0;
363}
#define SDL_DestroyRenderer
#define SDL_DestroyTexture
#define SDL_CreateTexture
#define SDL_GetRenderDriverInfo
#define SDL_CreateRenderer
#define SDL_malloc
#define SDL_strcasecmp
#define SDL_free
#define SDL_strcmp
#define SDL_GetNumRenderDrivers
#define SDL_GetRendererInfo
#define SDL_GetHint
#define SDL_RenderSetViewport
#define SDL_HINT_FRAMEBUFFER_ACCELERATION
A variable controlling how 3D acceleration is used to accelerate the SDL screen surface.
Definition: SDL_hints.h:65
#define SDL_BYTESPERPIXEL(X)
Definition: SDL_pixels.h:128
#define SDL_ISPIXELFORMAT_ALPHA(format)
Definition: SDL_pixels.h:154
#define SDL_ISPIXELFORMAT_FOURCC(format)
Definition: SDL_pixels.h:167
@ SDL_TEXTUREACCESS_STREAMING
Definition: SDL_render.h:94
#define SDL_WINDOWTEXTUREDATA
Definition: SDL_video.c:155
void * SDL_GetWindowData(SDL_Window *window, const char *name)
Retrieve the data pointer associated with a window.
Definition: SDL_video.c:1843
void * SDL_SetWindowData(SDL_Window *window, const char *name, void *userdata)
Associate an arbitrary named pointer with a window.
Definition: SDL_video.c:1796
Information on the capabilities of a render driver or context.
Definition: SDL_render.h:79
const char * name
Definition: SDL_render.h:80
Uint32 texture_formats[16]
Definition: SDL_render.h:83
Uint32 num_texture_formats
Definition: SDL_render.h:82
static SDL_Renderer * renderer

References i, SDL_RendererInfo::name, NULL, SDL_RendererInfo::num_texture_formats, renderer, SDL_BYTESPERPIXEL, SDL_calloc, SDL_CreateRenderer, SDL_CreateTexture, SDL_DestroyRenderer, SDL_DestroyTexture, SDL_free, SDL_GetHint, SDL_GetNumRenderDrivers, SDL_GetRenderDriverInfo, SDL_GetRendererInfo, SDL_GetWindowData(), SDL_HINT_FRAMEBUFFER_ACCELERATION, SDL_ISPIXELFORMAT_ALPHA, SDL_ISPIXELFORMAT_FOURCC, SDL_malloc, SDL_OutOfMemory, SDL_RenderSetViewport, SDL_SetError, SDL_SetWindowData(), SDL_strcasecmp, SDL_strcmp, SDL_TEXTUREACCESS_STREAMING, SDL_WINDOWTEXTUREDATA, and SDL_RendererInfo::texture_formats.

Referenced by SDL_VideoInit().

◆ SDL_DestroyWindow()

void SDL_DestroyWindow ( SDL_Window window)

Destroy a window.

Definition at line 2712 of file SDL_video.c.

2713{
2714 SDL_VideoDisplay *display;
2715
2717
2718 window->is_destroying = SDL_TRUE;
2719
2720 /* Restore video mode, etc. */
2722
2723 /* Make sure this window no longer has focus */
2724 if (SDL_GetKeyboardFocus() == window) {
2726 }
2727 if (SDL_GetMouseFocus() == window) {
2729 }
2730
2731 /* make no context current if this is the current context window. */
2732 if (window->flags & SDL_WINDOW_OPENGL) {
2733 if (_this->current_glwin == window) {
2735 }
2736 }
2737
2738 if (window->surface) {
2739 window->surface->flags &= ~SDL_DONTFREE;
2740 SDL_FreeSurface(window->surface);
2741 }
2744 }
2745 if (_this->DestroyWindow) {
2747 }
2748 if (window->flags & SDL_WINDOW_OPENGL) {
2750 }
2751 if (window->flags & SDL_WINDOW_VULKAN) {
2753 }
2754
2756 if (display->fullscreen_window == window) {
2757 display->fullscreen_window = NULL;
2758 }
2759
2760 /* Now invalidate magic */
2761 window->magic = NULL;
2762
2763 /* Free memory associated with the window */
2764 SDL_free(window->title);
2765 SDL_FreeSurface(window->icon);
2766 SDL_free(window->gamma);
2767 while (window->data) {
2769
2770 window->data = data->next;
2771 SDL_free(data->name);
2772 SDL_free(data);
2773 }
2774
2775 /* Unlink the window from the list */
2776 if (window->next) {
2777 window->next->prev = window->prev;
2778 }
2779 if (window->prev) {
2780 window->prev->next = window->next;
2781 } else {
2783 }
2784
2786}
#define SDL_GetKeyboardFocus
#define SDL_GetMouseFocus
#define SDL_FreeSurface
void SDL_SetKeyboardFocus(SDL_Window *window)
Definition: SDL_keyboard.c:630
void SDL_SetMouseFocus(SDL_Window *window)
Definition: SDL_mouse.c:211
void SDL_HideWindow(SDL_Window *window)
Hide a window.
Definition: SDL_video.c:2168
#define CHECK_WINDOW_MAGIC(window, retval)
Definition: SDL_video.c:120
int SDL_GL_MakeCurrent(SDL_Window *window, SDL_GLContext ctx)
Set up an OpenGL context for rendering into an OpenGL window.
Definition: SDL_video.c:3516
void SDL_GL_UnloadLibrary(void)
Unload the OpenGL library previously loaded by SDL_GL_LoadLibrary().
Definition: SDL_video.c:2929
void SDL_Vulkan_UnloadLibrary(void)
Unload the Vulkan loader library previously loaded by SDL_Vulkan_LoadLibrary().
Definition: SDL_video.c:4115
void(* DestroyWindow)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:235
void(* DestroyWindowFramebuffer)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:238
SDL_Window * current_glwin
Definition: SDL_sysvideo.h:363
SDL_Window * fullscreen_window
Definition: SDL_sysvideo.h:135
SDL_Window * next
Definition: SDL_sysvideo.h:114

References _this, CHECK_WINDOW_MAGIC, SDL_VideoDevice::current_glwin, SDL_WindowUserData::data, SDL_VideoDevice::DestroyWindow, SDL_VideoDevice::DestroyWindowFramebuffer, SDL_VideoDisplay::fullscreen_window, SDL_Window::next, NULL, SDL_free, SDL_FreeSurface, SDL_GetDisplayForWindow(), SDL_GetKeyboardFocus, SDL_GetMouseFocus, SDL_GL_MakeCurrent(), SDL_GL_UnloadLibrary(), SDL_HideWindow(), SDL_SetKeyboardFocus(), SDL_SetMouseFocus(), SDL_TRUE, SDL_Vulkan_UnloadLibrary(), SDL_WINDOW_OPENGL, SDL_WINDOW_VULKAN, and SDL_VideoDevice::windows.

Referenced by SDL_CreateWindow(), SDL_CreateWindowFrom(), SDL_VideoQuit(), and ShouldUseTextureFramebuffer().

◆ SDL_DestroyWindowTexture()

static void SDL_DestroyWindowTexture ( SDL_VideoDevice unused,
SDL_Window window 
)
static

Definition at line 396 of file SDL_video.c.

397{
399
401 if (!data) {
402 return;
403 }
404 if (data->texture) {
405 SDL_DestroyTexture(data->texture);
406 }
407 if (data->renderer) {
408 SDL_DestroyRenderer(data->renderer);
409 }
410 SDL_free(data->pixels);
411 SDL_free(data);
412}

References NULL, SDL_DestroyRenderer, SDL_DestroyTexture, SDL_free, SDL_SetWindowData(), and SDL_WINDOWTEXTUREDATA.

Referenced by SDL_VideoInit().

◆ SDL_DisableScreenSaver()

void SDL_DisableScreenSaver ( void  )

Prevent the screen from being blanked by a screensaver.

See also
SDL_IsScreenSaverEnabled()
SDL_EnableScreenSaver()

Definition at line 2813 of file SDL_video.c.

2814{
2815 if (!_this) {
2816 return;
2817 }
2819 return;
2820 }
2824 }
2825}
void(* SuspendScreenSaver)(_THIS)
Definition: SDL_sysvideo.h:284
SDL_bool suspend_screensaver
Definition: SDL_sysvideo.h:314

References _this, SDL_TRUE, SDL_VideoDevice::suspend_screensaver, and SDL_VideoDevice::SuspendScreenSaver.

Referenced by SDL_VideoInit().

◆ SDL_EnableScreenSaver()

void SDL_EnableScreenSaver ( void  )

Allow the screen to be blanked by a screensaver.

See also
SDL_IsScreenSaverEnabled()
SDL_DisableScreenSaver()

Definition at line 2798 of file SDL_video.c.

2799{
2800 if (!_this) {
2801 return;
2802 }
2803 if (!_this->suspend_screensaver) {
2804 return;
2805 }
2809 }
2810}

References _this, SDL_FALSE, SDL_VideoDevice::suspend_screensaver, and SDL_VideoDevice::SuspendScreenSaver.

Referenced by SDL_VideoQuit().

◆ SDL_FinishWindowCreation()

static void SDL_FinishWindowCreation ( SDL_Window window,
Uint32  flags 
)
static

Definition at line 1383 of file SDL_video.c.

1384{
1386
1389 }
1392 }
1395 }
1398 }
1399 if (!(flags & SDL_WINDOW_HIDDEN)) {
1401 }
1402}
void SDL_SetWindowGrab(SDL_Window *window, SDL_bool grabbed)
Set a window's input grab mode.
Definition: SDL_video.c:2551
int SDL_SetWindowFullscreen(SDL_Window *window, Uint32 flags)
Set a window's fullscreen state.
Definition: SDL_video.c:2259
void SDL_ShowWindow(SDL_Window *window)
Show a window.
Definition: SDL_video.c:2153
void SDL_MaximizeWindow(SDL_Window *window)
Make a window as large as possible.
Definition: SDL_video.c:2200
void SDL_MinimizeWindow(SDL_Window *window)
Minimize a window to an iconic representation.
Definition: SDL_video.c:2225
@ SDL_WINDOW_INPUT_GRABBED
Definition: SDL_video.h:108
@ SDL_WINDOW_MAXIMIZED
Definition: SDL_video.h:107

References PrepareDragAndDropSupport(), SDL_MaximizeWindow(), SDL_MinimizeWindow(), SDL_SetWindowFullscreen(), SDL_SetWindowGrab(), SDL_ShowWindow(), SDL_TRUE, SDL_WINDOW_FULLSCREEN, SDL_WINDOW_HIDDEN, SDL_WINDOW_INPUT_GRABBED, SDL_WINDOW_MAXIMIZED, and SDL_WINDOW_MINIMIZED.

Referenced by SDL_CreateWindow(), and SDL_RecreateWindow().

◆ SDL_GetClosestDisplayMode()

SDL_DisplayMode * SDL_GetClosestDisplayMode ( int  displayIndex,
const SDL_DisplayMode mode,
SDL_DisplayMode closest 
)

Get the closest match to the requested display mode.

Parameters
displayIndexThe index of display from which mode should be queried.
modeThe desired display mode
closestA pointer to a display mode to be filled in with the closest match of the available display modes.
Returns
The passed in value closest, or NULL if no matching video mode was available.

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 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.

See also
SDL_GetNumDisplayModes()
SDL_GetDisplayMode()

Definition at line 959 of file SDL_video.c.

962{
963 SDL_VideoDisplay *display;
964
965 CHECK_DISPLAY_INDEX(displayIndex, NULL);
966
967 display = &_this->displays[displayIndex];
968 return SDL_GetClosestDisplayModeForDisplay(display, mode, closest);
969}
#define CHECK_DISPLAY_INDEX(displayIndex, retval)
Definition: SDL_video.c:131
static SDL_DisplayMode * SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *display, const SDL_DisplayMode *mode, SDL_DisplayMode *closest)
Definition: SDL_video.c:852

References _this, CHECK_DISPLAY_INDEX, SDL_VideoDevice::displays, NULL, and SDL_GetClosestDisplayModeForDisplay().

◆ SDL_GetClosestDisplayModeForDisplay()

static SDL_DisplayMode * SDL_GetClosestDisplayModeForDisplay ( SDL_VideoDisplay display,
const SDL_DisplayMode mode,
SDL_DisplayMode closest 
)
static

Definition at line 852 of file SDL_video.c.

855{
856 Uint32 target_format;
857 int target_refresh_rate;
858 int i;
859 SDL_DisplayMode *current, *match;
860
861 if (!mode || !closest) {
862 SDL_SetError("Missing desired mode or closest mode parameter");
863 return NULL;
864 }
865
866 /* Default to the desktop format */
867 if (mode->format) {
868 target_format = mode->format;
869 } else {
870 target_format = display->desktop_mode.format;
871 }
872
873 /* Default to the desktop refresh rate */
874 if (mode->refresh_rate) {
875 target_refresh_rate = mode->refresh_rate;
876 } else {
877 target_refresh_rate = display->desktop_mode.refresh_rate;
878 }
879
880 match = NULL;
881 for (i = 0; i < SDL_GetNumDisplayModesForDisplay(display); ++i) {
882 current = &display->display_modes[i];
883
884 if (current->w && (current->w < mode->w)) {
885 /* Out of sorted modes large enough here */
886 break;
887 }
888 if (current->h && (current->h < mode->h)) {
889 if (current->w && (current->w == mode->w)) {
890 /* Out of sorted modes large enough here */
891 break;
892 }
893 /* Wider, but not tall enough, due to a different
894 aspect ratio. This mode must be skipped, but closer
895 modes may still follow. */
896 continue;
897 }
898 if (!match || current->w < match->w || current->h < match->h) {
899 match = current;
900 continue;
901 }
902 if (current->format != match->format) {
903 /* Sorted highest depth to lowest */
904 if (current->format == target_format ||
905 (SDL_BITSPERPIXEL(current->format) >=
906 SDL_BITSPERPIXEL(target_format)
907 && SDL_PIXELTYPE(current->format) ==
908 SDL_PIXELTYPE(target_format))) {
909 match = current;
910 }
911 continue;
912 }
913 if (current->refresh_rate != match->refresh_rate) {
914 /* Sorted highest refresh to lowest */
915 if (current->refresh_rate >= target_refresh_rate) {
916 match = current;
917 }
918 }
919 }
920 if (match) {
921 if (match->format) {
922 closest->format = match->format;
923 } else {
924 closest->format = mode->format;
925 }
926 if (match->w && match->h) {
927 closest->w = match->w;
928 closest->h = match->h;
929 } else {
930 closest->w = mode->w;
931 closest->h = mode->h;
932 }
933 if (match->refresh_rate) {
934 closest->refresh_rate = match->refresh_rate;
935 } else {
936 closest->refresh_rate = mode->refresh_rate;
937 }
938 closest->driverdata = match->driverdata;
939
940 /*
941 * Pick some reasonable defaults if the app and driver don't
942 * care
943 */
944 if (!closest->format) {
946 }
947 if (!closest->w) {
948 closest->w = 640;
949 }
950 if (!closest->h) {
951 closest->h = 480;
952 }
953 return closest;
954 }
955 return NULL;
956}
@ SDL_PIXELFORMAT_RGB888
Definition: SDL_pixels.h:236
#define SDL_PIXELTYPE(X)
Definition: SDL_pixels.h:124
static int SDL_GetNumDisplayModesForDisplay(SDL_VideoDisplay *display)
Definition: SDL_video.c:787
void * driverdata
Definition: SDL_video.h:59
Uint32 format
Definition: SDL_video.h:55

References SDL_VideoDisplay::desktop_mode, SDL_VideoDisplay::display_modes, SDL_DisplayMode::driverdata, SDL_DisplayMode::format, SDL_DisplayMode::h, i, NULL, SDL_DisplayMode::refresh_rate, SDL_BITSPERPIXEL, SDL_GetNumDisplayModesForDisplay(), SDL_PIXELFORMAT_RGB888, SDL_PIXELTYPE, SDL_SetError, and SDL_DisplayMode::w.

Referenced by SDL_GetClosestDisplayMode(), SDL_GetWindowDisplayMode(), and SDL_SetDisplayModeForDisplay().

◆ SDL_GetCurrentDisplayMode()

int SDL_GetCurrentDisplayMode ( int  displayIndex,
SDL_DisplayMode mode 
)

Fill in information about the current display mode.

Definition at line 838 of file SDL_video.c.

839{
840 SDL_VideoDisplay *display;
841
842 CHECK_DISPLAY_INDEX(displayIndex, -1);
843
844 display = &_this->displays[displayIndex];
845 if (mode) {
846 *mode = display->current_mode;
847 }
848 return 0;
849}

References _this, CHECK_DISPLAY_INDEX, SDL_VideoDisplay::current_mode, and SDL_VideoDevice::displays.

◆ SDL_GetCurrentVideoDriver()

const char * SDL_GetCurrentVideoDriver ( void  )

Returns the name of the currently initialized video driver.

Returns
The name of the current video driver or NULL if no driver has been initialized
See also
SDL_GetNumVideoDrivers()
SDL_GetVideoDriver()

Definition at line 573 of file SDL_video.c.

574{
575 if (!_this) {
577 return NULL;
578 }
579 return _this->name;
580}

References _this, SDL_VideoDevice::name, NULL, and SDL_UninitializedVideo().

◆ SDL_GetDesktopDisplayMode()

int SDL_GetDesktopDisplayMode ( int  displayIndex,
SDL_DisplayMode mode 
)

Fill in information about the desktop display mode.

Definition at line 824 of file SDL_video.c.

825{
826 SDL_VideoDisplay *display;
827
828 CHECK_DISPLAY_INDEX(displayIndex, -1);
829
830 display = &_this->displays[displayIndex];
831 if (mode) {
832 *mode = display->desktop_mode;
833 }
834 return 0;
835}

References _this, CHECK_DISPLAY_INDEX, SDL_VideoDisplay::desktop_mode, and SDL_VideoDevice::displays.

◆ SDL_GetDisplay()

SDL_VideoDisplay * SDL_GetDisplay ( int  displayIndex)

Definition at line 1021 of file SDL_video.c.

1022{
1023 CHECK_DISPLAY_INDEX(displayIndex, NULL);
1024
1025 return &_this->displays[displayIndex];
1026}

References _this, CHECK_DISPLAY_INDEX, SDL_VideoDevice::displays, and NULL.

◆ SDL_GetDisplayBounds()

int SDL_GetDisplayBounds ( int  displayIndex,
SDL_Rect rect 
)

Get the desktop area represented by a display, with the primary display located at 0,0.

Returns
0 on success, or -1 if the index is out of range.
See also
SDL_GetNumVideoDisplays()

Definition at line 673 of file SDL_video.c.

674{
675 CHECK_DISPLAY_INDEX(displayIndex, -1);
676
677 if (rect) {
678 SDL_VideoDisplay *display = &_this->displays[displayIndex];
679
680 if (_this->GetDisplayBounds) {
681 if (_this->GetDisplayBounds(_this, display, rect) == 0) {
682 return 0;
683 }
684 }
685
686 /* Assume that the displays are left to right */
687 if (displayIndex == 0) {
688 rect->x = 0;
689 rect->y = 0;
690 } else {
691 SDL_GetDisplayBounds(displayIndex-1, rect);
692 rect->x += rect->w;
693 }
694 rect->w = display->current_mode.w;
695 rect->h = display->current_mode.h;
696 }
697 return 0; /* !!! FIXME: should this be an error if (rect==NULL) ? */
698}
int(* GetDisplayBounds)(_THIS, SDL_VideoDisplay *display, SDL_Rect *rect)
Definition: SDL_sysvideo.h:182
SDL_Rect rect
Definition: testrelative.c:27

References _this, CHECK_DISPLAY_INDEX, SDL_VideoDisplay::current_mode, SDL_VideoDevice::displays, SDL_VideoDevice::GetDisplayBounds, SDL_Rect::h, SDL_DisplayMode::h, rect, SDL_GetDisplayBounds(), SDL_Rect::w, SDL_DisplayMode::w, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDL_CreateWindow(), SDL_GetDisplayBounds(), SDL_GetDisplayUsableBounds(), SDL_GetWindowDisplayIndex(), SDL_GetWindowPosition(), and SDL_SetWindowPosition().

◆ SDL_GetDisplayDPI()

int SDL_GetDisplayDPI ( int  displayIndex,
float *  ddpi,
float *  hdpi,
float *  vdpi 
)

Get the dots/pixels-per-inch for a display.

Note
Diagonal, horizontal and vertical DPI can all be optionally returned if the parameter is non-NULL.
Returns
0 on success, or -1 if no DPI information is available or the index is out of range.
See also
SDL_GetNumVideoDisplays()

Definition at line 720 of file SDL_video.c.

721{
722 SDL_VideoDisplay *display;
723
724 CHECK_DISPLAY_INDEX(displayIndex, -1);
725
726 display = &_this->displays[displayIndex];
727
728 if (_this->GetDisplayDPI) {
729 if (_this->GetDisplayDPI(_this, display, ddpi, hdpi, vdpi) == 0) {
730 return 0;
731 }
732 } else {
733 return SDL_Unsupported();
734 }
735
736 return -1;
737}
int(* GetDisplayDPI)(_THIS, SDL_VideoDisplay *display, float *ddpi, float *hdpi, float *vdpi)
Definition: SDL_sysvideo.h:192

References _this, CHECK_DISPLAY_INDEX, SDL_VideoDevice::displays, SDL_VideoDevice::GetDisplayDPI, and SDL_Unsupported.

◆ SDL_GetDisplayDriverData()

void * SDL_GetDisplayDriverData ( int  displayIndex)

Definition at line 657 of file SDL_video.c.

658{
659 CHECK_DISPLAY_INDEX(displayIndex, NULL);
660
661 return _this->displays[displayIndex].driverdata;
662}

References _this, CHECK_DISPLAY_INDEX, SDL_VideoDevice::displays, SDL_VideoDisplay::driverdata, and NULL.

◆ SDL_GetDisplayForWindow()

SDL_VideoDisplay * SDL_GetDisplayForWindow ( SDL_Window window)

Definition at line 1089 of file SDL_video.c.

1090{
1091 int displayIndex = SDL_GetWindowDisplayIndex(window);
1092 if (displayIndex >= 0) {
1093 return &_this->displays[displayIndex];
1094 } else {
1095 return NULL;
1096 }
1097}
int SDL_GetWindowDisplayIndex(SDL_Window *window)
Get the display index associated with a window.
Definition: SDL_video.c:1029

References _this, SDL_VideoDevice::displays, NULL, and SDL_GetWindowDisplayIndex().

Referenced by SDL_CreateWindow(), SDL_DestroyWindow(), SDL_GetWindowDisplayMode(), SDL_GetWindowPixelFormat(), SDL_SetWindowDisplayMode(), and SDL_UpdateFullscreenMode().

◆ SDL_GetDisplayMode()

int SDL_GetDisplayMode ( int  displayIndex,
int  modeIndex,
SDL_DisplayMode mode 
)

Fill in information about a specific display mode.

Note
The display modes are sorted in this priority:
  • bits per pixel -> more colors to fewer colors
  • width -> largest to smallest
  • height -> largest to smallest
  • refresh rate -> highest to lowest
See also
SDL_GetNumDisplayModes()

Definition at line 806 of file SDL_video.c.

807{
808 SDL_VideoDisplay *display;
809
810 CHECK_DISPLAY_INDEX(displayIndex, -1);
811
812 display = &_this->displays[displayIndex];
814 return SDL_SetError("index must be in the range of 0 - %d",
816 }
817 if (mode) {
818 *mode = display->display_modes[index];
819 }
820 return 0;
821}

References _this, CHECK_DISPLAY_INDEX, SDL_VideoDisplay::display_modes, SDL_VideoDevice::displays, SDL_GetNumDisplayModesForDisplay(), and SDL_SetError.

◆ SDL_GetDisplayName()

const char * SDL_GetDisplayName ( int  displayIndex)

Get the name of a display in UTF-8 encoding.

Returns
The name of a display, or NULL for an invalid display index.
See also
SDL_GetNumVideoDisplays()

Definition at line 665 of file SDL_video.c.

666{
667 CHECK_DISPLAY_INDEX(displayIndex, NULL);
668
669 return _this->displays[displayIndex].name;
670}

References _this, CHECK_DISPLAY_INDEX, SDL_VideoDevice::displays, SDL_VideoDisplay::name, and NULL.

◆ SDL_GetDisplayOrientation()

SDL_DisplayOrientation SDL_GetDisplayOrientation ( int  displayIndex)

Get the orientation of a display.

Returns
The orientation of the display, or SDL_ORIENTATION_UNKNOWN if it isn't available.
See also
SDL_GetNumVideoDisplays()

Definition at line 740 of file SDL_video.c.

741{
742 SDL_VideoDisplay *display;
743
745
746 display = &_this->displays[displayIndex];
747 return display->orientation;
748}
@ SDL_ORIENTATION_UNKNOWN
Definition: SDL_video.h:183
SDL_DisplayOrientation orientation
Definition: SDL_sysvideo.h:133

References _this, CHECK_DISPLAY_INDEX, SDL_VideoDevice::displays, SDL_VideoDisplay::orientation, and SDL_ORIENTATION_UNKNOWN.

◆ SDL_GetDisplayUsableBounds()

int SDL_GetDisplayUsableBounds ( int  displayIndex,
SDL_Rect rect 
)

Get the usable desktop area represented by a display, with the primary display located at 0,0.

This is the same area as SDL_GetDisplayBounds() reports, but with portions reserved by the system removed. For example, on Mac OS X, 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.

Returns
0 on success, or -1 if the index is out of range.
See also
SDL_GetDisplayBounds()
SDL_GetNumVideoDisplays()

Definition at line 700 of file SDL_video.c.

701{
702 CHECK_DISPLAY_INDEX(displayIndex, -1);
703
704 if (rect) {
705 SDL_VideoDisplay *display = &_this->displays[displayIndex];
706
708 if (_this->GetDisplayUsableBounds(_this, display, rect) == 0) {
709 return 0;
710 }
711 }
712
713 /* Oh well, just give the entire display bounds. */
714 return SDL_GetDisplayBounds(displayIndex, rect);
715 }
716 return 0; /* !!! FIXME: should this be an error if (rect==NULL) ? */
717}
int(* GetDisplayUsableBounds)(_THIS, SDL_VideoDisplay *display, SDL_Rect *rect)
Definition: SDL_sysvideo.h:187

References _this, CHECK_DISPLAY_INDEX, SDL_VideoDevice::displays, SDL_VideoDevice::GetDisplayUsableBounds, rect, and SDL_GetDisplayBounds().

◆ SDL_GetFocusWindow()

SDL_Window * SDL_GetFocusWindow ( void  )

Definition at line 2696 of file SDL_video.c.

2697{
2699
2700 if (!_this) {
2701 return NULL;
2702 }
2703 for (window = _this->windows; window; window = window->next) {
2704 if (window->flags & SDL_WINDOW_INPUT_FOCUS) {
2705 return window;
2706 }
2707 }
2708 return NULL;
2709}
@ SDL_WINDOW_INPUT_FOCUS
Definition: SDL_video.h:109

References _this, SDL_Window::next, NULL, SDL_WINDOW_INPUT_FOCUS, and SDL_VideoDevice::windows.

Referenced by SDL_PromptAssertion(), SDL_StartTextInput(), and SDL_StopTextInput().

◆ SDL_GetGrabbedWindow()

SDL_Window * SDL_GetGrabbedWindow ( void  )

Get the window that currently has an input grab enabled.

Returns
This returns the window if input is grabbed, and NULL otherwise.
See also
SDL_SetWindowGrab()

Definition at line 2575 of file SDL_video.c.

2576{
2578 return _this->grabbed_window;
2579}
#define SDL_assert(condition)
Definition: SDL_assert.h:169
SDL_Window * grabbed_window
Definition: SDL_sysvideo.h:318
Uint32 flags
Definition: SDL_sysvideo.h:83

References _this, SDL_Window::flags, SDL_VideoDevice::grabbed_window, SDL_assert, and SDL_WINDOW_INPUT_GRABBED.

◆ SDL_GetIndexOfDisplay()

int SDL_GetIndexOfDisplay ( SDL_VideoDisplay display)

Definition at line 642 of file SDL_video.c.

643{
644 int displayIndex;
645
646 for (displayIndex = 0; displayIndex < _this->num_displays; ++displayIndex) {
647 if (display == &_this->displays[displayIndex]) {
648 return displayIndex;
649 }
650 }
651
652 /* Couldn't find the display, just use index 0 */
653 return 0;
654}

References _this, SDL_VideoDevice::displays, and SDL_VideoDevice::num_displays.

Referenced by SDL_CreateWindow(), and SDL_SendDisplayEvent().

◆ SDL_GetNumDisplayModes()

int SDL_GetNumDisplayModes ( int  displayIndex)

Returns the number of available display modes.

See also
SDL_GetDisplayMode()

Definition at line 798 of file SDL_video.c.

799{
800 CHECK_DISPLAY_INDEX(displayIndex, -1);
801
802 return SDL_GetNumDisplayModesForDisplay(&_this->displays[displayIndex]);
803}

References _this, CHECK_DISPLAY_INDEX, SDL_VideoDevice::displays, and SDL_GetNumDisplayModesForDisplay().

◆ SDL_GetNumDisplayModesForDisplay()

static int SDL_GetNumDisplayModesForDisplay ( SDL_VideoDisplay display)
static

Definition at line 787 of file SDL_video.c.

788{
789 if (!display->num_display_modes && _this->GetDisplayModes) {
790 _this->GetDisplayModes(_this, display);
791 SDL_qsort(display->display_modes, display->num_display_modes,
792 sizeof(SDL_DisplayMode), cmpmodes);
793 }
794 return display->num_display_modes;
795}
void(* GetDisplayModes)(_THIS, SDL_VideoDisplay *display)
Definition: SDL_sysvideo.h:197

References _this, cmpmodes(), SDL_VideoDisplay::display_modes, SDL_VideoDevice::GetDisplayModes, SDL_VideoDisplay::num_display_modes, and SDL_qsort.

Referenced by SDL_GetClosestDisplayModeForDisplay(), SDL_GetDisplayMode(), and SDL_GetNumDisplayModes().

◆ SDL_GetNumVideoDisplays()

int SDL_GetNumVideoDisplays ( void  )

Returns the number of available video displays.

See also
SDL_GetDisplayBounds()

Definition at line 632 of file SDL_video.c.

633{
634 if (!_this) {
636 return 0;
637 }
638 return _this->num_displays;
639}

References _this, SDL_VideoDevice::num_displays, and SDL_UninitializedVideo().

◆ SDL_GetNumVideoDrivers()

int SDL_GetNumVideoDrivers ( void  )

Get the number of video drivers compiled into SDL.

See also
SDL_GetVideoDriver()

Definition at line 443 of file SDL_video.c.

444{
445 return SDL_arraysize(bootstrap) - 1;
446}
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:115
static VideoBootStrap * bootstrap[]
Definition: SDL_video.c:60

References bootstrap, and SDL_arraysize.

Referenced by SDL_GetVideoDriver().

◆ SDL_GetVideoDevice()

◆ SDL_GetVideoDriver()

const char * SDL_GetVideoDriver ( int  index)

Get the name of a built in video driver.

Note
The video drivers are presented in the order in which they are normally checked during initialization.
See also
SDL_GetNumVideoDrivers()

Definition at line 449 of file SDL_video.c.

450{
451 if (index >= 0 && index < SDL_GetNumVideoDrivers()) {
452 return bootstrap[index]->name;
453 }
454 return NULL;
455}
int SDL_GetNumVideoDrivers(void)
Get the number of video drivers compiled into SDL.
Definition: SDL_video.c:443
const char * name
Definition: SDL_sysvideo.h:399

References bootstrap, VideoBootStrap::name, NULL, and SDL_GetNumVideoDrivers().

◆ SDL_GetWindowBordersSize()

int SDL_GetWindowBordersSize ( SDL_Window window,
int *  top,
int *  left,
int *  bottom,
int *  right 
)

Get the size of a window's borders (decorations) around the client area.

Parameters
windowThe window to query.
topPointer to variable for storing the size of the top border. NULL is permitted.
leftPointer to variable for storing the size of the left border. NULL is permitted.
bottomPointer to variable for storing the size of the bottom border. NULL is permitted.
rightPointer to variable for storing the size of the right border. NULL is permitted.
Returns
0 on success, or -1 if getting this information is not supported.
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.

Definition at line 2046 of file SDL_video.c.

2047{
2048 int dummy = 0;
2049
2050 if (!top) { top = &dummy; }
2051 if (!left) { left = &dummy; }
2052 if (!right) { right = &dummy; }
2053 if (!bottom) { bottom = &dummy; }
2054
2055 /* Always initialize, so applications don't have to care */
2056 *top = *left = *bottom = *right = 0;
2057
2059
2061 return SDL_Unsupported();
2062 }
2063
2065}
GLdouble GLdouble GLdouble GLdouble top
GLint left
GLint GLint bottom
GLdouble GLdouble right
int(* GetWindowBordersSize)(_THIS, SDL_Window *window, int *top, int *left, int *bottom, int *right)
Definition: SDL_sysvideo.h:219

References _this, CHECK_WINDOW_MAGIC, SDL_VideoDevice::GetWindowBordersSize, and SDL_Unsupported.

◆ SDL_GetWindowBrightness()

float SDL_GetWindowBrightness ( SDL_Window window)

Get the brightness (gamma correction) for a window.

Returns
The last brightness value passed to SDL_SetWindowBrightness()
See also
SDL_SetWindowBrightness()

Definition at line 2371 of file SDL_video.c.

2372{
2374
2375 return window->brightness;
2376}

References CHECK_WINDOW_MAGIC.

◆ SDL_GetWindowData()

void * SDL_GetWindowData ( SDL_Window window,
const char *  name 
)

Retrieve the data pointer associated with a window.

Parameters
windowThe window to query.
nameThe name of the pointer.
Returns
The value associated with 'name'
See also
SDL_SetWindowData()

Definition at line 1843 of file SDL_video.c.

1844{
1846
1848
1849 /* Input validation */
1850 if (name == NULL || name[0] == '\0') {
1851 SDL_InvalidParamError("name");
1852 return NULL;
1853 }
1854
1855 for (data = window->data; data; data = data->next) {
1856 if (data->name && SDL_strcmp(data->name, name) == 0) {
1857 return data->data;
1858 }
1859 }
1860 return NULL;
1861}
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54

References CHECK_WINDOW_MAGIC, NULL, SDL_InvalidParamError, and SDL_strcmp.

Referenced by SDL_CreateWindowTexture(), and SDL_UpdateWindowTexture().

◆ SDL_GetWindowDisplayIndex()

int SDL_GetWindowDisplayIndex ( SDL_Window window)

Get the display index associated with a window.

Returns
the display index of the display containing the center of the window, or -1 on error.

Definition at line 1029 of file SDL_video.c.

1030{
1031 int displayIndex;
1032 int i, dist;
1033 int closest = -1;
1034 int closest_dist = 0x7FFFFFFF;
1035 SDL_Point center;
1036 SDL_Point delta;
1037 SDL_Rect rect;
1038
1040
1043 displayIndex = (window->x & 0xFFFF);
1044 if (displayIndex >= _this->num_displays) {
1045 displayIndex = 0;
1046 }
1047 return displayIndex;
1048 }
1051 displayIndex = (window->y & 0xFFFF);
1052 if (displayIndex >= _this->num_displays) {
1053 displayIndex = 0;
1054 }
1055 return displayIndex;
1056 }
1057
1058 /* Find the display containing the window */
1059 for (i = 0; i < _this->num_displays; ++i) {
1060 SDL_VideoDisplay *display = &_this->displays[i];
1061
1062 if (display->fullscreen_window == window) {
1063 return i;
1064 }
1065 }
1066 center.x = window->x + window->w / 2;
1067 center.y = window->y + window->h / 2;
1068 for (i = 0; i < _this->num_displays; ++i) {
1070 if (SDL_EnclosePoints(&center, 1, &rect, NULL)) {
1071 return i;
1072 }
1073
1074 delta.x = center.x - (rect.x + rect.w / 2);
1075 delta.y = center.y - (rect.y + rect.h / 2);
1076 dist = (delta.x*delta.x + delta.y*delta.y);
1077 if (dist < closest_dist) {
1078 closest = i;
1079 closest_dist = dist;
1080 }
1081 }
1082 if (closest < 0) {
1083 SDL_SetError("Couldn't find any displays");
1084 }
1085 return closest;
1086}
#define SDL_EnclosePoints
The structure that defines a point (integer)
Definition: SDL_rect.h:49
int x
Definition: SDL_rect.h:50
int y
Definition: SDL_rect.h:51

References _this, CHECK_WINDOW_MAGIC, SDL_VideoDevice::displays, SDL_VideoDisplay::fullscreen_window, SDL_Rect::h, i, NULL, SDL_VideoDevice::num_displays, rect, SDL_EnclosePoints, SDL_GetDisplayBounds(), SDL_SetError, SDL_WINDOWPOS_ISCENTERED, SDL_WINDOWPOS_ISUNDEFINED, SDL_Rect::w, SDL_Point::x, SDL_Rect::x, SDL_Point::y, and SDL_Rect::y.

Referenced by SDL_GetDisplayForWindow(), and SDL_GetWindowPosition().

◆ SDL_GetWindowDisplayMode()

int SDL_GetWindowDisplayMode ( SDL_Window window,
SDL_DisplayMode mode 
)

Fill in information about the display mode used when a fullscreen window is visible.

See also
SDL_SetWindowDisplayMode()
SDL_SetWindowFullscreen()

Definition at line 1120 of file SDL_video.c.

1121{
1122 SDL_DisplayMode fullscreen_mode;
1123 SDL_VideoDisplay *display;
1124
1126
1127 if (!mode) {
1128 return SDL_InvalidParamError("mode");
1129 }
1130
1131 fullscreen_mode = window->fullscreen_mode;
1132 if (!fullscreen_mode.w) {
1133 fullscreen_mode.w = window->windowed.w;
1134 }
1135 if (!fullscreen_mode.h) {
1136 fullscreen_mode.h = window->windowed.h;
1137 }
1138
1140
1141 /* if in desktop size mode, just return the size of the desktop */
1143 fullscreen_mode = display->desktop_mode;
1145 &fullscreen_mode,
1146 &fullscreen_mode)) {
1147 return SDL_SetError("Couldn't find display mode match");
1148 }
1149
1150 if (mode) {
1151 *mode = fullscreen_mode;
1152 }
1153 return 0;
1154}
@ SDL_WINDOW_FULLSCREEN_DESKTOP
Definition: SDL_video.h:111

References CHECK_WINDOW_MAGIC, SDL_VideoDisplay::desktop_mode, SDL_DisplayMode::h, SDL_GetClosestDisplayModeForDisplay(), SDL_GetDisplayForWindow(), SDL_InvalidParamError, SDL_SetError, SDL_WINDOW_FULLSCREEN_DESKTOP, and SDL_DisplayMode::w.

Referenced by SDL_SetWindowDisplayMode(), and SDL_UpdateFullscreenMode().

◆ SDL_GetWindowFlags()

Uint32 SDL_GetWindowFlags ( SDL_Window window)

Get the window flags.

Definition at line 1741 of file SDL_video.c.

1742{
1744
1745 return window->flags;
1746}

References CHECK_WINDOW_MAGIC.

Referenced by SDL_ShowMessageBox().

◆ SDL_GetWindowFromID()

SDL_Window * SDL_GetWindowFromID ( Uint32  id)

Get a window from a stored ID, or NULL if it doesn't exist.

Definition at line 1725 of file SDL_video.c.

1726{
1728
1729 if (!_this) {
1730 return NULL;
1731 }
1732 for (window = _this->windows; window; window = window->next) {
1733 if (window->id == id) {
1734 return window;
1735 }
1736 }
1737 return NULL;
1738}

References _this, SDL_Window::next, NULL, and SDL_VideoDevice::windows.

◆ SDL_GetWindowGammaRamp()

int SDL_GetWindowGammaRamp ( SDL_Window window,
Uint16 red,
Uint16 green,
Uint16 blue 
)

Get the gamma ramp for a window.

Parameters
windowThe window from which the gamma ramp should be queried.
redA pointer to a 256 element array of 16-bit quantities to hold the translation table for the red channel, or NULL.
greenA pointer to a 256 element array of 16-bit quantities to hold the translation table for the green channel, or NULL.
blueA pointer to a 256 element array of 16-bit quantities to hold the translation table for the blue channel, or NULL.
Returns
0 on success, or -1 if gamma ramps are unsupported.
See also
SDL_SetWindowGammaRamp()

Definition at line 2475 of file SDL_video.c.

2478{
2480
2481 if (!window->gamma) {
2482 int i;
2483
2484 window->gamma = (Uint16 *)SDL_malloc(256*6*sizeof(Uint16));
2485 if (!window->gamma) {
2486 return SDL_OutOfMemory();
2487 }
2488 window->saved_gamma = window->gamma + 3*256;
2489
2491 if (_this->GetWindowGammaRamp(_this, window, window->gamma) < 0) {
2492 return -1;
2493 }
2494 } else {
2495 /* Create an identity gamma ramp */
2496 for (i = 0; i < 256; ++i) {
2497 Uint16 value = (Uint16)((i << 8) | i);
2498
2499 window->gamma[0*256+i] = value;
2500 window->gamma[1*256+i] = value;
2501 window->gamma[2*256+i] = value;
2502 }
2503 }
2504 SDL_memcpy(window->saved_gamma, window->gamma, 3*256*sizeof(Uint16));
2505 }
2506
2507 if (red) {
2508 SDL_memcpy(red, &window->gamma[0*256], 256*sizeof(Uint16));
2509 }
2510 if (green) {
2511 SDL_memcpy(green, &window->gamma[1*256], 256*sizeof(Uint16));
2512 }
2513 if (blue) {
2514 SDL_memcpy(blue, &window->gamma[2*256], 256*sizeof(Uint16));
2515 }
2516 return 0;
2517}
#define SDL_memcpy
const GLubyte GLuint red
Definition: SDL_glfuncs.h:80
GLbyte GLbyte blue
GLbyte green
GLsizei const GLfloat * value
uint16_t Uint16
Definition: SDL_stdinc.h:191
int(* GetWindowGammaRamp)(_THIS, SDL_Window *window, Uint16 *ramp)
Definition: SDL_sysvideo.h:233

References _this, CHECK_WINDOW_MAGIC, SDL_VideoDevice::GetWindowGammaRamp, i, red, SDL_malloc, SDL_memcpy, and SDL_OutOfMemory.

Referenced by SDL_SetWindowGammaRamp().

◆ SDL_GetWindowGrab()

SDL_bool SDL_GetWindowGrab ( SDL_Window window)

Get a window's input grab mode.

Returns
This returns SDL_TRUE if input is grabbed, and SDL_FALSE otherwise.
See also
SDL_SetWindowGrab()

Definition at line 2567 of file SDL_video.c.

References _this, CHECK_WINDOW_MAGIC, SDL_Window::flags, SDL_VideoDevice::grabbed_window, SDL_assert, SDL_FALSE, and SDL_WINDOW_INPUT_GRABBED.

◆ SDL_GetWindowID()

Uint32 SDL_GetWindowID ( SDL_Window window)

Get the numeric ID of a window, for logging purposes.

Definition at line 1717 of file SDL_video.c.

1718{
1720
1721 return window->id;
1722}

References CHECK_WINDOW_MAGIC.

◆ SDL_GetWindowMaximumSize()

void SDL_GetWindowMaximumSize ( SDL_Window window,
int *  w,
int *  h 
)

Get the maximum size of a window's client area.

Parameters
windowThe window to query.
wPointer to variable for storing the maximum width, may be NULL
hPointer to variable for storing the maximum height, may be NULL
See also
SDL_GetWindowMinimumSize()
SDL_SetWindowMaximumSize()

Definition at line 2141 of file SDL_video.c.

2142{
2144 if (max_w) {
2145 *max_w = window->max_w;
2146 }
2147 if (max_h) {
2148 *max_h = window->max_h;
2149 }
2150}

References CHECK_WINDOW_MAGIC.

◆ SDL_GetWindowMinimumSize()

void SDL_GetWindowMinimumSize ( SDL_Window window,
int *  w,
int *  h 
)

Get the minimum size of a window's client area.

Parameters
windowThe window to query.
wPointer to variable for storing the minimum width, may be NULL
hPointer to variable for storing the minimum height, may be NULL
See also
SDL_GetWindowMaximumSize()
SDL_SetWindowMinimumSize()

Definition at line 2099 of file SDL_video.c.

2100{
2102 if (min_w) {
2103 *min_w = window->min_w;
2104 }
2105 if (min_h) {
2106 *min_h = window->min_h;
2107 }
2108}

References CHECK_WINDOW_MAGIC.

◆ SDL_GetWindowOpacity()

int SDL_GetWindowOpacity ( SDL_Window window,
float *  out_opacity 
)

Get the opacity of a window.

If transparency isn't supported on this platform, opacity will be reported as 1.0f without error.

Parameters
windowThe window in question.
out_opacityOpacity (0.0f - transparent, 1.0f - opaque)
Returns
0 on success, or -1 on error (invalid window, etc).
See also
SDL_SetWindowOpacity()

Definition at line 2403 of file SDL_video.c.

2404{
2406
2407 if (out_opacity) {
2408 *out_opacity = window->opacity;
2409 }
2410
2411 return 0;
2412}

References CHECK_WINDOW_MAGIC.

◆ SDL_GetWindowPixelFormat()

Uint32 SDL_GetWindowPixelFormat ( SDL_Window window)

Get the pixel format associated with the window.

Definition at line 1157 of file SDL_video.c.

1158{
1159 SDL_VideoDisplay *display;
1160
1162
1164 return display->current_mode.format;
1165}
@ SDL_PIXELFORMAT_UNKNOWN
Definition: SDL_pixels.h:173

References CHECK_WINDOW_MAGIC, SDL_VideoDisplay::current_mode, SDL_DisplayMode::format, SDL_GetDisplayForWindow(), and SDL_PIXELFORMAT_UNKNOWN.

◆ SDL_GetWindowPosition()

void SDL_GetWindowPosition ( SDL_Window window,
int *  x,
int *  y 
)

Get the position of a window.

Parameters
windowThe window to query.
xPointer to variable for storing the x position, in screen coordinates. May be NULL.
yPointer to variable for storing the y position, in screen coordinates. May be NULL.
See also
SDL_SetWindowPosition()

Definition at line 1908 of file SDL_video.c.

1909{
1911
1912 /* Fullscreen windows are always at their display's origin */
1913 if (window->flags & SDL_WINDOW_FULLSCREEN) {
1914 int displayIndex;
1915
1916 if (x) {
1917 *x = 0;
1918 }
1919 if (y) {
1920 *y = 0;
1921 }
1922
1923 /* Find the window's monitor and update to the
1924 monitor offset. */
1925 displayIndex = SDL_GetWindowDisplayIndex(window);
1926 if (displayIndex >= 0) {
1927 SDL_Rect bounds;
1928
1929 SDL_zero(bounds);
1930
1931 SDL_GetDisplayBounds(displayIndex, &bounds);
1932 if (x) {
1933 *x = bounds.x;
1934 }
1935 if (y) {
1936 *y = bounds.y;
1937 }
1938 }
1939 } else {
1940 if (x) {
1941 *x = window->x;
1942 }
1943 if (y) {
1944 *y = window->y;
1945 }
1946 }
1947}

References CHECK_WINDOW_MAGIC, SDL_GetDisplayBounds(), SDL_GetWindowDisplayIndex(), SDL_WINDOW_FULLSCREEN, SDL_zero, SDL_Rect::x, and SDL_Rect::y.

◆ SDL_GetWindowSize()

void SDL_GetWindowSize ( SDL_Window window,
int *  w,
int *  h 
)

Get the size of a window's client area.

Parameters
windowThe window to query.
wPointer to variable for storing the width, in screen coordinates. May be NULL.
hPointer to variable for storing the height, in screen coordinates. May be NULL.

The window size in screen coordinates may differ from the size in pixels, if the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a platform with high-dpi support (e.g. iOS or OS X). Use SDL_GL_GetDrawableSize() or SDL_GetRendererOutputSize() to get the real client area size in pixels.

See also
SDL_SetWindowSize()

Definition at line 2034 of file SDL_video.c.

2035{
2037 if (w) {
2038 *w = window->w;
2039 }
2040 if (h) {
2041 *h = window->h;
2042 }
2043}

References CHECK_WINDOW_MAGIC.

Referenced by SDL_GL_GetDrawableSize(), and SDL_Vulkan_GetDrawableSize().

◆ SDL_GetWindowSurface()

SDL_Surface * SDL_GetWindowSurface ( SDL_Window window)

Get the SDL surface associated with the window.

Returns
The window's framebuffer surface, or NULL on error.

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.

Note
You may not combine this with 3D or the rendering API on this window.
See also
SDL_UpdateWindowSurface()
SDL_UpdateWindowSurfaceRects()

Definition at line 2309 of file SDL_video.c.

2310{
2312
2313 if (!window->surface_valid) {
2314 if (window->surface) {
2315 window->surface->flags &= ~SDL_DONTFREE;
2316 SDL_FreeSurface(window->surface);
2317 }
2319 if (window->surface) {
2320 window->surface_valid = SDL_TRUE;
2321 window->surface->flags |= SDL_DONTFREE;
2322 }
2323 }
2324 return window->surface;
2325}
#define SDL_DONTFREE
Definition: SDL_surface.h:55
static SDL_Surface * SDL_CreateWindowFramebuffer(SDL_Window *window)
Definition: SDL_video.c:2285

References CHECK_WINDOW_MAGIC, NULL, SDL_CreateWindowFramebuffer(), SDL_DONTFREE, SDL_FreeSurface, and SDL_TRUE.

◆ SDL_GetWindowTitle()

const char * SDL_GetWindowTitle ( SDL_Window window)

Get the title of a window, in UTF-8 format.

See also
SDL_SetWindowTitle()

Definition at line 1766 of file SDL_video.c.

1767{
1769
1770 return window->title ? window->title : "";
1771}

References CHECK_WINDOW_MAGIC.

◆ SDL_GetWindowWMInfo()

SDL_bool SDL_GetWindowWMInfo ( SDL_Window window,
SDL_SysWMinfo info 
)

This function allows access to driver-dependent window information.

Parameters
windowThe window about which information is being requested
infoThis structure must be initialized with the SDL version, and is then filled in with information about the given window.
Returns
SDL_TRUE if the function is implemented and the version member of the info struct is valid, SDL_FALSE otherwise.

You typically use this function like this:

if ( SDL_GetWindowWMInfo(window, &info) ) { ... }
#define SDL_GetWindowWMInfo
#define SDL_VERSION(x)
Macro to determine SDL version program was compiled against.
Definition: SDL_version.h:79
SDL_version version
Definition: SDL_syswm.h:199

Definition at line 3737 of file SDL_video.c.

3738{
3740
3741 if (!info) {
3742 SDL_InvalidParamError("info");
3743 return SDL_FALSE;
3744 }
3746
3747 if (!_this->GetWindowWMInfo) {
3749 return SDL_FALSE;
3750 }
3751 return (_this->GetWindowWMInfo(_this, window, info));
3752}
@ SDL_SYSWM_UNKNOWN
Definition: SDL_syswm.h:121
SDL_SYSWM_TYPE subsystem
Definition: SDL_syswm.h:200
SDL_bool(* GetWindowWMInfo)(_THIS, SDL_Window *window, struct SDL_SysWMinfo *info)
Definition: SDL_sysvideo.h:248

References _this, CHECK_WINDOW_MAGIC, SDL_VideoDevice::GetWindowWMInfo, SDL_FALSE, SDL_InvalidParamError, SDL_SYSWM_UNKNOWN, SDL_Unsupported, and SDL_SysWMinfo::subsystem.

Referenced by SDL_MessageboxValidForDriver().

◆ SDL_GL_CreateContext()

SDL_GLContext SDL_GL_CreateContext ( SDL_Window window)

Create an OpenGL context for use with an OpenGL window, and make it current.

See also
SDL_GL_DeleteContext()

Definition at line 3493 of file SDL_video.c.

3494{
3497
3498 if (!(window->flags & SDL_WINDOW_OPENGL)) {
3499 SDL_SetError("The specified window isn't an OpenGL window");
3500 return NULL;
3501 }
3502
3504
3505 /* Creating a context is assumed to make it current in the SDL driver. */
3506 if (ctx) {
3511 }
3512 return ctx;
3513}
#define SDL_TLSSet
void * SDL_GLContext
An opaque handle to an OpenGL context.
Definition: SDL_video.h:193
EGLContext ctx
Definition: eglext.h:208
SDL_GLContext current_glctx
Definition: SDL_sysvideo.h:364
SDL_TLSID current_glwin_tls
Definition: SDL_sysvideo.h:365
SDL_TLSID current_glctx_tls
Definition: SDL_sysvideo.h:366

References _this, CHECK_WINDOW_MAGIC, SDL_VideoDevice::current_glctx, SDL_VideoDevice::current_glctx_tls, SDL_VideoDevice::current_glwin, SDL_VideoDevice::current_glwin_tls, SDL_VideoDevice::GL_CreateContext, NULL, SDL_SetError, SDL_TLSSet, and SDL_WINDOW_OPENGL.

Referenced by ShouldUseTextureFramebuffer().

◆ SDL_GL_DeduceMaxSupportedESProfile()

void SDL_GL_DeduceMaxSupportedESProfile ( int *  major,
int *  minor 
)

Definition at line 3044 of file SDL_video.c.

3045{
3046/* THIS REQUIRES AN EXISTING GL CONTEXT THAT HAS BEEN MADE CURRENT. */
3047/* Please refer to https://bugzilla.libsdl.org/show_bug.cgi?id=3725 for discussion. */
3048#if SDL_VIDEO_OPENGL || SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2
3049 /* XXX This is fragile; it will break in the event of release of
3050 * new versions of OpenGL ES.
3051 */
3052 if (SDL_GL_ExtensionSupported("GL_ARB_ES3_2_compatibility")) {
3053 *major = 3;
3054 *minor = 2;
3055 } else if (SDL_GL_ExtensionSupported("GL_ARB_ES3_1_compatibility")) {
3056 *major = 3;
3057 *minor = 1;
3058 } else if (SDL_GL_ExtensionSupported("GL_ARB_ES3_compatibility")) {
3059 *major = 3;
3060 *minor = 0;
3061 } else {
3062 *major = 2;
3063 *minor = 0;
3064 }
3065#endif
3066}
SDL_bool SDL_GL_ExtensionSupported(const char *extension)
Return true if an OpenGL extension is supported for the current context.
Definition: SDL_video.c:2954

References SDL_GL_ExtensionSupported().

◆ SDL_GL_DeleteContext()

void SDL_GL_DeleteContext ( SDL_GLContext  context)

Delete an OpenGL context.

See also
SDL_GL_CreateContext()

Definition at line 3624 of file SDL_video.c.

3625{
3626 if (!_this || !context) {
3627 return;
3628 }
3629
3632 }
3633
3635}
SDL_GLContext SDL_GL_GetCurrentContext(void)
Get the currently active OpenGL context.
Definition: SDL_video.c:3557
void(* GL_DeleteContext)(_THIS, SDL_GLContext context)
Definition: SDL_sysvideo.h:264
static screen_context_t context
Definition: video.c:25

References _this, context, SDL_VideoDevice::GL_DeleteContext, NULL, SDL_GL_GetCurrentContext(), and SDL_GL_MakeCurrent().

Referenced by ShouldUseTextureFramebuffer().

◆ SDL_GL_ExtensionSupported()

SDL_bool SDL_GL_ExtensionSupported ( const char *  extension)

Return true if an OpenGL extension is supported for the current context.

Definition at line 2954 of file SDL_video.c.

2955{
2956#if SDL_VIDEO_OPENGL || SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2
2957 const GLubyte *(APIENTRY * glGetStringFunc) (GLenum);
2958 const char *extensions;
2959 const char *start;
2960 const char *where, *terminator;
2961
2962 /* Extension names should not have spaces. */
2963 where = SDL_strchr(extension, ' ');
2964 if (where || *extension == '\0') {
2965 return SDL_FALSE;
2966 }
2967 /* See if there's an environment variable override */
2968 start = SDL_getenv(extension);
2969 if (start && *start == '0') {
2970 return SDL_FALSE;
2971 }
2972
2973 /* Lookup the available extensions */
2974
2975 glGetStringFunc = SDL_GL_GetProcAddress("glGetString");
2976 if (!glGetStringFunc) {
2977 return SDL_FALSE;
2978 }
2979
2980 if (isAtLeastGL3((const char *) glGetStringFunc(GL_VERSION))) {
2981 const GLubyte *(APIENTRY * glGetStringiFunc) (GLenum, GLuint);
2982 void (APIENTRY * glGetIntegervFunc) (GLenum pname, GLint * params);
2983 GLint num_exts = 0;
2984 GLint i;
2985
2986 glGetStringiFunc = SDL_GL_GetProcAddress("glGetStringi");
2987 glGetIntegervFunc = SDL_GL_GetProcAddress("glGetIntegerv");
2988 if ((!glGetStringiFunc) || (!glGetIntegervFunc)) {
2989 return SDL_FALSE;
2990 }
2991
2992 #ifndef GL_NUM_EXTENSIONS
2993 #define GL_NUM_EXTENSIONS 0x821D
2994 #endif
2995 glGetIntegervFunc(GL_NUM_EXTENSIONS, &num_exts);
2996 for (i = 0; i < num_exts; i++) {
2997 const char *thisext = (const char *) glGetStringiFunc(GL_EXTENSIONS, i);
2998 if (SDL_strcmp(thisext, extension) == 0) {
2999 return SDL_TRUE;
3000 }
3001 }
3002
3003 return SDL_FALSE;
3004 }
3005
3006 /* Try the old way with glGetString(GL_EXTENSIONS) ... */
3007
3008 extensions = (const char *) glGetStringFunc(GL_EXTENSIONS);
3009 if (!extensions) {
3010 return SDL_FALSE;
3011 }
3012 /*
3013 * It takes a bit of care to be fool-proof about parsing the OpenGL
3014 * extensions string. Don't be fooled by sub-strings, etc.
3015 */
3016
3017 start = extensions;
3018
3019 for (;;) {
3020 where = SDL_strstr(start, extension);
3021 if (!where)
3022 break;
3023
3024 terminator = where + SDL_strlen(extension);
3025 if (where == extensions || *(where - 1) == ' ')
3026 if (*terminator == ' ' || *terminator == '\0')
3027 return SDL_TRUE;
3028
3029 start = terminator;
3030 }
3031 return SDL_FALSE;
3032#else
3033 return SDL_FALSE;
3034#endif
3035}
#define SDL_strchr
#define SDL_getenv
#define SDL_strlen
#define SDL_strstr
SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char const char SDL_SCANF_FORMAT_STRING const char return SDL_ThreadFunction const char void return Uint32 return Uint32 void
unsigned char GLubyte
Definition: SDL_opengl.h:183
#define GL_VERSION
Definition: SDL_opengl.h:715
#define APIENTRY
Definition: SDL_opengl.h:139
unsigned int GLenum
Definition: SDL_opengl.h:176
unsigned int GLuint
Definition: SDL_opengl.h:185
#define GL_EXTENSIONS
Definition: SDL_opengl.h:716
GLuint start
Definition: SDL_opengl.h:1571
int GLint
Definition: SDL_opengl.h:182
const GLfloat * params
GLenum pname
void * SDL_GL_GetProcAddress(const char *proc)
Get the address of an OpenGL function.
Definition: SDL_video.c:2907
static SDL_INLINE SDL_bool isAtLeastGL3(const char *verstr)
Definition: SDL_video.c:2947
#define GL_NUM_EXTENSIONS

References APIENTRY, GL_EXTENSIONS, GL_NUM_EXTENSIONS, GL_VERSION, i, isAtLeastGL3(), SDL_FALSE, SDL_getenv, SDL_GL_GetProcAddress(), SDL_strchr, SDL_strcmp, SDL_strlen, SDL_strstr, SDL_TRUE, and void.

Referenced by SDL_GL_DeduceMaxSupportedESProfile().

◆ SDL_GL_GetAttribute()

int SDL_GL_GetAttribute ( SDL_GLattr  attr,
int *  value 
)

Get the actual value for an attribute from the current context.

Returns
0 on success, or -1 if the attribute could not be retrieved. The integer at value will be modified in either case.

Definition at line 3244 of file SDL_video.c.

3245{
3246#if SDL_VIDEO_OPENGL || SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2
3247 GLenum (APIENTRY *glGetErrorFunc) (void);
3248 GLenum attrib = 0;
3249 GLenum error = 0;
3250
3251 /*
3252 * Some queries in Core Profile desktop OpenGL 3+ contexts require
3253 * glGetFramebufferAttachmentParameteriv instead of glGetIntegerv. Note that
3254 * the enums we use for the former function don't exist in OpenGL ES 2, and
3255 * the function itself doesn't exist prior to OpenGL 3 and OpenGL ES 2.
3256 */
3257#if SDL_VIDEO_OPENGL
3258 const GLubyte *(APIENTRY *glGetStringFunc) (GLenum name);
3259 void (APIENTRY *glGetFramebufferAttachmentParameterivFunc) (GLenum target, GLenum attachment, GLenum pname, GLint* params);
3261 GLenum attachmentattrib = 0;
3262#endif
3263
3264 if (!value) {
3265 return SDL_InvalidParamError("value");
3266 }
3267
3268 /* Clear value in any case */
3269 *value = 0;
3270
3271 if (!_this) {
3272 return SDL_UninitializedVideo();
3273 }
3274
3275 switch (attr) {
3276 case SDL_GL_RED_SIZE:
3277#if SDL_VIDEO_OPENGL
3278 attachmentattrib = GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE;
3279#endif
3280 attrib = GL_RED_BITS;
3281 break;
3282 case SDL_GL_BLUE_SIZE:
3283#if SDL_VIDEO_OPENGL
3284 attachmentattrib = GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE;
3285#endif
3286 attrib = GL_BLUE_BITS;
3287 break;
3288 case SDL_GL_GREEN_SIZE:
3289#if SDL_VIDEO_OPENGL
3290 attachmentattrib = GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE;
3291#endif
3292 attrib = GL_GREEN_BITS;
3293 break;
3294 case SDL_GL_ALPHA_SIZE:
3295#if SDL_VIDEO_OPENGL
3296 attachmentattrib = GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE;
3297#endif
3298 attrib = GL_ALPHA_BITS;
3299 break;
3301#if SDL_VIDEO_OPENGL
3302 attrib = GL_DOUBLEBUFFER;
3303 break;
3304#else
3305 /* OpenGL ES 1.0 and above specifications have EGL_SINGLE_BUFFER */
3306 /* parameter which switches double buffer to single buffer. OpenGL ES */
3307 /* SDL driver must set proper value after initialization */
3309 return 0;
3310#endif
3311 case SDL_GL_DEPTH_SIZE:
3312#if SDL_VIDEO_OPENGL
3314 attachmentattrib = GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE;
3315#endif
3316 attrib = GL_DEPTH_BITS;
3317 break;
3319#if SDL_VIDEO_OPENGL
3321 attachmentattrib = GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE;
3322#endif
3323 attrib = GL_STENCIL_BITS;
3324 break;
3325#if SDL_VIDEO_OPENGL
3327 attrib = GL_ACCUM_RED_BITS;
3328 break;
3330 attrib = GL_ACCUM_GREEN_BITS;
3331 break;
3333 attrib = GL_ACCUM_BLUE_BITS;
3334 break;
3336 attrib = GL_ACCUM_ALPHA_BITS;
3337 break;
3338 case SDL_GL_STEREO:
3339 attrib = GL_STEREO;
3340 break;
3341#else
3346 case SDL_GL_STEREO:
3347 /* none of these are supported in OpenGL ES */
3348 *value = 0;
3349 return 0;
3350#endif
3352 attrib = GL_SAMPLE_BUFFERS;
3353 break;
3355 attrib = GL_SAMPLES;
3356 break;
3358#if SDL_VIDEO_OPENGL
3360#else
3362#endif
3363 break;
3364 case SDL_GL_BUFFER_SIZE:
3365 {
3366 int rsize = 0, gsize = 0, bsize = 0, asize = 0;
3367
3368 /* There doesn't seem to be a single flag in OpenGL for this! */
3369 if (SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &rsize) < 0) {
3370 return -1;
3371 }
3372 if (SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &gsize) < 0) {
3373 return -1;
3374 }
3375 if (SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &bsize) < 0) {
3376 return -1;
3377 }
3378 if (SDL_GL_GetAttribute(SDL_GL_ALPHA_SIZE, &asize) < 0) {
3379 return -1;
3380 }
3381
3382 *value = rsize + gsize + bsize + asize;
3383 return 0;
3384 }
3386 {
3387 /* FIXME: How do we get this information? */
3388 *value = (_this->gl_config.accelerated != 0);
3389 return 0;
3390 }
3392 {
3394 return 0;
3395 }
3397 {
3399 return 0;
3400 }
3402 {
3404 return 0;
3405 }
3406 case SDL_GL_CONTEXT_EGL:
3407 /* FIXME: SDL_GL_CONTEXT_EGL to be deprecated in SDL 2.1 */
3408 {
3410 *value = 1;
3411 }
3412 else {
3413 *value = 0;
3414 }
3415 return 0;
3416 }
3418 {
3420 return 0;
3421 }
3423 {
3425 return 0;
3426 }
3428 {
3430 return 0;
3431 }
3433 {
3435 return 0;
3436 }
3438 {
3440 return 0;
3441 }
3442 default:
3443 return SDL_SetError("Unknown OpenGL attribute");
3444 }
3445
3446#if SDL_VIDEO_OPENGL
3447 glGetStringFunc = SDL_GL_GetProcAddress("glGetString");
3448 if (!glGetStringFunc) {
3449 return -1;
3450 }
3451
3452 if (attachmentattrib && isAtLeastGL3((const char *) glGetStringFunc(GL_VERSION))) {
3453 glGetFramebufferAttachmentParameterivFunc = SDL_GL_GetProcAddress("glGetFramebufferAttachmentParameteriv");
3454
3455 if (glGetFramebufferAttachmentParameterivFunc) {
3456 glGetFramebufferAttachmentParameterivFunc(GL_FRAMEBUFFER, attachment, attachmentattrib, (GLint *) value);
3457 } else {
3458 return -1;
3459 }
3460 } else
3461#endif
3462 {
3463 void (APIENTRY *glGetIntegervFunc) (GLenum pname, GLint * params);
3464 glGetIntegervFunc = SDL_GL_GetProcAddress("glGetIntegerv");
3465 if (glGetIntegervFunc) {
3466 glGetIntegervFunc(attrib, (GLint *) value);
3467 } else {
3468 return -1;
3469 }
3470 }
3471
3472 glGetErrorFunc = SDL_GL_GetProcAddress("glGetError");
3473 if (!glGetErrorFunc) {
3474 return -1;
3475 }
3476
3477 error = glGetErrorFunc();
3478 if (error != GL_NO_ERROR) {
3479 if (error == GL_INVALID_ENUM) {
3480 return SDL_SetError("OpenGL error: GL_INVALID_ENUM");
3481 } else if (error == GL_INVALID_VALUE) {
3482 return SDL_SetError("OpenGL error: GL_INVALID_VALUE");
3483 }
3484 return SDL_SetError("OpenGL error: %08X", error);
3485 }
3486 return 0;
3487#else
3488 return SDL_Unsupported();
3489#endif /* SDL_VIDEO_OPENGL */
3490}
#define GL_DOUBLEBUFFER
Definition: SDL_opengl.h:521
#define GL_INVALID_VALUE
Definition: SDL_opengl.h:721
#define GL_STENCIL_BITS
Definition: SDL_opengl.h:474
#define GL_SAMPLES
Definition: SDL_opengl.h:1840
#define GL_GREEN_BITS
Definition: SDL_opengl.h:514
#define GL_BACK_LEFT
Definition: SDL_opengl.h:499
#define GL_STENCIL
Definition: SDL_opengl.h:526
#define GL_ACCUM_ALPHA_BITS
Definition: SDL_opengl.h:383
#define GL_DEPTH_BITS
Definition: SDL_opengl.h:328
#define GL_SAMPLE_BUFFERS
Definition: SDL_opengl.h:1839
#define GL_NO_ERROR
Definition: SDL_opengl.h:719
#define GL_BLUE_BITS
Definition: SDL_opengl.h:515
#define GL_DEPTH
Definition: SDL_opengl.h:525
#define GL_ALPHA_BITS
Definition: SDL_opengl.h:512
#define GL_ACCUM_GREEN_BITS
Definition: SDL_opengl.h:381
#define GL_ACCUM_BLUE_BITS
Definition: SDL_opengl.h:382
#define GL_STEREO
Definition: SDL_opengl.h:522
#define GL_INVALID_ENUM
Definition: SDL_opengl.h:720
#define GL_RED_BITS
Definition: SDL_opengl.h:513
#define GL_ACCUM_RED_BITS
Definition: SDL_opengl.h:380
#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE
#define GL_FRAMEBUFFER
#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE
GLenum attachment
#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE
#define GL_CONTEXT_RELEASE_BEHAVIOR
GLenum target
#define GL_CONTEXT_RELEASE_BEHAVIOR_KHR
Definition: SDL_video.c:51
int SDL_GL_GetAttribute(SDL_GLattr attr, int *value)
Get the actual value for an attribute from the current context.
Definition: SDL_video.c:3244
@ SDL_GL_FRAMEBUFFER_SRGB_CAPABLE
Definition: SDL_video.h:223
@ SDL_GL_CONTEXT_RELEASE_BEHAVIOR
Definition: SDL_video.h:224
@ SDL_GL_DOUBLEBUFFER
Definition: SDL_video.h:205
@ SDL_GL_STENCIL_SIZE
Definition: SDL_video.h:207
@ SDL_GL_CONTEXT_MAJOR_VERSION
Definition: SDL_video.h:217
@ SDL_GL_CONTEXT_EGL
Definition: SDL_video.h:219
@ SDL_GL_ACCUM_ALPHA_SIZE
Definition: SDL_video.h:211
@ SDL_GL_MULTISAMPLESAMPLES
Definition: SDL_video.h:214
@ SDL_GL_CONTEXT_MINOR_VERSION
Definition: SDL_video.h:218
@ SDL_GL_STEREO
Definition: SDL_video.h:212
@ SDL_GL_MULTISAMPLEBUFFERS
Definition: SDL_video.h:213
@ SDL_GL_ACCUM_GREEN_SIZE
Definition: SDL_video.h:209
@ SDL_GL_BLUE_SIZE
Definition: SDL_video.h:202
@ SDL_GL_SHARE_WITH_CURRENT_CONTEXT
Definition: SDL_video.h:222
@ SDL_GL_RETAINED_BACKING
Definition: SDL_video.h:216
@ SDL_GL_RED_SIZE
Definition: SDL_video.h:200
@ SDL_GL_ALPHA_SIZE
Definition: SDL_video.h:203
@ SDL_GL_BUFFER_SIZE
Definition: SDL_video.h:204
@ SDL_GL_ACCELERATED_VISUAL
Definition: SDL_video.h:215
@ SDL_GL_ACCUM_BLUE_SIZE
Definition: SDL_video.h:210
@ SDL_GL_DEPTH_SIZE
Definition: SDL_video.h:206
@ SDL_GL_ACCUM_RED_SIZE
Definition: SDL_video.h:208
@ SDL_GL_CONTEXT_FLAGS
Definition: SDL_video.h:220
@ SDL_GL_CONTEXT_PROFILE_MASK
Definition: SDL_video.h:221
@ SDL_GL_CONTEXT_NO_ERROR
Definition: SDL_video.h:226
@ SDL_GL_GREEN_SIZE
Definition: SDL_video.h:201
@ SDL_GL_CONTEXT_PROFILE_ES
Definition: SDL_video.h:233
int framebuffer_srgb_capable
Definition: SDL_sysvideo.h:350
struct SDL_VideoDevice::@262 gl_config
int share_with_current_context
Definition: SDL_sysvideo.h:347

References _this, SDL_VideoDevice::accelerated, APIENTRY, SDL_VideoDevice::double_buffer, SDL_VideoDevice::flags, SDL_VideoDevice::framebuffer_srgb_capable, GL_ACCUM_ALPHA_BITS, GL_ACCUM_BLUE_BITS, GL_ACCUM_GREEN_BITS, GL_ACCUM_RED_BITS, GL_ALPHA_BITS, GL_BACK_LEFT, GL_BLUE_BITS, SDL_VideoDevice::gl_config, GL_CONTEXT_RELEASE_BEHAVIOR, GL_CONTEXT_RELEASE_BEHAVIOR_KHR, GL_DEPTH, GL_DEPTH_BITS, GL_DOUBLEBUFFER, GL_FRAMEBUFFER, GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE, GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE, GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE, GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, GL_GREEN_BITS, GL_INVALID_ENUM, GL_INVALID_VALUE, GL_NO_ERROR, GL_RED_BITS, GL_SAMPLE_BUFFERS, GL_SAMPLES, GL_STENCIL, GL_STENCIL_BITS, GL_STEREO, GL_VERSION, isAtLeastGL3(), SDL_VideoDevice::major_version, SDL_VideoDevice::minor_version, SDL_VideoDevice::no_error, SDL_VideoDevice::profile_mask, SDL_VideoDevice::retained_backing, SDL_GL_ACCELERATED_VISUAL, SDL_GL_ACCUM_ALPHA_SIZE, SDL_GL_ACCUM_BLUE_SIZE, SDL_GL_ACCUM_GREEN_SIZE, SDL_GL_ACCUM_RED_SIZE, SDL_GL_ALPHA_SIZE, SDL_GL_BLUE_SIZE, SDL_GL_BUFFER_SIZE, SDL_GL_CONTEXT_EGL, SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_MAJOR_VERSION, SDL_GL_CONTEXT_MINOR_VERSION, SDL_GL_CONTEXT_NO_ERROR, SDL_GL_CONTEXT_PROFILE_ES, SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_RELEASE_BEHAVIOR, SDL_GL_DEPTH_SIZE, SDL_GL_DOUBLEBUFFER, SDL_GL_FRAMEBUFFER_SRGB_CAPABLE, SDL_GL_GetAttribute(), SDL_GL_GetProcAddress(), SDL_GL_GREEN_SIZE, SDL_GL_MULTISAMPLEBUFFERS, SDL_GL_MULTISAMPLESAMPLES, SDL_GL_RED_SIZE, SDL_GL_RETAINED_BACKING, SDL_GL_SHARE_WITH_CURRENT_CONTEXT, SDL_GL_STENCIL_SIZE, SDL_GL_STEREO, SDL_InvalidParamError, SDL_SetError, SDL_UninitializedVideo(), SDL_Unsupported, SDL_VideoDevice::share_with_current_context, and void.

Referenced by SDL_GL_GetAttribute().

◆ SDL_GL_GetCurrentContext()

SDL_GLContext SDL_GL_GetCurrentContext ( void  )

Get the currently active OpenGL context.

Definition at line 3557 of file SDL_video.c.

3558{
3559 if (!_this) {
3561 return NULL;
3562 }
3564}
#define SDL_TLSGet

References _this, SDL_VideoDevice::current_glctx_tls, NULL, SDL_TLSGet, and SDL_UninitializedVideo().

Referenced by SDL_GL_DeleteContext(), SDL_GL_GetSwapInterval(), SDL_GL_MakeCurrent(), and SDL_GL_SetSwapInterval().

◆ SDL_GL_GetCurrentWindow()

SDL_Window * SDL_GL_GetCurrentWindow ( void  )

Get the currently active OpenGL window.

Definition at line 3547 of file SDL_video.c.

3548{
3549 if (!_this) {
3551 return NULL;
3552 }
3554}

References _this, SDL_VideoDevice::current_glwin_tls, NULL, SDL_TLSGet, and SDL_UninitializedVideo().

Referenced by SDL_GL_MakeCurrent(), and SDL_GL_SwapWindow().

◆ SDL_GL_GetDrawableSize()

void SDL_GL_GetDrawableSize ( SDL_Window window,
int *  w,
int *  h 
)

Get the size of a window's underlying drawable in pixels (for use with glViewport).

Parameters
windowWindow from which the drawable size should be queried
wPointer to variable for storing the width in pixels, may be NULL
hPointer to variable for storing the height in pixels, may be NULL

This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI drawable, i.e. the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a platform with high-DPI support (Apple calls this "Retina"), and not disabled by the SDL_HINT_VIDEO_HIGHDPI_DISABLED hint.

See also
SDL_GetWindowSize()
SDL_CreateWindow()

Definition at line 3566 of file SDL_video.c.

3567{
3569
3572 } else {
3574 }
3575}
void SDL_GetWindowSize(SDL_Window *window, int *w, int *h)
Get the size of a window's client area.
Definition: SDL_video.c:2034
void(* GL_GetDrawableSize)(_THIS, SDL_Window *window, int *w, int *h)
Definition: SDL_sysvideo.h:260

References _this, CHECK_WINDOW_MAGIC, SDL_VideoDevice::GL_GetDrawableSize, and SDL_GetWindowSize().

◆ SDL_GL_GetProcAddress()

void * SDL_GL_GetProcAddress ( const char *  proc)

Get the address of an OpenGL function.

Definition at line 2907 of file SDL_video.c.

2908{
2909 void *func;
2910
2911 if (!_this) {
2913 return NULL;
2914 }
2915 func = NULL;
2916 if (_this->GL_GetProcAddress) {
2919 } else {
2920 SDL_SetError("No GL driver has been loaded");
2921 }
2922 } else {
2923 SDL_SetError("No dynamic GL support in current SDL video driver (%s)", _this->name);
2924 }
2925 return func;
2926}
GLenum func
void *(* GL_GetProcAddress)(_THIS, const char *proc)
Definition: SDL_sysvideo.h:256

References _this, SDL_VideoDevice::driver_loaded, SDL_VideoDevice::gl_config, SDL_VideoDevice::GL_GetProcAddress, SDL_VideoDevice::name, NULL, SDL_SetError, and SDL_UninitializedVideo().

Referenced by SDL_GL_ExtensionSupported(), SDL_GL_GetAttribute(), and ShouldUseTextureFramebuffer().

◆ SDL_GL_GetSwapInterval()

int SDL_GL_GetSwapInterval ( void  )

Get the swap interval for the current OpenGL context.

Returns
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. If the system can't determine the swap interval, or there isn't a valid current context, this will return 0 as a safe default.
See also
SDL_GL_SetSwapInterval()

Definition at line 3592 of file SDL_video.c.

3593{
3594 if (!_this) {
3595 return 0;
3596 } else if (SDL_GL_GetCurrentContext() == NULL) {
3597 return 0;
3598 } else if (_this->GL_GetSwapInterval) {
3600 } else {
3601 return 0;
3602 }
3603}
int(* GL_GetSwapInterval)(_THIS)
Definition: SDL_sysvideo.h:262

References _this, SDL_VideoDevice::GL_GetSwapInterval, NULL, and SDL_GL_GetCurrentContext().

◆ SDL_GL_LoadLibrary()

int SDL_GL_LoadLibrary ( const char *  path)

Dynamically load an OpenGL library.

Parameters
pathThe platform dependent OpenGL library name, or NULL to open the default OpenGL library.
Returns
0 on success, or -1 if the library couldn't be loaded.

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.

Note
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().
See also
SDL_GL_GetProcAddress()
SDL_GL_UnloadLibrary()

Definition at line 2878 of file SDL_video.c.

2879{
2880 int retval;
2881
2882 if (!_this) {
2883 return SDL_UninitializedVideo();
2884 }
2886 if (path && SDL_strcmp(path, _this->gl_config.driver_path) != 0) {
2887 return SDL_SetError("OpenGL library already loaded");
2888 }
2889 retval = 0;
2890 } else {
2891 if (!_this->GL_LoadLibrary) {
2892 return SDL_SetError("No dynamic GL support in current SDL video driver (%s)", _this->name);
2893 }
2895 }
2896 if (retval == 0) {
2898 } else {
2899 if (_this->GL_UnloadLibrary) {
2901 }
2902 }
2903 return (retval);
2904}
GLsizei const GLchar *const * path
char driver_path[256]
Definition: SDL_sysvideo.h:354
void(* GL_UnloadLibrary)(_THIS)
Definition: SDL_sysvideo.h:257
int(* GL_LoadLibrary)(_THIS, const char *path)
Definition: SDL_sysvideo.h:255

References _this, SDL_VideoDevice::driver_loaded, SDL_VideoDevice::driver_path, SDL_VideoDevice::gl_config, SDL_VideoDevice::GL_LoadLibrary, SDL_VideoDevice::GL_UnloadLibrary, SDL_VideoDevice::name, retval, SDL_SetError, SDL_strcmp, and SDL_UninitializedVideo().

Referenced by SDL_CreateWindow(), and SDL_RecreateWindow().

◆ SDL_GL_MakeCurrent()

int SDL_GL_MakeCurrent ( SDL_Window window,
SDL_GLContext  context 
)

Set up an OpenGL context for rendering into an OpenGL window.

Note
The context must have been created with a compatible window.

Definition at line 3516 of file SDL_video.c.

3517{
3518 int retval;
3519
3522 /* We're already current. */
3523 return 0;
3524 }
3525
3526 if (!ctx) {
3527 window = NULL;
3528 } else {
3530
3531 if (!(window->flags & SDL_WINDOW_OPENGL)) {
3532 return SDL_SetError("The specified window isn't an OpenGL window");
3533 }
3534 }
3535
3537 if (retval == 0) {
3542 }
3543 return retval;
3544}
SDL_Window * SDL_GL_GetCurrentWindow(void)
Get the currently active OpenGL window.
Definition: SDL_video.c:3547
int(* GL_MakeCurrent)(_THIS, SDL_Window *window, SDL_GLContext context)
Definition: SDL_sysvideo.h:259

References _this, CHECK_WINDOW_MAGIC, SDL_VideoDevice::current_glctx, SDL_VideoDevice::current_glctx_tls, SDL_VideoDevice::current_glwin, SDL_VideoDevice::current_glwin_tls, SDL_VideoDevice::GL_MakeCurrent, NULL, retval, SDL_GL_GetCurrentContext(), SDL_GL_GetCurrentWindow(), SDL_SetError, SDL_TLSSet, and SDL_WINDOW_OPENGL.

Referenced by SDL_DestroyWindow(), and SDL_GL_DeleteContext().

◆ SDL_GL_ResetAttributes()

void SDL_GL_ResetAttributes ( void  )

Reset all previously set OpenGL context attributes to their default values.

Definition at line 3069 of file SDL_video.c.

3070{
3071 if (!_this) {
3072 return;
3073 }
3074
3087 _this->gl_config.stereo = 0;
3091 _this->gl_config.accelerated = -1; /* accelerated or not, both are fine */
3092
3097 } else {
3098#if SDL_VIDEO_OPENGL
3102#elif SDL_VIDEO_OPENGL_ES2
3106#elif SDL_VIDEO_OPENGL_ES
3110#endif
3111 }
3112
3113 _this->gl_config.flags = 0;
3118
3120}
@ SDL_GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH
Definition: SDL_video.h:247
@ SDL_GL_CONTEXT_RESET_NO_NOTIFICATION
Definition: SDL_video.h:252
void(* GL_DefaultProfileConfig)(_THIS, int *mask, int *major, int *minor)
Definition: SDL_sysvideo.h:265

References _this, SDL_VideoDevice::accelerated, SDL_VideoDevice::accum_alpha_size, SDL_VideoDevice::accum_blue_size, SDL_VideoDevice::accum_green_size, SDL_VideoDevice::accum_red_size, SDL_VideoDevice::alpha_size, SDL_VideoDevice::blue_size, SDL_VideoDevice::buffer_size, SDL_VideoDevice::depth_size, SDL_VideoDevice::double_buffer, SDL_VideoDevice::flags, SDL_VideoDevice::framebuffer_srgb_capable, SDL_VideoDevice::gl_config, SDL_VideoDevice::GL_DefaultProfileConfig, SDL_VideoDevice::green_size, SDL_VideoDevice::major_version, SDL_VideoDevice::minor_version, SDL_VideoDevice::multisamplebuffers, SDL_VideoDevice::multisamplesamples, SDL_VideoDevice::no_error, SDL_VideoDevice::profile_mask, SDL_VideoDevice::red_size, SDL_VideoDevice::release_behavior, SDL_VideoDevice::reset_notification, SDL_VideoDevice::retained_backing, SDL_GL_CONTEXT_PROFILE_ES, SDL_GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH, SDL_GL_CONTEXT_RESET_NO_NOTIFICATION, SDL_VideoDevice::share_with_current_context, SDL_VideoDevice::stencil_size, and SDL_VideoDevice::stereo.

Referenced by SDL_VideoInit().

◆ SDL_GL_SetAttribute()

int SDL_GL_SetAttribute ( SDL_GLattr  attr,
int  value 
)

Set an OpenGL window attribute before window creation.

Returns
0 on success, or -1 if the attribute could not be set.

Definition at line 3123 of file SDL_video.c.

3124{
3125#if SDL_VIDEO_OPENGL || SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2
3126 int retval;
3127
3128 if (!_this) {
3129 return SDL_UninitializedVideo();
3130 }
3131 retval = 0;
3132 switch (attr) {
3133 case SDL_GL_RED_SIZE:
3135 break;
3136 case SDL_GL_GREEN_SIZE:
3138 break;
3139 case SDL_GL_BLUE_SIZE:
3141 break;
3142 case SDL_GL_ALPHA_SIZE:
3144 break;
3147 break;
3148 case SDL_GL_BUFFER_SIZE:
3150 break;
3151 case SDL_GL_DEPTH_SIZE:
3153 break;
3156 break;
3159 break;
3162 break;
3165 break;
3168 break;
3169 case SDL_GL_STEREO:
3171 break;
3174 break;
3177 break;
3180 break;
3183 break;
3186 break;
3189 break;
3190 case SDL_GL_CONTEXT_EGL:
3191 /* FIXME: SDL_GL_CONTEXT_EGL to be deprecated in SDL 2.1 */
3192 if (value != 0) {
3194 } else {
3196 };
3197 break;
3203 retval = SDL_SetError("Unknown OpenGL context flag %d", value);
3204 break;
3205 }
3207 break;
3209 if (value != 0 &&
3213 retval = SDL_SetError("Unknown OpenGL context profile %d", value);
3214 break;
3215 }
3217 break;
3220 break;
3223 break;
3226 break;
3229 break;
3232 break;
3233 default:
3234 retval = SDL_SetError("Unknown OpenGL attribute");
3235 break;
3236 }
3237 return retval;
3238#else
3239 return SDL_Unsupported();
3240#endif /* SDL_VIDEO_OPENGL */
3241}
int SDL_GL_SetAttribute(SDL_GLattr attr, int value)
Set an OpenGL window attribute before window creation.
Definition: SDL_video.c:3123
@ SDL_GL_CONTEXT_RESET_NOTIFICATION
Definition: SDL_video.h:225
@ SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG
Definition: SDL_video.h:239
@ SDL_GL_CONTEXT_RESET_ISOLATION_FLAG
Definition: SDL_video.h:241
@ SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG
Definition: SDL_video.h:240
@ SDL_GL_CONTEXT_DEBUG_FLAG
Definition: SDL_video.h:238
@ SDL_GL_CONTEXT_PROFILE_COMPATIBILITY
Definition: SDL_video.h:232
@ SDL_GL_CONTEXT_PROFILE_CORE
Definition: SDL_video.h:231

References _this, SDL_VideoDevice::accelerated, SDL_VideoDevice::accum_alpha_size, SDL_VideoDevice::accum_blue_size, SDL_VideoDevice::accum_green_size, SDL_VideoDevice::accum_red_size, SDL_VideoDevice::alpha_size, SDL_VideoDevice::blue_size, SDL_VideoDevice::buffer_size, SDL_VideoDevice::depth_size, SDL_VideoDevice::double_buffer, SDL_VideoDevice::flags, SDL_VideoDevice::framebuffer_srgb_capable, SDL_VideoDevice::gl_config, SDL_VideoDevice::green_size, SDL_VideoDevice::major_version, SDL_VideoDevice::minor_version, SDL_VideoDevice::multisamplebuffers, SDL_VideoDevice::multisamplesamples, SDL_VideoDevice::no_error, SDL_VideoDevice::profile_mask, SDL_VideoDevice::red_size, SDL_VideoDevice::release_behavior, SDL_VideoDevice::reset_notification, SDL_VideoDevice::retained_backing, retval, SDL_GL_ACCELERATED_VISUAL, SDL_GL_ACCUM_ALPHA_SIZE, SDL_GL_ACCUM_BLUE_SIZE, SDL_GL_ACCUM_GREEN_SIZE, SDL_GL_ACCUM_RED_SIZE, SDL_GL_ALPHA_SIZE, SDL_GL_BLUE_SIZE, SDL_GL_BUFFER_SIZE, SDL_GL_CONTEXT_DEBUG_FLAG, SDL_GL_CONTEXT_EGL, SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG, SDL_GL_CONTEXT_MAJOR_VERSION, SDL_GL_CONTEXT_MINOR_VERSION, SDL_GL_CONTEXT_NO_ERROR, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY, SDL_GL_CONTEXT_PROFILE_CORE, SDL_GL_CONTEXT_PROFILE_ES, SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_RELEASE_BEHAVIOR, SDL_GL_CONTEXT_RESET_ISOLATION_FLAG, SDL_GL_CONTEXT_RESET_NOTIFICATION, SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG, SDL_GL_DEPTH_SIZE, SDL_GL_DOUBLEBUFFER, SDL_GL_FRAMEBUFFER_SRGB_CAPABLE, SDL_GL_GREEN_SIZE, SDL_GL_MULTISAMPLEBUFFERS, SDL_GL_MULTISAMPLESAMPLES, SDL_GL_RED_SIZE, SDL_GL_RETAINED_BACKING, SDL_GL_SetAttribute(), SDL_GL_SHARE_WITH_CURRENT_CONTEXT, SDL_GL_STENCIL_SIZE, SDL_GL_STEREO, SDL_SetError, SDL_UninitializedVideo(), SDL_Unsupported, SDL_VideoDevice::share_with_current_context, SDL_VideoDevice::stencil_size, and SDL_VideoDevice::stereo.

Referenced by SDL_GL_SetAttribute().

◆ SDL_GL_SetSwapInterval()

int SDL_GL_SetSwapInterval ( int  interval)

Set the swap interval for the current OpenGL context.

Parameters
interval0 for immediate updates, 1 for updates synchronized with the vertical retrace. If the system supports it, you may specify -1 to allow late swaps to happen immediately instead of waiting for the next retrace.
Returns
0 on success, or -1 if setting the swap interval is not supported.
See also
SDL_GL_GetSwapInterval()

Definition at line 3578 of file SDL_video.c.

3579{
3580 if (!_this) {
3581 return SDL_UninitializedVideo();
3582 } else if (SDL_GL_GetCurrentContext() == NULL) {
3583 return SDL_SetError("No OpenGL context has been made current");
3584 } else if (_this->GL_SetSwapInterval) {
3585 return _this->GL_SetSwapInterval(_this, interval);
3586 } else {
3587 return SDL_SetError("Setting the swap interval is not supported");
3588 }
3589}
int(* GL_SetSwapInterval)(_THIS, int interval)
Definition: SDL_sysvideo.h:261

References _this, SDL_VideoDevice::GL_SetSwapInterval, NULL, SDL_GL_GetCurrentContext(), SDL_SetError, and SDL_UninitializedVideo().

◆ SDL_GL_SwapWindow()

void SDL_GL_SwapWindow ( SDL_Window window)

Swap the OpenGL buffers for a window, if double-buffering is supported.

Definition at line 3606 of file SDL_video.c.

3607{
3609
3610 if (!(window->flags & SDL_WINDOW_OPENGL)) {
3611 SDL_SetError("The specified window isn't an OpenGL window");
3612 return;
3613 }
3614
3616 SDL_SetError("The specified window has not been made current");
3617 return;
3618 }
3619
3621}
int(* GL_SwapWindow)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:263

References _this, CHECK_WINDOW_MAGIC, SDL_VideoDevice::GL_SwapWindow, SDL_GL_GetCurrentWindow(), SDL_SetError, and SDL_WINDOW_OPENGL.

◆ SDL_GL_UnloadLibrary()

void SDL_GL_UnloadLibrary ( void  )

Unload the OpenGL library previously loaded by SDL_GL_LoadLibrary().

See also
SDL_GL_LoadLibrary()

Definition at line 2929 of file SDL_video.c.

2930{
2931 if (!_this) {
2933 return;
2934 }
2935 if (_this->gl_config.driver_loaded > 0) {
2936 if (--_this->gl_config.driver_loaded > 0) {
2937 return;
2938 }
2939 if (_this->GL_UnloadLibrary) {
2941 }
2942 }
2943}

References _this, SDL_VideoDevice::driver_loaded, SDL_VideoDevice::gl_config, SDL_VideoDevice::GL_UnloadLibrary, and SDL_UninitializedVideo().

Referenced by SDL_DestroyWindow(), and SDL_RecreateWindow().

◆ SDL_HasScreenKeyboardSupport()

SDL_bool SDL_HasScreenKeyboardSupport ( void  )

Returns whether the platform has some screen keyboard support.

Returns
SDL_TRUE if some keyboard support is available else SDL_FALSE.
Note
Not all screen keyboard functions are supported on all platforms.
See also
SDL_IsScreenKeyboardShown()

Definition at line 3811 of file SDL_video.c.

3812{
3815 }
3816 return SDL_FALSE;
3817}
SDL_bool(* HasScreenKeyboardSupport)(_THIS)
Definition: SDL_sysvideo.h:292

References _this, SDL_VideoDevice::HasScreenKeyboardSupport, and SDL_FALSE.

Referenced by SDL_VideoInit().

◆ SDL_HasWindows()

SDL_bool SDL_HasWindows ( void  )

Definition at line 1711 of file SDL_video.c.

1712{
1713 return (_this && _this->windows != NULL);
1714}

References _this, NULL, and SDL_VideoDevice::windows.

Referenced by SDL_PrivateJoystickShouldIgnoreEvent().

◆ SDL_HideWindow()

void SDL_HideWindow ( SDL_Window window)

Hide a window.

See also
SDL_ShowWindow()

Definition at line 2168 of file SDL_video.c.

2169{
2171
2172 if (!(window->flags & SDL_WINDOW_SHOWN)) {
2173 return;
2174 }
2175
2176 window->is_hiding = SDL_TRUE;
2178
2179 if (_this->HideWindow) {
2181 }
2182 window->is_hiding = SDL_FALSE;
2184}
@ SDL_WINDOW_SHOWN
Definition: SDL_video.h:102
@ SDL_WINDOWEVENT_HIDDEN
Definition: SDL_video.h:150
int SDL_SendWindowEvent(SDL_Window *window, Uint8 windowevent, int data1, int data2)
void(* HideWindow)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:224

References _this, CHECK_WINDOW_MAGIC, SDL_VideoDevice::HideWindow, SDL_FALSE, SDL_SendWindowEvent(), SDL_TRUE, SDL_UpdateFullscreenMode(), SDL_WINDOW_SHOWN, and SDL_WINDOWEVENT_HIDDEN.

Referenced by SDL_DestroyWindow(), and SDL_RecreateWindow().

◆ SDL_IsScreenKeyboardShown()

SDL_bool SDL_IsScreenKeyboardShown ( SDL_Window window)

Returns whether the screen keyboard is shown for given window.

Parameters
windowThe window for which screen keyboard should be queried.
Returns
SDL_TRUE if screen keyboard is shown else SDL_FALSE.
See also
SDL_HasScreenKeyboardSupport()

Definition at line 3820 of file SDL_video.c.

3821{
3824 }
3825 return SDL_FALSE;
3826}
SDL_bool(* IsScreenKeyboardShown)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:295

References _this, SDL_VideoDevice::IsScreenKeyboardShown, and SDL_FALSE.

◆ SDL_IsScreenSaverEnabled()

SDL_bool SDL_IsScreenSaverEnabled ( void  )

Returns whether the screensaver is currently enabled (default off).

See also
SDL_EnableScreenSaver()
SDL_DisableScreenSaver()

Definition at line 2789 of file SDL_video.c.

2790{
2791 if (!_this) {
2792 return SDL_TRUE;
2793 }
2795}

References _this, SDL_FALSE, SDL_TRUE, and SDL_VideoDevice::suspend_screensaver.

◆ SDL_IsTextInputActive()

SDL_bool SDL_IsTextInputActive ( void  )

Return whether or not Unicode text input events are enabled.

See also
SDL_StartTextInput()
SDL_StopTextInput()

Definition at line 3776 of file SDL_video.c.

3777{
3779}
@ SDL_TEXTINPUT
Definition: SDL_events.h:99

References SDL_ENABLE, SDL_GetEventState, and SDL_TEXTINPUT.

◆ SDL_MaximizeWindow()

void SDL_MaximizeWindow ( SDL_Window window)

Make a window as large as possible.

See also
SDL_RestoreWindow()

Definition at line 2200 of file SDL_video.c.

2201{
2203
2204 if (window->flags & SDL_WINDOW_MAXIMIZED) {
2205 return;
2206 }
2207
2208 /* !!! FIXME: should this check if the window is resizable? */
2209
2210 if (_this->MaximizeWindow) {
2212 }
2213}
void(* MaximizeWindow)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:226

References _this, CHECK_WINDOW_MAGIC, SDL_VideoDevice::MaximizeWindow, and SDL_WINDOW_MAXIMIZED.

Referenced by SDL_FinishWindowCreation().

◆ SDL_MessageboxValidForDriver()

static SDL_bool SDL_MessageboxValidForDriver ( const SDL_MessageBoxData messageboxdata,
SDL_SYSWM_TYPE  drivertype 
)
static

Definition at line 3849 of file SDL_video.c.

3850{
3851 SDL_SysWMinfo info;
3852 SDL_Window *window = messageboxdata->window;
3853
3854 if (!window) {
3855 return SDL_TRUE;
3856 }
3857
3858 SDL_VERSION(&info.version);
3859 if (!SDL_GetWindowWMInfo(window, &info)) {
3860 return SDL_TRUE;
3861 } else {
3862 return (info.subsystem == drivertype);
3863 }
3864}
SDL_bool SDL_GetWindowWMInfo(SDL_Window *window, struct SDL_SysWMinfo *info)
This function allows access to driver-dependent window information.
Definition: SDL_video.c:3737
SDL_Window * window

References SDL_GetWindowWMInfo(), SDL_TRUE, SDL_VERSION, SDL_SysWMinfo::subsystem, SDL_SysWMinfo::version, and SDL_MessageBoxData::window.

Referenced by SDL_ShowMessageBox().

◆ SDL_MinimizeWindow()

void SDL_MinimizeWindow ( SDL_Window window)

Minimize a window to an iconic representation.

See also
SDL_RestoreWindow()

Definition at line 2225 of file SDL_video.c.

2226{
2228
2229 if (window->flags & SDL_WINDOW_MINIMIZED) {
2230 return;
2231 }
2232
2233 if (!CanMinimizeWindow(window)) {
2234 return;
2235 }
2236
2238
2239 if (_this->MinimizeWindow) {
2241 }
2242}
static SDL_bool CanMinimizeWindow(SDL_Window *window)
Definition: SDL_video.c:2216

References _this, CanMinimizeWindow(), CHECK_WINDOW_MAGIC, SDL_VideoDevice::MinimizeWindow, SDL_FALSE, SDL_UpdateFullscreenMode(), and SDL_WINDOW_MINIMIZED.

Referenced by SDL_FinishWindowCreation(), SDL_OnWindowFocusLost(), and SDL_UpdateFullscreenMode().

◆ SDL_OnApplicationDidBecomeActive()

void SDL_OnApplicationDidBecomeActive ( void  )

Definition at line 4061 of file SDL_video.c.

4062{
4064
4065 if (_this) {
4067 for (window = _this->windows; window != NULL; window = window->next) {
4070 }
4071 }
4072}
int SDL_SendAppEvent(SDL_EventType eventType)
Definition: SDL_events.c:965
@ SDL_APP_DIDENTERFOREGROUND
Definition: SDL_events.h:83
@ SDL_WINDOWEVENT_FOCUS_GAINED
Definition: SDL_video.h:165
@ SDL_WINDOWEVENT_RESTORED
Definition: SDL_video.h:161

References _this, NULL, SDL_APP_DIDENTERFOREGROUND, SDL_SendAppEvent(), SDL_SendWindowEvent(), SDL_WINDOWEVENT_FOCUS_GAINED, SDL_WINDOWEVENT_RESTORED, and SDL_VideoDevice::windows.

Referenced by SDL_SendPendingSignalEvents().

◆ SDL_OnApplicationDidEnterBackground()

void SDL_OnApplicationDidEnterBackground ( void  )

Definition at line 4051 of file SDL_video.c.

4052{
4054}
@ SDL_APP_DIDENTERBACKGROUND
Definition: SDL_events.h:75

References SDL_APP_DIDENTERBACKGROUND, and SDL_SendAppEvent().

◆ SDL_OnApplicationDidReceiveMemoryWarning()

void SDL_OnApplicationDidReceiveMemoryWarning ( void  )

Definition at line 4034 of file SDL_video.c.

4035{
4037}
@ SDL_APP_LOWMEMORY
Definition: SDL_events.h:67

References SDL_APP_LOWMEMORY, and SDL_SendAppEvent().

◆ SDL_OnApplicationWillEnterForeground()

void SDL_OnApplicationWillEnterForeground ( void  )

Definition at line 4056 of file SDL_video.c.

4057{
4059}
@ SDL_APP_WILLENTERFOREGROUND
Definition: SDL_events.h:79

References SDL_APP_WILLENTERFOREGROUND, and SDL_SendAppEvent().

◆ SDL_OnApplicationWillResignActive()

void SDL_OnApplicationWillResignActive ( void  )

◆ SDL_OnApplicationWillTerminate()

void SDL_OnApplicationWillTerminate ( void  )

Definition at line 4029 of file SDL_video.c.

4030{
4032}
@ SDL_APP_TERMINATING
Definition: SDL_events.h:63

References SDL_APP_TERMINATING, and SDL_SendAppEvent().

◆ SDL_OnWindowEnter()

void SDL_OnWindowEnter ( SDL_Window window)

Definition at line 2623 of file SDL_video.c.

2624{
2625 if (_this->OnWindowEnter) {
2627 }
2628}
void(* OnWindowEnter)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:239

References _this, and SDL_VideoDevice::OnWindowEnter.

Referenced by SDL_SendWindowEvent().

◆ SDL_OnWindowFocusGained()

void SDL_OnWindowFocusGained ( SDL_Window window)

Definition at line 2636 of file SDL_video.c.

2637{
2638 SDL_Mouse *mouse = SDL_GetMouse();
2639
2640 if (window->gamma && _this->SetWindowGammaRamp) {
2642 }
2643
2644 if (mouse && mouse->relative_mode) {
2647 }
2648
2650}
#define SDL_WarpMouseInWindow
SDL_Mouse * SDL_GetMouse(void)
Definition: SDL_mouse.c:178
void SDL_UpdateWindowGrab(SDL_Window *window)
Definition: SDL_video.c:2520
SDL_bool relative_mode
Definition: SDL_mouse_c.h:87
int(* SetWindowGammaRamp)(_THIS, SDL_Window *window, const Uint16 *ramp)
Definition: SDL_sysvideo.h:232

References _this, SDL_Mouse::relative_mode, SDL_GetMouse(), SDL_SetMouseFocus(), SDL_UpdateWindowGrab(), SDL_WarpMouseInWindow, and SDL_VideoDevice::SetWindowGammaRamp.

Referenced by SDL_SendWindowEvent().

◆ SDL_OnWindowFocusLost()

void SDL_OnWindowFocusLost ( SDL_Window window)

Definition at line 2680 of file SDL_video.c.

2681{
2682 if (window->gamma && _this->SetWindowGammaRamp) {
2683 _this->SetWindowGammaRamp(_this, window, window->saved_gamma);
2684 }
2685
2687
2690 }
2691}
static SDL_bool ShouldMinimizeOnFocusLoss(SDL_Window *window)
Definition: SDL_video.c:2653

References _this, SDL_MinimizeWindow(), SDL_UpdateWindowGrab(), SDL_VideoDevice::SetWindowGammaRamp, and ShouldMinimizeOnFocusLoss().

Referenced by SDL_SendWindowEvent().

◆ SDL_OnWindowHidden()

void SDL_OnWindowHidden ( SDL_Window window)

Definition at line 2588 of file SDL_video.c.

References SDL_FALSE, and SDL_UpdateFullscreenMode().

Referenced by SDL_SendWindowEvent().

◆ SDL_OnWindowLeave()

void SDL_OnWindowLeave ( SDL_Window window)

Definition at line 2631 of file SDL_video.c.

2632{
2633}

Referenced by SDL_SendWindowEvent().

◆ SDL_OnWindowMinimized()

void SDL_OnWindowMinimized ( SDL_Window window)

Definition at line 2601 of file SDL_video.c.

References SDL_FALSE, and SDL_UpdateFullscreenMode().

Referenced by SDL_SendWindowEvent().

◆ SDL_OnWindowResized()

void SDL_OnWindowResized ( SDL_Window window)

Definition at line 2594 of file SDL_video.c.

2595{
2596 window->surface_valid = SDL_FALSE;
2598}
@ SDL_WINDOWEVENT_SIZE_CHANGED
Definition: SDL_video.h:156

References SDL_FALSE, SDL_SendWindowEvent(), and SDL_WINDOWEVENT_SIZE_CHANGED.

Referenced by SDL_SendWindowEvent(), SDL_SetWindowSize(), and SDL_UpdateFullscreenMode().

◆ SDL_OnWindowRestored()

void SDL_OnWindowRestored ( SDL_Window window)

Definition at line 2607 of file SDL_video.c.

2608{
2609 /*
2610 * FIXME: Is this fine to just remove this, or should it be preserved just
2611 * for the fullscreen case? In principle it seems like just hiding/showing
2612 * windows shouldn't affect the stacking order; maybe the right fix is to
2613 * re-decouple OnWindowShown and OnWindowRestored.
2614 */
2615 /*SDL_RaiseWindow(window);*/
2616
2619 }
2620}

References FULLSCREEN_VISIBLE, SDL_TRUE, and SDL_UpdateFullscreenMode().

Referenced by SDL_OnWindowShown(), and SDL_SendWindowEvent().

◆ SDL_OnWindowShown()

void SDL_OnWindowShown ( SDL_Window window)

Definition at line 2582 of file SDL_video.c.

2583{
2585}
void SDL_OnWindowRestored(SDL_Window *window)
Definition: SDL_video.c:2607

References SDL_OnWindowRestored().

Referenced by SDL_SendWindowEvent().

◆ SDL_RaiseWindow()

void SDL_RaiseWindow ( SDL_Window window)

Raise a window above other windows and set the input focus.

Definition at line 2187 of file SDL_video.c.

2188{
2190
2191 if (!(window->flags & SDL_WINDOW_SHOWN)) {
2192 return;
2193 }
2194 if (_this->RaiseWindow) {
2196 }
2197}
void(* RaiseWindow)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:225

References _this, CHECK_WINDOW_MAGIC, SDL_VideoDevice::RaiseWindow, and SDL_WINDOW_SHOWN.

Referenced by SDL_ShowMessageBox().

◆ SDL_RecreateWindow()

int SDL_RecreateWindow ( SDL_Window window,
Uint32  flags 
)

Definition at line 1614 of file SDL_video.c.

1615{
1616 SDL_bool loaded_opengl = SDL_FALSE;
1617
1619 return SDL_SetError("OpenGL support is either not configured in SDL "
1620 "or not available in current SDL video driver "
1621 "(%s) or platform", _this->name);
1622 }
1623
1624 if (window->flags & SDL_WINDOW_FOREIGN) {
1625 /* Can't destroy and re-create foreign windows, hrm */
1627 } else {
1628 flags &= ~SDL_WINDOW_FOREIGN;
1629 }
1630
1631 /* Restore video mode, etc. */
1633
1634 /* Tear down the old native window */
1635 if (window->surface) {
1636 window->surface->flags &= ~SDL_DONTFREE;
1637 SDL_FreeSurface(window->surface);
1638 window->surface = NULL;
1639 window->surface_valid = SDL_FALSE;
1640 }
1643 }
1646 }
1647
1648 if ((window->flags & SDL_WINDOW_OPENGL) != (flags & SDL_WINDOW_OPENGL)) {
1649 if (flags & SDL_WINDOW_OPENGL) {
1650 if (SDL_GL_LoadLibrary(NULL) < 0) {
1651 return -1;
1652 }
1653 loaded_opengl = SDL_TRUE;
1654 } else {
1656 }
1657 } else if (window->flags & SDL_WINDOW_OPENGL) {
1659 if (SDL_GL_LoadLibrary(NULL) < 0) {
1660 return -1;
1661 }
1662 loaded_opengl = SDL_TRUE;
1663 }
1664
1665 if ((window->flags & SDL_WINDOW_VULKAN) != (flags & SDL_WINDOW_VULKAN)) {
1666 SDL_SetError("Can't change SDL_WINDOW_VULKAN window flag");
1667 return -1;
1668 }
1669
1670 if ((window->flags & SDL_WINDOW_VULKAN) && (flags & SDL_WINDOW_OPENGL)) {
1671 SDL_SetError("Vulkan and OpenGL not supported on same window");
1672 return -1;
1673 }
1674
1675 window->flags = ((flags & CREATE_FLAGS) | SDL_WINDOW_HIDDEN);
1676 window->last_fullscreen_flags = window->flags;
1677 window->is_destroying = SDL_FALSE;
1678
1680 if (_this->CreateSDLWindow(_this, window) < 0) {
1681 if (loaded_opengl) {
1683 window->flags &= ~SDL_WINDOW_OPENGL;
1684 }
1685 return -1;
1686 }
1687 }
1688
1689 if (flags & SDL_WINDOW_FOREIGN) {
1690 window->flags |= SDL_WINDOW_FOREIGN;
1691 }
1692
1693 if (_this->SetWindowTitle && window->title) {
1695 }
1696
1697 if (_this->SetWindowIcon && window->icon) {
1699 }
1700
1701 if (window->hit_test) {
1703 }
1704
1706
1707 return 0;
1708}
SDL_bool
Definition: SDL_stdinc.h:162
void(* SetWindowIcon)(_THIS, SDL_Window *window, SDL_Surface *icon)
Definition: SDL_sysvideo.h:214
int(* SetWindowHitTest)(SDL_Window *window, SDL_bool enabled)
Definition: SDL_sysvideo.h:306
void(* SetWindowTitle)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:213

References _this, CREATE_FLAGS, SDL_VideoDevice::CreateSDLWindow, SDL_VideoDevice::DestroyWindow, SDL_VideoDevice::DestroyWindowFramebuffer, SDL_VideoDevice::GL_CreateContext, SDL_VideoDevice::name, NULL, SDL_FALSE, SDL_FinishWindowCreation(), SDL_FreeSurface, SDL_GL_LoadLibrary(), SDL_GL_UnloadLibrary(), SDL_HideWindow(), SDL_SetError, SDL_TRUE, SDL_WINDOW_FOREIGN, SDL_WINDOW_HIDDEN, SDL_WINDOW_OPENGL, SDL_WINDOW_VULKAN, SDL_VideoDevice::SetWindowHitTest, SDL_VideoDevice::SetWindowIcon, and SDL_VideoDevice::SetWindowTitle.

◆ SDL_RestoreMousePosition()

static void SDL_RestoreMousePosition ( SDL_Window window)
static

Definition at line 1168 of file SDL_video.c.

1169{
1170 int x, y;
1171
1172 if (window == SDL_GetMouseFocus()) {
1173 SDL_GetMouseState(&x, &y);
1175 }
1176}
#define SDL_GetMouseState

References SDL_GetMouseFocus, SDL_GetMouseState, and SDL_WarpMouseInWindow.

Referenced by SDL_UpdateFullscreenMode().

◆ SDL_RestoreWindow()

void SDL_RestoreWindow ( SDL_Window window)

Restore the size and position of a minimized or maximized window.

See also
SDL_MaximizeWindow()
SDL_MinimizeWindow()

Definition at line 2245 of file SDL_video.c.

2246{
2248
2249 if (!(window->flags & (SDL_WINDOW_MAXIMIZED | SDL_WINDOW_MINIMIZED))) {
2250 return;
2251 }
2252
2253 if (_this->RestoreWindow) {
2255 }
2256}
void(* RestoreWindow)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:228

References _this, CHECK_WINDOW_MAGIC, SDL_VideoDevice::RestoreWindow, SDL_WINDOW_MAXIMIZED, and SDL_WINDOW_MINIMIZED.

◆ SDL_SetDisplayModeForDisplay()

static int SDL_SetDisplayModeForDisplay ( SDL_VideoDisplay display,
const SDL_DisplayMode mode 
)
static

Definition at line 972 of file SDL_video.c.

973{
974 SDL_DisplayMode display_mode;
975 SDL_DisplayMode current_mode;
976
977 if (mode) {
978 display_mode = *mode;
979
980 /* Default to the current mode */
981 if (!display_mode.format) {
982 display_mode.format = display->current_mode.format;
983 }
984 if (!display_mode.w) {
985 display_mode.w = display->current_mode.w;
986 }
987 if (!display_mode.h) {
988 display_mode.h = display->current_mode.h;
989 }
990 if (!display_mode.refresh_rate) {
991 display_mode.refresh_rate = display->current_mode.refresh_rate;
992 }
993
994 /* Get a good video mode, the closest one possible */
995 if (!SDL_GetClosestDisplayModeForDisplay(display, &display_mode, &display_mode)) {
996 return SDL_SetError("No video mode large enough for %dx%d",
997 display_mode.w, display_mode.h);
998 }
999 } else {
1000 display_mode = display->desktop_mode;
1001 }
1002
1003 /* See if there's anything left to do */
1004 current_mode = display->current_mode;
1005 if (SDL_memcmp(&display_mode, &current_mode, sizeof(display_mode)) == 0) {
1006 return 0;
1007 }
1008
1009 /* Actually change the display mode */
1010 if (!_this->SetDisplayMode) {
1011 return SDL_SetError("SDL video driver doesn't support changing display mode");
1012 }
1013 if (_this->SetDisplayMode(_this, display, &display_mode) < 0) {
1014 return -1;
1015 }
1016 display->current_mode = display_mode;
1017 return 0;
1018}
#define SDL_memcmp
int(* SetDisplayMode)(_THIS, SDL_VideoDisplay *display, SDL_DisplayMode *mode)
Definition: SDL_sysvideo.h:205

References _this, SDL_VideoDisplay::current_mode, SDL_VideoDisplay::desktop_mode, SDL_DisplayMode::format, SDL_DisplayMode::h, SDL_DisplayMode::refresh_rate, SDL_GetClosestDisplayModeForDisplay(), SDL_memcmp, SDL_SetError, SDL_VideoDevice::SetDisplayMode, and SDL_DisplayMode::w.

Referenced by SDL_SetWindowDisplayMode(), and SDL_UpdateFullscreenMode().

◆ SDL_SetTextInputRect()

void SDL_SetTextInputRect ( SDL_Rect rect)

Set the rectangle used to type Unicode text inputs. This is used as a hint for IME and on-screen keyboard placement.

See also
SDL_StartTextInput()

Definition at line 3803 of file SDL_video.c.

3804{
3805 if (_this && _this->SetTextInputRect) {
3807 }
3808}
void(* SetTextInputRect)(_THIS, SDL_Rect *rect)
Definition: SDL_sysvideo.h:289

References _this, rect, and SDL_VideoDevice::SetTextInputRect.

◆ SDL_SetWindowBordered()

void SDL_SetWindowBordered ( SDL_Window window,
SDL_bool  bordered 
)

Set the border state of a window.

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.

Parameters
windowThe window of which to change the border state.
borderedSDL_FALSE to remove border, SDL_TRUE to add border.
Note
You can't change the border state of a fullscreen window.
See also
SDL_GetWindowFlags()

Definition at line 1950 of file SDL_video.c.

1951{
1953 if (!(window->flags & SDL_WINDOW_FULLSCREEN)) {
1954 const int want = (bordered != SDL_FALSE); /* normalize the flag. */
1955 const int have = ((window->flags & SDL_WINDOW_BORDERLESS) == 0);
1956 if ((want != have) && (_this->SetWindowBordered)) {
1957 if (want) {
1958 window->flags &= ~SDL_WINDOW_BORDERLESS;
1959 } else {
1960 window->flags |= SDL_WINDOW_BORDERLESS;
1961 }
1963 }
1964 }
1965}
@ SDL_WINDOW_BORDERLESS
Definition: SDL_video.h:104
void(* SetWindowBordered)(_THIS, SDL_Window *window, SDL_bool bordered)
Definition: SDL_sysvideo.h:229

References _this, CHECK_WINDOW_MAGIC, SDL_FALSE, SDL_WINDOW_BORDERLESS, SDL_WINDOW_FULLSCREEN, and SDL_VideoDevice::SetWindowBordered.

◆ SDL_SetWindowBrightness()

int SDL_SetWindowBrightness ( SDL_Window window,
float  brightness 
)

Set the brightness (gamma correction) for a window.

Returns
0 on success, or -1 if setting the brightness isn't supported.
See also
SDL_GetWindowBrightness()
SDL_SetWindowGammaRamp()

Definition at line 2355 of file SDL_video.c.

2356{
2357 Uint16 ramp[256];
2358 int status;
2359
2361
2362 SDL_CalculateGammaRamp(brightness, ramp);
2363 status = SDL_SetWindowGammaRamp(window, ramp, ramp, ramp);
2364 if (status == 0) {
2365 window->brightness = brightness;
2366 }
2367 return status;
2368}
#define SDL_CalculateGammaRamp
int SDL_SetWindowGammaRamp(SDL_Window *window, const Uint16 *red, const Uint16 *green, const Uint16 *blue)
Set the gamma ramp for a window.
Definition: SDL_video.c:2441

References CHECK_WINDOW_MAGIC, SDL_CalculateGammaRamp, and SDL_SetWindowGammaRamp().

◆ SDL_SetWindowData()

void * SDL_SetWindowData ( SDL_Window window,
const char *  name,
void userdata 
)

Associate an arbitrary named pointer with a window.

Parameters
windowThe window to associate with the pointer.
nameThe name of the pointer.
userdataThe associated pointer.
Returns
The previous value associated with 'name'
Note
The name is case-sensitive.
See also
SDL_GetWindowData()

Definition at line 1796 of file SDL_video.c.

1797{
1798 SDL_WindowUserData *prev, *data;
1799
1801
1802 /* Input validation */
1803 if (name == NULL || name[0] == '\0') {
1804 SDL_InvalidParamError("name");
1805 return NULL;
1806 }
1807
1808 /* See if the named data already exists */
1809 prev = NULL;
1810 for (data = window->data; data; prev = data, data = data->next) {
1811 if (data->name && SDL_strcmp(data->name, name) == 0) {
1812 void *last_value = data->data;
1813
1814 if (userdata) {
1815 /* Set the new value */
1816 data->data = userdata;
1817 } else {
1818 /* Delete this value */
1819 if (prev) {
1820 prev->next = data->next;
1821 } else {
1822 window->data = data->next;
1823 }
1824 SDL_free(data->name);
1825 SDL_free(data);
1826 }
1827 return last_value;
1828 }
1829 }
1830
1831 /* Add new data to the window */
1832 if (userdata) {
1833 data = (SDL_WindowUserData *)SDL_malloc(sizeof(*data));
1834 data->name = SDL_strdup(name);
1835 data->data = userdata;
1836 data->next = window->data;
1837 window->data = data;
1838 }
1839 return NULL;
1840}
struct SDL_WindowUserData * next
Definition: SDL_sysvideo.h:69

References CHECK_WINDOW_MAGIC, SDL_WindowUserData::data, SDL_WindowUserData::next, NULL, SDL_free, SDL_InvalidParamError, SDL_malloc, SDL_strcmp, and SDL_strdup.

Referenced by SDL_CreateWindowTexture(), and SDL_DestroyWindowTexture().

◆ SDL_SetWindowDisplayMode()

int SDL_SetWindowDisplayMode ( SDL_Window window,
const SDL_DisplayMode mode 
)

Set the display mode used when a fullscreen window is visible.

By default the window's dimensions and the desktop format and refresh rate are used.

Parameters
windowThe window for which the display mode should be set.
modeThe mode to use, or NULL for the default mode.
Returns
0 on success, or -1 if setting the display mode failed.
See also
SDL_GetWindowDisplayMode()
SDL_SetWindowFullscreen()

Definition at line 1100 of file SDL_video.c.

1101{
1103
1104 if (mode) {
1105 window->fullscreen_mode = *mode;
1106 } else {
1107 SDL_zero(window->fullscreen_mode);
1108 }
1109
1111 SDL_DisplayMode fullscreen_mode;
1112 if (SDL_GetWindowDisplayMode(window, &fullscreen_mode) == 0) {
1114 }
1115 }
1116 return 0;
1117}
static int SDL_SetDisplayModeForDisplay(SDL_VideoDisplay *display, const SDL_DisplayMode *mode)
Definition: SDL_video.c:972
int SDL_GetWindowDisplayMode(SDL_Window *window, SDL_DisplayMode *mode)
Fill in information about the display mode used when a fullscreen window is visible.
Definition: SDL_video.c:1120

References CHECK_WINDOW_MAGIC, FULLSCREEN_VISIBLE, SDL_GetDisplayForWindow(), SDL_GetWindowDisplayMode(), SDL_SetDisplayModeForDisplay(), SDL_WINDOW_FULLSCREEN_DESKTOP, and SDL_zero.

◆ SDL_SetWindowFullscreen()

int SDL_SetWindowFullscreen ( SDL_Window window,
Uint32  flags 
)

Set a window's fullscreen state.

Returns
0 on success, or -1 if setting the display mode failed.
See also
SDL_SetWindowDisplayMode()
SDL_GetWindowDisplayMode()

Definition at line 2259 of file SDL_video.c.

2260{
2261 Uint32 oldflags;
2263
2265
2266 if (flags == (window->flags & FULLSCREEN_MASK)) {
2267 return 0;
2268 }
2269
2270 /* clear the previous flags and OR in the new ones */
2271 oldflags = window->flags & FULLSCREEN_MASK;
2272 window->flags &= ~FULLSCREEN_MASK;
2273 window->flags |= flags;
2274
2276 return 0;
2277 }
2278
2279 window->flags &= ~FULLSCREEN_MASK;
2280 window->flags |= oldflags;
2281 return -1;
2282}
#define FULLSCREEN_MASK
Definition: SDL_video.c:144

References CHECK_WINDOW_MAGIC, FULLSCREEN_MASK, FULLSCREEN_VISIBLE, and SDL_UpdateFullscreenMode().

Referenced by SDL_FinishWindowCreation().

◆ SDL_SetWindowGammaRamp()

int SDL_SetWindowGammaRamp ( SDL_Window window,
const Uint16 red,
const Uint16 green,
const Uint16 blue 
)

Set the gamma ramp for a window.

Parameters
windowThe window for which the gamma ramp should be set.
redThe translation table for the red channel, or NULL.
greenThe translation table for the green channel, or NULL.
blueThe translation table for the blue channel, or NULL.
Returns
0 on success, or -1 if gamma ramps are unsupported.

Set the gamma translation table for the red, green, and blue channels of the video hardware. Each table is an array of 256 16-bit quantities, representing a mapping between the input and output for that channel. The input is the index into the array, and the output is the 16-bit gamma value at that index, scaled to the output color precision.

See also
SDL_GetWindowGammaRamp()

Definition at line 2441 of file SDL_video.c.

2444{
2446
2447 if (!_this->SetWindowGammaRamp) {
2448 return SDL_Unsupported();
2449 }
2450
2451 if (!window->gamma) {
2453 return -1;
2454 }
2455 SDL_assert(window->gamma != NULL);
2456 }
2457
2458 if (red) {
2459 SDL_memcpy(&window->gamma[0*256], red, 256*sizeof(Uint16));
2460 }
2461 if (green) {
2462 SDL_memcpy(&window->gamma[1*256], green, 256*sizeof(Uint16));
2463 }
2464 if (blue) {
2465 SDL_memcpy(&window->gamma[2*256], blue, 256*sizeof(Uint16));
2466 }
2467 if (window->flags & SDL_WINDOW_INPUT_FOCUS) {
2468 return _this->SetWindowGammaRamp(_this, window, window->gamma);
2469 } else {
2470 return 0;
2471 }
2472}
int SDL_GetWindowGammaRamp(SDL_Window *window, Uint16 *red, Uint16 *green, Uint16 *blue)
Get the gamma ramp for a window.
Definition: SDL_video.c:2475

References _this, CHECK_WINDOW_MAGIC, NULL, red, SDL_assert, SDL_GetWindowGammaRamp(), SDL_memcpy, SDL_Unsupported, SDL_WINDOW_INPUT_FOCUS, and SDL_VideoDevice::SetWindowGammaRamp.

Referenced by SDL_SetWindowBrightness().

◆ SDL_SetWindowGrab()

void SDL_SetWindowGrab ( SDL_Window window,
SDL_bool  grabbed 
)

Set a window's input grab mode.

Parameters
windowThe window for which the input grab mode should be set.
grabbedThis is SDL_TRUE to grab input, and SDL_FALSE to release input.

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.

See also
SDL_GetWindowGrab()

Definition at line 2551 of file SDL_video.c.

2552{
2554
2555 if (!!grabbed == !!(window->flags & SDL_WINDOW_INPUT_GRABBED)) {
2556 return;
2557 }
2558 if (grabbed) {
2560 } else {
2561 window->flags &= ~SDL_WINDOW_INPUT_GRABBED;
2562 }
2564}

References CHECK_WINDOW_MAGIC, SDL_UpdateWindowGrab(), and SDL_WINDOW_INPUT_GRABBED.

Referenced by SDL_FinishWindowCreation().

◆ SDL_SetWindowHitTest()

int SDL_SetWindowHitTest ( SDL_Window window,
SDL_HitTest  callback,
void callback_data 
)

Provide a callback that decides if a window region has special properties.

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.

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."

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.

Specifying NULL for a callback disables hit-testing. Hit-testing is disabled by default.

Platforms that don't support this functionality will return -1 unconditionally, even if you're attempting to disable hit-testing.

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.

Parameters
windowThe window to set hit-testing on.
callbackThe callback to call when doing a hit-test.
callback_dataAn app-defined void pointer passed to the callback.
Returns
0 on success, -1 on error (including unsupported).

Definition at line 3998 of file SDL_video.c.

3999{
4001
4002 if (!_this->SetWindowHitTest) {
4003 return SDL_Unsupported();
4004 } else if (_this->SetWindowHitTest(window, callback != NULL) == -1) {
4005 return -1;
4006 }
4007
4008 window->hit_test = callback;
4009 window->hit_test_data = userdata;
4010
4011 return 0;
4012}
static Uint32 callback(Uint32 interval, void *param)
Definition: testtimer.c:34

References _this, callback(), CHECK_WINDOW_MAGIC, NULL, SDL_Unsupported, and SDL_VideoDevice::SetWindowHitTest.

◆ SDL_SetWindowIcon()

void SDL_SetWindowIcon ( SDL_Window window,
SDL_Surface icon 
)

Set the icon for a window.

Parameters
windowThe window for which the icon should be set.
iconThe icon for the window.

Definition at line 1774 of file SDL_video.c.

1775{
1777
1778 if (!icon) {
1779 return;
1780 }
1781
1782 SDL_FreeSurface(window->icon);
1783
1784 /* Convert the icon into ARGB8888 */
1786 if (!window->icon) {
1787 return;
1788 }
1789
1790 if (_this->SetWindowIcon) {
1792 }
1793}
#define SDL_ConvertSurfaceFormat
@ SDL_PIXELFORMAT_ARGB8888
Definition: SDL_pixels.h:248

References _this, CHECK_WINDOW_MAGIC, SDL_ConvertSurfaceFormat, SDL_FreeSurface, SDL_PIXELFORMAT_ARGB8888, and SDL_VideoDevice::SetWindowIcon.

◆ SDL_SetWindowInputFocus()

int SDL_SetWindowInputFocus ( SDL_Window window)

Explicitly sets input focus to the window.

You almost certainly want SDL_RaiseWindow() instead of this function. Use this with caution, as you might give focus to a window that's completely obscured by other windows.

Parameters
windowThe window that should get the input focus
Returns
0 on success, or -1 otherwise.
See also
SDL_RaiseWindow()

Definition at line 2428 of file SDL_video.c.

2429{
2431
2432 if (!_this->SetWindowInputFocus) {
2433 return SDL_Unsupported();
2434 }
2435
2437}
int(* SetWindowInputFocus)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:222

References _this, CHECK_WINDOW_MAGIC, SDL_Unsupported, and SDL_VideoDevice::SetWindowInputFocus.

◆ SDL_SetWindowMaximumSize()

void SDL_SetWindowMaximumSize ( SDL_Window window,
int  max_w,
int  max_h 
)

Set the maximum size of a window's client area.

Parameters
windowThe window to set a new maximum size.
max_wThe maximum width of the window, must be >0
max_hThe maximum height of the window, must be >0
Note
You can't change the maximum size of a fullscreen window, it automatically matches the size of the display mode.
See also
SDL_GetWindowMaximumSize()
SDL_SetWindowMinimumSize()

Definition at line 2111 of file SDL_video.c.

2112{
2114 if (max_w <= 0) {
2115 SDL_InvalidParamError("max_w");
2116 return;
2117 }
2118 if (max_h <= 0) {
2119 SDL_InvalidParamError("max_h");
2120 return;
2121 }
2122
2123 if (max_w <= window->min_w || max_h <= window->min_h) {
2124 SDL_SetError("SDL_SetWindowMaximumSize(): Tried to set maximum size smaller than minimum size");
2125 return;
2126 }
2127
2128 window->max_w = max_w;
2129 window->max_h = max_h;
2130
2131 if (!(window->flags & SDL_WINDOW_FULLSCREEN)) {
2134 }
2135 /* Ensure that window is not larger than maximal size */
2136 SDL_SetWindowSize(window, SDL_min(window->w, window->max_w), SDL_min(window->h, window->max_h));
2137 }
2138}
#define SDL_min(x, y)
Definition: SDL_stdinc.h:406
void SDL_SetWindowSize(SDL_Window *window, int w, int h)
Set the size of a window's client area.
Definition: SDL_video.c:1986
void(* SetWindowMaximumSize)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:218

References _this, CHECK_WINDOW_MAGIC, SDL_InvalidParamError, SDL_min, SDL_SetError, SDL_SetWindowSize(), SDL_WINDOW_FULLSCREEN, and SDL_VideoDevice::SetWindowMaximumSize.

◆ SDL_SetWindowMinimumSize()

void SDL_SetWindowMinimumSize ( SDL_Window window,
int  min_w,
int  min_h 
)

Set the minimum size of a window's client area.

Parameters
windowThe window to set a new minimum size.
min_wThe minimum width of the window, must be >0
min_hThe minimum height of the window, must be >0
Note
You can't change the minimum size of a fullscreen window, it automatically matches the size of the display mode.
See also
SDL_GetWindowMinimumSize()
SDL_SetWindowMaximumSize()

Definition at line 2068 of file SDL_video.c.

2069{
2071 if (min_w <= 0) {
2072 SDL_InvalidParamError("min_w");
2073 return;
2074 }
2075 if (min_h <= 0) {
2076 SDL_InvalidParamError("min_h");
2077 return;
2078 }
2079
2080 if ((window->max_w && min_w >= window->max_w) ||
2081 (window->max_h && min_h >= window->max_h)) {
2082 SDL_SetError("SDL_SetWindowMinimumSize(): Tried to set minimum size larger than maximum size");
2083 return;
2084 }
2085
2086 window->min_w = min_w;
2087 window->min_h = min_h;
2088
2089 if (!(window->flags & SDL_WINDOW_FULLSCREEN)) {
2092 }
2093 /* Ensure that window is not smaller than minimal size */
2094 SDL_SetWindowSize(window, SDL_max(window->w, window->min_w), SDL_max(window->h, window->min_h));
2095 }
2096}
#define SDL_max(x, y)
Definition: SDL_stdinc.h:407
void(* SetWindowMinimumSize)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:217

References _this, CHECK_WINDOW_MAGIC, SDL_InvalidParamError, SDL_max, SDL_SetError, SDL_SetWindowSize(), SDL_WINDOW_FULLSCREEN, and SDL_VideoDevice::SetWindowMinimumSize.

◆ SDL_SetWindowModalFor()

int SDL_SetWindowModalFor ( SDL_Window modal_window,
SDL_Window parent_window 
)

Sets the window as a modal for another window (TODO: reconsider this function and/or its name)

Parameters
modal_windowThe window that should be modal
parent_windowThe parent window
Returns
0 on success, or -1 otherwise.

Definition at line 2415 of file SDL_video.c.

2416{
2417 CHECK_WINDOW_MAGIC(modal_window, -1);
2418 CHECK_WINDOW_MAGIC(parent_window, -1);
2419
2420 if (!_this->SetWindowModalFor) {
2421 return SDL_Unsupported();
2422 }
2423
2424 return _this->SetWindowModalFor(_this, modal_window, parent_window);
2425}
int(* SetWindowModalFor)(_THIS, SDL_Window *modal_window, SDL_Window *parent_window)
Definition: SDL_sysvideo.h:221

References _this, CHECK_WINDOW_MAGIC, SDL_Unsupported, and SDL_VideoDevice::SetWindowModalFor.

◆ SDL_SetWindowOpacity()

int SDL_SetWindowOpacity ( SDL_Window window,
float  opacity 
)

Set the opacity for a window.

Parameters
windowThe window which will be made transparent or opaque
opacityOpacity (0.0f - transparent, 1.0f - opaque) This will be clamped internally between 0.0f and 1.0f.
Returns
0 on success, or -1 if setting the opacity isn't supported.
See also
SDL_GetWindowOpacity()

Definition at line 2379 of file SDL_video.c.

2380{
2381 int retval;
2383
2384 if (!_this->SetWindowOpacity) {
2385 return SDL_Unsupported();
2386 }
2387
2388 if (opacity < 0.0f) {
2389 opacity = 0.0f;
2390 } else if (opacity > 1.0f) {
2391 opacity = 1.0f;
2392 }
2393
2395 if (retval == 0) {
2396 window->opacity = opacity;
2397 }
2398
2399 return retval;
2400}
int(* SetWindowOpacity)(_THIS, SDL_Window *window, float opacity)
Definition: SDL_sysvideo.h:220

References _this, CHECK_WINDOW_MAGIC, retval, SDL_Unsupported, and SDL_VideoDevice::SetWindowOpacity.

◆ SDL_SetWindowPosition()

void SDL_SetWindowPosition ( SDL_Window window,
int  x,
int  y 
)

Set the position of a window.

Parameters
windowThe window to reposition.
xThe x coordinate of the window in screen coordinates, or SDL_WINDOWPOS_CENTERED or SDL_WINDOWPOS_UNDEFINED.
yThe y coordinate of the window in screen coordinates, or SDL_WINDOWPOS_CENTERED or SDL_WINDOWPOS_UNDEFINED.
Note
The window coordinate origin is the upper left of the display.
See also
SDL_GetWindowPosition()

Definition at line 1864 of file SDL_video.c.

1865{
1867
1869 int displayIndex = (x & 0xFFFF);
1870 SDL_Rect bounds;
1871 if (displayIndex >= _this->num_displays) {
1872 displayIndex = 0;
1873 }
1874
1875 SDL_zero(bounds);
1876
1877 SDL_GetDisplayBounds(displayIndex, &bounds);
1879 x = bounds.x + (bounds.w - window->w) / 2;
1880 }
1882 y = bounds.y + (bounds.h - window->h) / 2;
1883 }
1884 }
1885
1886 if ((window->flags & SDL_WINDOW_FULLSCREEN)) {
1888 window->windowed.x = x;
1889 }
1891 window->windowed.y = y;
1892 }
1893 } else {
1895 window->x = x;
1896 }
1898 window->y = y;
1899 }
1900
1901 if (_this->SetWindowPosition) {
1903 }
1904 }
1905}
void(* SetWindowPosition)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:215

References _this, CHECK_WINDOW_MAGIC, SDL_Rect::h, SDL_VideoDevice::num_displays, SDL_GetDisplayBounds(), SDL_WINDOW_FULLSCREEN, SDL_WINDOWPOS_ISCENTERED, SDL_WINDOWPOS_ISUNDEFINED, SDL_zero, SDL_VideoDevice::SetWindowPosition, SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

◆ SDL_SetWindowResizable()

void SDL_SetWindowResizable ( SDL_Window window,
SDL_bool  resizable 
)

Set the user-resizable state of a window.

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.

Parameters
windowThe window of which to change the resizable state.
resizableSDL_TRUE to allow resizing, SDL_FALSE to disallow.
Note
You can't change the resizable state of a fullscreen window.
See also
SDL_GetWindowFlags()

Definition at line 1968 of file SDL_video.c.

1969{
1971 if (!(window->flags & SDL_WINDOW_FULLSCREEN)) {
1972 const int want = (resizable != SDL_FALSE); /* normalize the flag. */
1973 const int have = ((window->flags & SDL_WINDOW_RESIZABLE) != 0);
1974 if ((want != have) && (_this->SetWindowResizable)) {
1975 if (want) {
1976 window->flags |= SDL_WINDOW_RESIZABLE;
1977 } else {
1978 window->flags &= ~SDL_WINDOW_RESIZABLE;
1979 }
1981 }
1982 }
1983}
@ SDL_WINDOW_RESIZABLE
Definition: SDL_video.h:105
void(* SetWindowResizable)(_THIS, SDL_Window *window, SDL_bool resizable)
Definition: SDL_sysvideo.h:230

References _this, CHECK_WINDOW_MAGIC, SDL_FALSE, SDL_WINDOW_FULLSCREEN, SDL_WINDOW_RESIZABLE, and SDL_VideoDevice::SetWindowResizable.

◆ SDL_SetWindowSize()

void SDL_SetWindowSize ( SDL_Window window,
int  w,
int  h 
)

Set the size of a window's client area.

Parameters
windowThe window to resize.
wThe width of the window, in screen coordinates. Must be >0.
hThe height of the window, in screen coordinates. Must be >0.
Note
Fullscreen windows automatically match the size of the display mode, and you should use SDL_SetWindowDisplayMode() to change their size.

The window size in screen coordinates may differ from the size in pixels, if the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a platform with high-dpi support (e.g. iOS or OS X). Use SDL_GL_GetDrawableSize() or SDL_GetRendererOutputSize() to get the real client area size in pixels.

See also
SDL_GetWindowSize()
SDL_SetWindowDisplayMode()

Definition at line 1986 of file SDL_video.c.

1987{
1989 if (w <= 0) {
1991 return;
1992 }
1993 if (h <= 0) {
1995 return;
1996 }
1997
1998 /* Make sure we don't exceed any window size limits */
1999 if (window->min_w && w < window->min_w) {
2000 w = window->min_w;
2001 }
2002 if (window->max_w && w > window->max_w) {
2003 w = window->max_w;
2004 }
2005 if (window->min_h && h < window->min_h) {
2006 h = window->min_h;
2007 }
2008 if (window->max_h && h > window->max_h) {
2009 h = window->max_h;
2010 }
2011
2012 window->windowed.w = w;
2013 window->windowed.h = h;
2014
2015 if (window->flags & SDL_WINDOW_FULLSCREEN) {
2017 window->last_fullscreen_flags = 0;
2019 }
2020 } else {
2021 window->w = w;
2022 window->h = h;
2023 if (_this->SetWindowSize) {
2025 }
2026 if (window->w == w && window->h == h) {
2027 /* We didn't get a SDL_WINDOWEVENT_RESIZED event (by design) */
2029 }
2030 }
2031}
void SDL_OnWindowResized(SDL_Window *window)
Definition: SDL_video.c:2594
void(* SetWindowSize)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:216

References _this, CHECK_WINDOW_MAGIC, FULLSCREEN_VISIBLE, SDL_InvalidParamError, SDL_OnWindowResized(), SDL_TRUE, SDL_UpdateFullscreenMode(), SDL_WINDOW_FULLSCREEN, SDL_WINDOW_FULLSCREEN_DESKTOP, and SDL_VideoDevice::SetWindowSize.

Referenced by SDL_SetWindowMaximumSize(), and SDL_SetWindowMinimumSize().

◆ SDL_SetWindowTitle()

void SDL_SetWindowTitle ( SDL_Window window,
const char *  title 
)

Set the title of a window, in UTF-8 format.

See also
SDL_GetWindowTitle()

Definition at line 1749 of file SDL_video.c.

1750{
1752
1753 if (title == window->title) {
1754 return;
1755 }
1756 SDL_free(window->title);
1757
1758 window->title = SDL_strdup(title ? title : "");
1759
1760 if (_this->SetWindowTitle) {
1762 }
1763}

References _this, CHECK_WINDOW_MAGIC, SDL_free, SDL_strdup, and SDL_VideoDevice::SetWindowTitle.

Referenced by SDL_CreateWindow().

◆ SDL_ShouldAllowTopmost()

SDL_bool SDL_ShouldAllowTopmost ( void  )

Definition at line 3992 of file SDL_video.c.

3993{
3995}
#define SDL_HINT_ALLOW_TOPMOST
If set to "0" then never set the top most bit on a SDL Window, even if the video mode expects it....
Definition: SDL_hints.h:588

References SDL_GetHintBoolean, SDL_HINT_ALLOW_TOPMOST, and SDL_TRUE.

◆ SDL_ShowMessageBox()

int SDL_ShowMessageBox ( const SDL_MessageBoxData messageboxdata,
int *  buttonid 
)

Create a modal message box.

Parameters
messageboxdataThe SDL_MessageBoxData structure with title, text, etc.
buttonidThe pointer to which user id of hit button should be copied.
Returns
-1 on error, otherwise 0 and buttonid contains user id of button hit or -1 if dialog was closed.
Note
This function should be called on the thread that created the parent window, or on the main thread if the messagebox has no parent. It will block execution of that thread until the user clicks a button or closes the messagebox.

Definition at line 3868 of file SDL_video.c.

3869{
3870 int dummybutton;
3871 int retval = -1;
3872 SDL_bool relative_mode;
3873 int show_cursor_prev;
3874 SDL_bool mouse_captured;
3875 SDL_Window *current_window;
3876
3877 if (!messageboxdata) {
3878 return SDL_InvalidParamError("messageboxdata");
3879 } else if (messageboxdata->numbuttons < 0) {
3880 return SDL_SetError("Invalid number of buttons");
3881 }
3882
3883 current_window = SDL_GetKeyboardFocus();
3884 mouse_captured = current_window && ((SDL_GetWindowFlags(current_window) & SDL_WINDOW_MOUSE_CAPTURE) != 0);
3885 relative_mode = SDL_GetRelativeMouseMode();
3888 show_cursor_prev = SDL_ShowCursor(1);
3890
3891 if (!buttonid) {
3892 buttonid = &dummybutton;
3893 }
3894
3895 if (_this && _this->ShowMessageBox) {
3896 retval = _this->ShowMessageBox(_this, messageboxdata, buttonid);
3897 }
3898
3899 /* It's completely fine to call this function before video is initialized */
3900#if SDL_VIDEO_DRIVER_ANDROID
3901 if (retval == -1 &&
3902 Android_ShowMessageBox(messageboxdata, buttonid) == 0) {
3903 retval = 0;
3904 }
3905#endif
3906#if SDL_VIDEO_DRIVER_WINDOWS
3907 if (retval == -1 &&
3909 WIN_ShowMessageBox(messageboxdata, buttonid) == 0) {
3910 retval = 0;
3911 }
3912#endif
3913#if SDL_VIDEO_DRIVER_WINRT
3914 if (retval == -1 &&
3916 WINRT_ShowMessageBox(messageboxdata, buttonid) == 0) {
3917 retval = 0;
3918 }
3919#endif
3920#if SDL_VIDEO_DRIVER_COCOA
3921 if (retval == -1 &&
3923 Cocoa_ShowMessageBox(messageboxdata, buttonid) == 0) {
3924 retval = 0;
3925 }
3926#endif
3927#if SDL_VIDEO_DRIVER_UIKIT
3928 if (retval == -1 &&
3930 UIKit_ShowMessageBox(messageboxdata, buttonid) == 0) {
3931 retval = 0;
3932 }
3933#endif
3934#if SDL_VIDEO_DRIVER_X11
3935 if (retval == -1 &&
3937 X11_ShowMessageBox(messageboxdata, buttonid) == 0) {
3938 retval = 0;
3939 }
3940#endif
3941 if (retval == -1) {
3942 SDL_SetError("No message system available");
3943 }
3944
3945 if (current_window) {
3946 SDL_RaiseWindow(current_window);
3947 if (mouse_captured) {
3949 }
3950 }
3951
3952 SDL_ShowCursor(show_cursor_prev);
3953 SDL_SetRelativeMouseMode(relative_mode);
3954
3955 return retval;
3956}
#define SDL_ShowCursor
#define SDL_SetRelativeMouseMode
#define SDL_CaptureMouse
#define SDL_GetRelativeMouseMode
void SDL_ResetKeyboard(void)
Definition: SDL_keyboard.c:572
@ SDL_SYSWM_X11
Definition: SDL_syswm.h:123
@ SDL_SYSWM_WINDOWS
Definition: SDL_syswm.h:122
@ SDL_SYSWM_UIKIT
Definition: SDL_syswm.h:126
@ SDL_SYSWM_COCOA
Definition: SDL_syswm.h:125
@ SDL_SYSWM_WINRT
Definition: SDL_syswm.h:129
Uint32 SDL_GetWindowFlags(SDL_Window *window)
Get the window flags.
Definition: SDL_video.c:1741
static SDL_bool SDL_MessageboxValidForDriver(const SDL_MessageBoxData *messageboxdata, SDL_SYSWM_TYPE drivertype)
Definition: SDL_video.c:3849
void SDL_RaiseWindow(SDL_Window *window)
Raise a window above other windows and set the input focus.
Definition: SDL_video.c:2187
@ SDL_WINDOW_MOUSE_CAPTURE
Definition: SDL_video.h:116
int(* ShowMessageBox)(_THIS, const SDL_MessageBoxData *messageboxdata, int *buttonid)
Definition: SDL_sysvideo.h:303

References _this, SDL_MessageBoxData::numbuttons, retval, SDL_CaptureMouse, SDL_FALSE, SDL_GetKeyboardFocus, SDL_GetRelativeMouseMode, SDL_GetWindowFlags(), SDL_InvalidParamError, SDL_MessageboxValidForDriver(), SDL_RaiseWindow(), SDL_ResetKeyboard(), SDL_SetError, SDL_SetRelativeMouseMode, SDL_ShowCursor, SDL_SYSWM_COCOA, SDL_SYSWM_UIKIT, SDL_SYSWM_WINDOWS, SDL_SYSWM_WINRT, SDL_SYSWM_X11, SDL_TRUE, SDL_WINDOW_MOUSE_CAPTURE, and SDL_VideoDevice::ShowMessageBox.

Referenced by SDL_ShowSimpleMessageBox().

◆ SDL_ShowSimpleMessageBox()

int SDL_ShowSimpleMessageBox ( Uint32  flags,
const char *  title,
const char *  message,
SDL_Window window 
)

Create a simple modal message box.

Parameters
flagsSDL_MessageBoxFlags
titleUTF-8 title text
messageUTF-8 message text
windowThe parent window, or NULL for no parent
Returns
0 on success, -1 on error
See also
SDL_ShowMessageBox

Definition at line 3959 of file SDL_video.c.

3960{
3961#ifdef __EMSCRIPTEN__
3962 /* !!! FIXME: propose a browser API for this, get this #ifdef out of here? */
3963 /* Web browsers don't (currently) have an API for a custom message box
3964 that can block, but for the most common case (SDL_ShowSimpleMessageBox),
3965 we can use the standard Javascript alert() function. */
3966 EM_ASM_({
3967 alert(UTF8ToString($0) + "\n\n" + UTF8ToString($1));
3968 }, title, message);
3969 return 0;
3970#else
3973
3974 SDL_zero(data);
3975 data.flags = flags;
3976 data.title = title;
3977 data.message = message;
3978 data.numbuttons = 1;
3979 data.buttons = &button;
3980 data.window = window;
3981
3985 button.text = "OK";
3986
3987 return SDL_ShowMessageBox(&data, NULL);
3988#endif
3989}
@ SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT
@ SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT
GLuint GLsizei const GLchar * message
int SDL_ShowMessageBox(const SDL_MessageBoxData *messageboxdata, int *buttonid)
Create a modal message box.
Definition: SDL_video.c:3868
Individual button data.
MessageBox structure containing title, text, window, etc.
SDL_Texture * button

References button, NULL, SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT, SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, SDL_ShowMessageBox(), and SDL_zero.

◆ SDL_ShowWindow()

void SDL_ShowWindow ( SDL_Window window)

Show a window.

See also
SDL_HideWindow()

Definition at line 2153 of file SDL_video.c.

2154{
2156
2157 if (window->flags & SDL_WINDOW_SHOWN) {
2158 return;
2159 }
2160
2161 if (_this->ShowWindow) {
2163 }
2165}
@ SDL_WINDOWEVENT_SHOWN
Definition: SDL_video.h:149
void(* ShowWindow)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:223

References _this, CHECK_WINDOW_MAGIC, SDL_SendWindowEvent(), SDL_WINDOW_SHOWN, SDL_WINDOWEVENT_SHOWN, and SDL_VideoDevice::ShowWindow.

Referenced by SDL_FinishWindowCreation().

◆ SDL_StartTextInput()

void SDL_StartTextInput ( void  )

Start accepting Unicode text input events. This function will show the on-screen keyboard if supported.

See also
SDL_StopTextInput()
SDL_SetTextInputRect()
SDL_HasScreenKeyboardSupport()

Definition at line 3755 of file SDL_video.c.

3756{
3758
3759 /* First, enable text events */
3762
3763 /* Then show the on-screen keyboard, if any */
3765 if (window && _this && _this->ShowScreenKeyboard) {
3767 }
3768
3769 /* Finally start the text input system */
3770 if (_this && _this->StartTextInput) {
3772 }
3773}
#define SDL_EventState
@ SDL_TEXTEDITING
Definition: SDL_events.h:98
SDL_Window * SDL_GetFocusWindow(void)
Definition: SDL_video.c:2696
void(* StartTextInput)(_THIS)
Definition: SDL_sysvideo.h:287
void(* ShowScreenKeyboard)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:293

References _this, SDL_ENABLE, SDL_EventState, SDL_GetFocusWindow(), SDL_TEXTEDITING, SDL_TEXTINPUT, SDL_VideoDevice::ShowScreenKeyboard, and SDL_VideoDevice::StartTextInput.

Referenced by SDL_VideoInit().

◆ SDL_StopTextInput()

void SDL_StopTextInput ( void  )

Stop receiving any text input events. This function will hide the on-screen keyboard if supported.

See also
SDL_StartTextInput()
SDL_HasScreenKeyboardSupport()

Definition at line 3782 of file SDL_video.c.

3783{
3785
3786 /* Stop the text input system */
3787 if (_this && _this->StopTextInput) {
3789 }
3790
3791 /* Hide the on-screen keyboard, if any */
3793 if (window && _this && _this->HideScreenKeyboard) {
3795 }
3796
3797 /* Finally disable text events */
3800}
#define SDL_DISABLE
Definition: SDL_events.h:758
void(* HideScreenKeyboard)(_THIS, SDL_Window *window)
Definition: SDL_sysvideo.h:294
void(* StopTextInput)(_THIS)
Definition: SDL_sysvideo.h:288

References _this, SDL_VideoDevice::HideScreenKeyboard, SDL_DISABLE, SDL_EventState, SDL_GetFocusWindow(), SDL_TEXTEDITING, SDL_TEXTINPUT, and SDL_VideoDevice::StopTextInput.

◆ SDL_ToggleDragAndDropSupport()

void SDL_ToggleDragAndDropSupport ( void  )

Definition at line 1371 of file SDL_video.c.

1372{
1373 if (_this && _this->AcceptDragAndDrop) {
1376 for (window = _this->windows; window; window = window->next) {
1378 }
1379 }
1380}
GLboolean enable

References _this, SDL_VideoDevice::AcceptDragAndDrop, IsAcceptingDragAndDrop(), SDL_Window::next, and SDL_VideoDevice::windows.

Referenced by SDL_EventState().

◆ SDL_UninitializedVideo()

◆ SDL_UpdateFullscreenMode()

static int SDL_UpdateFullscreenMode ( SDL_Window window,
SDL_bool  fullscreen 
)
static

Definition at line 1183 of file SDL_video.c.

1184{
1185 SDL_VideoDisplay *display;
1186 SDL_Window *other;
1187
1189
1190 /* if we are in the process of hiding don't go back to fullscreen */
1191 if (window->is_hiding && fullscreen) {
1192 return 0;
1193 }
1194
1195#ifdef __MACOSX__
1196 /* if the window is going away and no resolution change is necessary,
1197 do nothing, or else we may trigger an ugly double-transition
1198 */
1199 if (SDL_strcmp(_this->name, "cocoa") == 0) { /* don't do this for X11, etc */
1200 if (window->is_destroying && (window->last_fullscreen_flags & FULLSCREEN_MASK) == SDL_WINDOW_FULLSCREEN_DESKTOP)
1201 return 0;
1202
1203 /* If we're switching between a fullscreen Space and "normal" fullscreen, we need to get back to normal first. */
1204 if (fullscreen && ((window->last_fullscreen_flags & FULLSCREEN_MASK) == SDL_WINDOW_FULLSCREEN_DESKTOP) && ((window->flags & FULLSCREEN_MASK) == SDL_WINDOW_FULLSCREEN)) {
1205 if (!Cocoa_SetWindowFullscreenSpace(window, SDL_FALSE)) {
1206 return -1;
1207 }
1208 } else if (fullscreen && ((window->last_fullscreen_flags & FULLSCREEN_MASK) == SDL_WINDOW_FULLSCREEN) && ((window->flags & FULLSCREEN_MASK) == SDL_WINDOW_FULLSCREEN_DESKTOP)) {
1213 }
1214 }
1215
1216 if (Cocoa_SetWindowFullscreenSpace(window, fullscreen)) {
1217 if (Cocoa_IsWindowInFullscreenSpace(window) != fullscreen) {
1218 return -1;
1219 }
1220 window->last_fullscreen_flags = window->flags;
1221 return 0;
1222 }
1223 }
1224#elif __WINRT__ && (NTDDI_VERSION < NTDDI_WIN10)
1225 /* HACK: WinRT 8.x apps can't choose whether or not they are fullscreen
1226 or not. The user can choose this, via OS-provided UI, but this can't
1227 be set programmatically.
1228
1229 Just look at what SDL's WinRT video backend code detected with regards
1230 to fullscreen (being active, or not), and figure out a return/error code
1231 from that.
1232 */
1233 if (fullscreen == !(WINRT_DetectWindowFlags(window) & FULLSCREEN_MASK)) {
1234 /* Uh oh, either:
1235 1. fullscreen was requested, and we're already windowed
1236 2. windowed-mode was requested, and we're already fullscreen
1237
1238 WinRT 8.x can't resolve either programmatically, so we're
1239 giving up.
1240 */
1241 return -1;
1242 } else {
1243 /* Whatever was requested, fullscreen or windowed mode, is already
1244 in-place.
1245 */
1246 return 0;
1247 }
1248#endif
1249
1251
1252 if (fullscreen) {
1253 /* Hide any other fullscreen windows */
1254 if (display->fullscreen_window &&
1255 display->fullscreen_window != window) {
1257 }
1258 }
1259
1260 /* See if anything needs to be done now */
1261 if ((display->fullscreen_window == window) == fullscreen) {
1262 if ((window->last_fullscreen_flags & FULLSCREEN_MASK) == (window->flags & FULLSCREEN_MASK)) {
1263 return 0;
1264 }
1265 }
1266
1267 /* See if there are any fullscreen windows */
1268 for (other = _this->windows; other; other = other->next) {
1269 SDL_bool setDisplayMode = SDL_FALSE;
1270
1271 if (other == window) {
1272 setDisplayMode = fullscreen;
1273 } else if (FULLSCREEN_VISIBLE(other) &&
1274 SDL_GetDisplayForWindow(other) == display) {
1275 setDisplayMode = SDL_TRUE;
1276 }
1277
1278 if (setDisplayMode) {
1279 SDL_DisplayMode fullscreen_mode;
1280
1281 SDL_zero(fullscreen_mode);
1282
1283 if (SDL_GetWindowDisplayMode(other, &fullscreen_mode) == 0) {
1284 SDL_bool resized = SDL_TRUE;
1285
1286 if (other->w == fullscreen_mode.w && other->h == fullscreen_mode.h) {
1287 resized = SDL_FALSE;
1288 }
1289
1290 /* only do the mode change if we want exclusive fullscreen */
1292 if (SDL_SetDisplayModeForDisplay(display, &fullscreen_mode) < 0) {
1293 return -1;
1294 }
1295 } else {
1296 if (SDL_SetDisplayModeForDisplay(display, NULL) < 0) {
1297 return -1;
1298 }
1299 }
1300
1302 _this->SetWindowFullscreen(_this, other, display, SDL_TRUE);
1303 }
1304 display->fullscreen_window = other;
1305
1306 /* Generate a mode change event here */
1307 if (resized) {
1308#ifndef ANDROID
1309 // Android may not resize the window to exactly what our fullscreen mode is, especially on
1310 // windowed Android environments like the Chromebook or Samsung DeX. Given this, we shouldn't
1311 // use fullscreen_mode.w and fullscreen_mode.h, but rather get our current native size. As such,
1312 // Android's SetWindowFullscreen will generate the window event for us with the proper final size.
1313
1315 fullscreen_mode.w, fullscreen_mode.h);
1316#endif
1317 } else {
1318 SDL_OnWindowResized(other);
1319 }
1320
1322
1323 window->last_fullscreen_flags = window->flags;
1324 return 0;
1325 }
1326 }
1327 }
1328
1329 /* Nope, restore the desktop mode */
1331
1334 }
1335 display->fullscreen_window = NULL;
1336
1337 /* Generate a mode change event here */
1339
1340 /* Restore the cursor position */
1342
1343 window->last_fullscreen_flags = window->flags;
1344 return 0;
1345}
static void SDL_RestoreMousePosition(SDL_Window *window)
Definition: SDL_video.c:1168
@ SDL_WINDOWEVENT_RESIZED
Definition: SDL_video.h:155
Uint32 WINRT_DetectWindowFlags(SDL_Window *window)
void(* SetWindowFullscreen)(_THIS, SDL_Window *window, SDL_VideoDisplay *display, SDL_bool fullscreen)
Definition: SDL_sysvideo.h:231

References _this, CHECK_WINDOW_MAGIC, FULLSCREEN_MASK, FULLSCREEN_VISIBLE, SDL_VideoDisplay::fullscreen_window, SDL_DisplayMode::h, SDL_Window::h, SDL_VideoDevice::name, SDL_Window::next, NULL, SDL_FALSE, SDL_GetDisplayForWindow(), SDL_GetWindowDisplayMode(), SDL_MinimizeWindow(), SDL_OnWindowResized(), SDL_RestoreMousePosition(), SDL_SendWindowEvent(), SDL_SetDisplayModeForDisplay(), SDL_strcmp, SDL_TRUE, SDL_WINDOW_FULLSCREEN, SDL_WINDOW_FULLSCREEN_DESKTOP, SDL_WINDOWEVENT_RESIZED, SDL_zero, SDL_VideoDevice::SetWindowFullscreen, SDL_DisplayMode::w, SDL_Window::w, SDL_VideoDevice::windows, and WINRT_DetectWindowFlags().

Referenced by SDL_CreateWindow(), SDL_HideWindow(), SDL_MinimizeWindow(), SDL_OnWindowHidden(), SDL_OnWindowMinimized(), SDL_OnWindowRestored(), SDL_SetWindowFullscreen(), and SDL_SetWindowSize().

◆ SDL_UpdateWindowGrab()

void SDL_UpdateWindowGrab ( SDL_Window window)

Definition at line 2520 of file SDL_video.c.

2521{
2522 SDL_Window *grabbed_window;
2523 SDL_bool grabbed;
2524 if ((SDL_GetMouse()->relative_mode || (window->flags & SDL_WINDOW_INPUT_GRABBED)) &&
2525 (window->flags & SDL_WINDOW_INPUT_FOCUS)) {
2526 grabbed = SDL_TRUE;
2527 } else {
2528 grabbed = SDL_FALSE;
2529 }
2530
2531 grabbed_window = _this->grabbed_window;
2532 if (grabbed) {
2533 if (grabbed_window && (grabbed_window != window)) {
2534 /* stealing a grab from another window! */
2535 grabbed_window->flags &= ~SDL_WINDOW_INPUT_GRABBED;
2536 if (_this->SetWindowGrab) {
2537 _this->SetWindowGrab(_this, grabbed_window, SDL_FALSE);
2538 }
2539 }
2541 } else if (grabbed_window == window) {
2542 _this->grabbed_window = NULL; /* ungrabbing. */
2543 }
2544
2545 if (_this->SetWindowGrab) {
2546 _this->SetWindowGrab(_this, window, grabbed);
2547 }
2548}
void(* SetWindowGrab)(_THIS, SDL_Window *window, SDL_bool grabbed)
Definition: SDL_sysvideo.h:234

References _this, SDL_Window::flags, SDL_VideoDevice::grabbed_window, NULL, SDL_FALSE, SDL_GetMouse(), SDL_TRUE, SDL_WINDOW_INPUT_FOCUS, SDL_WINDOW_INPUT_GRABBED, and SDL_VideoDevice::SetWindowGrab.

Referenced by SDL_OnWindowFocusGained(), SDL_OnWindowFocusLost(), SDL_SetRelativeMouseMode(), and SDL_SetWindowGrab().

◆ SDL_UpdateWindowSurface()

int SDL_UpdateWindowSurface ( SDL_Window window)

Copy the window surface to the screen.

Returns
0 on success, or -1 on error.
See also
SDL_GetWindowSurface()
SDL_UpdateWindowSurfaceRects()

Definition at line 2328 of file SDL_video.c.

2329{
2330 SDL_Rect full_rect;
2331
2333
2334 full_rect.x = 0;
2335 full_rect.y = 0;
2336 full_rect.w = window->w;
2337 full_rect.h = window->h;
2338 return SDL_UpdateWindowSurfaceRects(window, &full_rect, 1);
2339}
int SDL_UpdateWindowSurfaceRects(SDL_Window *window, const SDL_Rect *rects, int numrects)
Copy a number of rectangles on the window surface to the screen.
Definition: SDL_video.c:2342

References CHECK_WINDOW_MAGIC, SDL_Rect::h, SDL_UpdateWindowSurfaceRects(), SDL_Rect::w, SDL_Rect::x, and SDL_Rect::y.

◆ SDL_UpdateWindowSurfaceRects()

int SDL_UpdateWindowSurfaceRects ( SDL_Window window,
const SDL_Rect rects,
int  numrects 
)

Copy a number of rectangles on the window surface to the screen.

Returns
0 on success, or -1 on error.
See also
SDL_GetWindowSurface()
SDL_UpdateWindowSurface()

Definition at line 2342 of file SDL_video.c.

2344{
2346
2347 if (!window->surface_valid) {
2348 return SDL_SetError("Window surface is invalid, please call SDL_GetWindowSurface() to get a new surface");
2349 }
2350
2351 return _this->UpdateWindowFramebuffer(_this, window, rects, numrects);
2352}
EGLSurface EGLint * rects
Definition: eglext.h:282

References _this, CHECK_WINDOW_MAGIC, SDL_SetError, and SDL_VideoDevice::UpdateWindowFramebuffer.

Referenced by SDL_UpdateWindowSurface().

◆ SDL_UpdateWindowTexture()

static int SDL_UpdateWindowTexture ( SDL_VideoDevice unused,
SDL_Window window,
const SDL_Rect rects,
int  numrects 
)
static

Definition at line 366 of file SDL_video.c.

367{
370 void *src;
371
373 if (!data || !data->texture) {
374 return SDL_SetError("No window texture data");
375 }
376
377 /* Update a single rect that contains subrects for best DMA performance */
378 if (SDL_GetSpanEnclosingRect(window->w, window->h, numrects, rects, &rect)) {
379 src = (void *)((Uint8 *)data->pixels +
380 rect.y * data->pitch +
381 rect.x * data->bytes_per_pixel);
382 if (SDL_UpdateTexture(data->texture, &rect, src, data->pitch) < 0) {
383 return -1;
384 }
385
386 if (SDL_RenderCopy(data->renderer, data->texture, NULL, NULL) < 0) {
387 return -1;
388 }
389
390 SDL_RenderPresent(data->renderer);
391 }
392 return 0;
393}
#define SDL_RenderPresent
#define SDL_UpdateTexture
#define SDL_RenderCopy
GLenum src
SDL_bool SDL_GetSpanEnclosingRect(int width, int height, int numrects, const SDL_Rect *rects, SDL_Rect *span)
Definition: SDL_rect.c:469
uint8_t Uint8
Definition: SDL_stdinc.h:179

References NULL, rect, SDL_GetSpanEnclosingRect(), SDL_GetWindowData(), SDL_RenderCopy, SDL_RenderPresent, SDL_SetError, SDL_UpdateTexture, SDL_WINDOWTEXTUREDATA, SDL_Rect::x, and SDL_Rect::y.

Referenced by SDL_VideoInit().

◆ SDL_VideoInit()

int SDL_VideoInit ( const char *  driver_name)

Initialize the video subsystem, optionally specifying a video driver.

Parameters
driver_nameInitialize a specific driver by name, or NULL for the default video driver.
Returns
0 on success, -1 on error

This function initializes the video subsystem; setting up a connection to the window manager, etc, and determines the available display modes and pixel formats, but does not initialize a window or graphics mode.

See also
SDL_VideoQuit()

Definition at line 461 of file SDL_video.c.

462{
463 SDL_VideoDevice *video;
464 int index;
465 int i;
466
467 /* Check to make sure we don't overwrite '_this' */
468 if (_this != NULL) {
470 }
471
472#if !SDL_TIMERS_DISABLED
474#endif
475
476 /* Start the event loop */
478 SDL_KeyboardInit() < 0 ||
479 SDL_MouseInit() < 0 ||
480 SDL_TouchInit() < 0) {
481 return -1;
482 }
483
484 /* Select the proper video driver */
485 index = 0;
486 video = NULL;
487 if (driver_name == NULL) {
488 driver_name = SDL_getenv("SDL_VIDEODRIVER");
489 }
490 if (driver_name != NULL) {
491 for (i = 0; bootstrap[i]; ++i) {
492 if (SDL_strncasecmp(bootstrap[i]->name, driver_name, SDL_strlen(driver_name)) == 0) {
493 if (bootstrap[i]->available()) {
494 video = bootstrap[i]->create(index);
495 break;
496 }
497 }
498 }
499 } else {
500 for (i = 0; bootstrap[i]; ++i) {
501 if (bootstrap[i]->available()) {
502 video = bootstrap[i]->create(index);
503 if (video != NULL) {
504 break;
505 }
506 }
507 }
508 }
509 if (video == NULL) {
510 if (driver_name) {
511 return SDL_SetError("%s not available", driver_name);
512 }
513 return SDL_SetError("No available video device");
514 }
515 _this = video;
518
519
520 /* Set some very sane GL defaults */
524
527
528 /* Initialize the video subsystem */
529 if (_this->VideoInit(_this) < 0) {
531 return -1;
532 }
533
534 /* Make sure some displays were added */
535 if (_this->num_displays == 0) {
537 return SDL_SetError("The video driver did not add any displays");
538 }
539
540 /* Add the renderer framebuffer emulation if desired */
545 }
546
547 /* Disable the screen saver by default. This is a change from <= 2.0.1,
548 but most things using SDL are games or media players; you wouldn't
549 want a screensaver to trigger if you're playing exclusively with a
550 joystick, or passively watching a movie. Things that use SDL but
551 function more like a normal desktop app should explicitly reenable the
552 screensaver. */
555 }
556
557 /* If we don't use a screen keyboard, turn on text input by default,
558 otherwise programs that expect to get text events without enabling
559 UNICODE input won't get any events.
560
561 Actually, come to think of it, you needed to call SDL_EnableUNICODE(1)
562 in SDL 1.2 before you got text input events. Hmm...
563 */
566 }
567
568 /* We're ready to go! */
569 return 0;
570}
#define SDL_INIT_EVENTS
Definition: SDL.h:83
#define SDL_TLSCreate
#define SDL_InitSubSystem
#define SDL_strncasecmp
#define SDL_HINT_VIDEO_ALLOW_SCREENSAVER
A variable controlling whether the screensaver is enabled.
Definition: SDL_hints.h:165
int SDL_KeyboardInit(void)
Definition: SDL_keyboard.c:562
int SDL_MouseInit(void)
Definition: SDL_mouse.c:135
void SDL_TicksInit(void)
int SDL_TouchInit(void)
Definition: SDL_touch.c:46
SDL_bool SDL_HasScreenKeyboardSupport(void)
Returns whether the platform has some screen keyboard support.
Definition: SDL_video.c:3811
static SDL_bool ShouldUseTextureFramebuffer()
Definition: SDL_video.c:166
static void SDL_DestroyWindowTexture(SDL_VideoDevice *unused, SDL_Window *window)
Definition: SDL_video.c:396
static int SDL_CreateWindowTexture(SDL_VideoDevice *unused, SDL_Window *window, Uint32 *format, void **pixels, int *pitch)
Definition: SDL_video.c:256
void SDL_DisableScreenSaver()
Prevent the screen from being blanked by a screensaver.
Definition: SDL_video.c:2813
void SDL_StartTextInput(void)
Start accepting Unicode text input events. This function will show the on-screen keyboard if supporte...
Definition: SDL_video.c:3755
void SDL_GL_ResetAttributes()
Reset all previously set OpenGL context attributes to their default values.
Definition: SDL_video.c:3069
static int SDL_UpdateWindowTexture(SDL_VideoDevice *unused, SDL_Window *window, const SDL_Rect *rects, int numrects)
Definition: SDL_video.c:366
void SDL_VideoQuit(void)
Shuts down the video subsystem.
Definition: SDL_video.c:2828
int(* VideoInit)(_THIS)
Definition: SDL_sysvideo.h:161
SDL_VideoDevice *(* create)(int devindex)
Definition: SDL_sysvideo.h:402
static int available()
Definition: video.c:356

References _this, available(), bootstrap, VideoBootStrap::create, SDL_VideoDevice::CreateWindowFramebuffer, SDL_VideoDevice::current_glctx_tls, SDL_VideoDevice::current_glwin_tls, SDL_VideoDevice::DestroyWindowFramebuffer, SDL_VideoDevice::dll_handle, SDL_VideoDevice::driver_loaded, SDL_VideoDevice::gl_config, i, SDL_VideoDevice::name, VideoBootStrap::name, SDL_VideoDevice::next_object_id, NULL, SDL_VideoDevice::num_displays, SDL_CreateWindowTexture(), SDL_DestroyWindowTexture(), SDL_DisableScreenSaver(), SDL_FALSE, SDL_getenv, SDL_GetHintBoolean, SDL_GL_ResetAttributes(), SDL_HasScreenKeyboardSupport(), SDL_HINT_VIDEO_ALLOW_SCREENSAVER, SDL_INIT_EVENTS, SDL_InitSubSystem, SDL_KeyboardInit(), SDL_MouseInit(), SDL_SetError, SDL_StartTextInput(), SDL_strlen, SDL_strncasecmp, SDL_TicksInit(), SDL_TLSCreate, SDL_TouchInit(), SDL_UpdateWindowTexture(), SDL_VideoQuit(), ShouldUseTextureFramebuffer(), SDL_VideoDevice::UpdateWindowFramebuffer, and SDL_VideoDevice::VideoInit.

Referenced by SDL_CreateWindow().

◆ SDL_VideoQuit()

void SDL_VideoQuit ( void  )

Shuts down the video subsystem.

This function closes all windows, and restores the original video mode.

See also
SDL_VideoInit()

Definition at line 2828 of file SDL_video.c.

2829{
2830 int i, j;
2831
2832 if (!_this) {
2833 return;
2834 }
2835
2836 /* Halt event processing before doing anything else */
2837 SDL_TouchQuit();
2838 SDL_MouseQuit();
2841
2843
2844 /* Clean up the system video */
2845 while (_this->windows) {
2847 }
2849
2850 for (i = 0; i < _this->num_displays; ++i) {
2851 SDL_VideoDisplay *display = &_this->displays[i];
2852 for (j = display->num_display_modes; j--;) {
2854 display->display_modes[j].driverdata = NULL;
2855 }
2856 SDL_free(display->display_modes);
2857 display->display_modes = NULL;
2859 display->desktop_mode.driverdata = NULL;
2860 SDL_free(display->driverdata);
2861 display->driverdata = NULL;
2862 }
2863 if (_this->displays) {
2864 for (i = 0; i < _this->num_displays; ++i) {
2866 }
2868 _this->displays = NULL;
2869 _this->num_displays = 0;
2870 }
2873 _this->free(_this);
2874 _this = NULL;
2875}
#define SDL_QuitSubSystem
void SDL_KeyboardQuit(void)
Definition: SDL_keyboard.c:832
void SDL_MouseQuit(void)
Definition: SDL_mouse.c:665
void SDL_TouchQuit(void)
Definition: SDL_touch.c:473
void SDL_EnableScreenSaver()
Allow the screen to be blanked by a screensaver.
Definition: SDL_video.c:2798
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int int in j)
Definition: SDL_x11sym.h:50
void(* VideoQuit)(_THIS)
Definition: SDL_sysvideo.h:167
void(* free)(_THIS)
Definition: SDL_sysvideo.h:394
char * clipboard_text
Definition: SDL_sysvideo.h:321

References _this, SDL_VideoDevice::clipboard_text, SDL_VideoDisplay::desktop_mode, SDL_VideoDisplay::display_modes, SDL_VideoDevice::displays, SDL_DisplayMode::driverdata, SDL_VideoDisplay::driverdata, SDL_VideoDevice::free, i, j, SDL_VideoDisplay::name, NULL, SDL_VideoDisplay::num_display_modes, SDL_VideoDevice::num_displays, SDL_DestroyWindow(), SDL_EnableScreenSaver(), SDL_free, SDL_INIT_EVENTS, SDL_KeyboardQuit(), SDL_MouseQuit(), SDL_QuitSubSystem, SDL_TouchQuit(), SDL_VideoDevice::VideoQuit, and SDL_VideoDevice::windows.

Referenced by SDL_VideoInit().

◆ SDL_Vulkan_CreateSurface()

SDL_bool SDL_Vulkan_CreateSurface ( SDL_Window window,
VkInstance  instance,
VkSurfaceKHR *  surface 
)

Create a Vulkan rendering surface for a window.

Parameters
[in]windowSDL_Window to which to attach the rendering surface.
[in]instancehandle to the Vulkan instance to use.
[out]surfacepointer to a VkSurfaceKHR handle to receive the handle of the newly created surface.
Returns
SDL_TRUE on success, SDL_FALSE on error.
VkInstance instance;
// create instance and window
// create the Vulkan surface
VkSurfaceKHR surface;
handle_error();
#define SDL_Vulkan_CreateSurface
EGLSurface surface
Definition: eglext.h:248
Note
window should have been created with the SDL_WINDOW_VULKAN flag.
instance should have been created with the extensions returned by SDL_Vulkan_CreateSurface() enabled.
See also
SDL_Vulkan_GetInstanceExtensions()

Definition at line 4151 of file SDL_video.c.

4154{
4156
4157 if (!(window->flags & SDL_WINDOW_VULKAN)) {
4159 return SDL_FALSE;
4160 }
4161
4162 if (!instance) {
4163 SDL_InvalidParamError("instance");
4164 return SDL_FALSE;
4165 }
4166
4167 if (!surface) {
4168 SDL_InvalidParamError("surface");
4169 return SDL_FALSE;
4170 }
4171
4172 return _this->Vulkan_CreateSurface(_this, window, instance, surface);
4173}
#define NOT_A_VULKAN_WINDOW
Definition: SDL_video.c:4074

References _this, CHECK_WINDOW_MAGIC, NOT_A_VULKAN_WINDOW, SDL_FALSE, SDL_InvalidParamError, SDL_SetError, SDL_WINDOW_VULKAN, and SDL_VideoDevice::Vulkan_CreateSurface.

◆ SDL_Vulkan_GetDrawableSize()

void SDL_Vulkan_GetDrawableSize ( SDL_Window window,
int *  w,
int *  h 
)

Get the size of a window's underlying drawable in pixels (for use with setting viewport, scissor & etc).

Parameters
windowSDL_Window from which the drawable size should be queried
wPointer to variable for storing the width in pixels, may be NULL
hPointer to variable for storing the height in pixels, may be NULL

This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI drawable, i.e. the window was created with SDL_WINDOW_ALLOW_HIGHDPI on a platform with high-DPI support (Apple calls this "Retina"), and not disabled by the SDL_HINT_VIDEO_HIGHDPI_DISABLED hint.

Note
On macOS high-DPI support must be enabled for an application by setting NSHighResolutionCapable to true in its Info.plist.
See also
SDL_GetWindowSize()
SDL_CreateWindow()

Definition at line 4175 of file SDL_video.c.

4176{
4178
4181 } else {
4183 }
4184}
void(* Vulkan_GetDrawableSize)(_THIS, SDL_Window *window, int *w, int *h)
Definition: SDL_sysvideo.h:275

References _this, CHECK_WINDOW_MAGIC, SDL_GetWindowSize(), and SDL_VideoDevice::Vulkan_GetDrawableSize.

◆ SDL_Vulkan_GetInstanceExtensions()

SDL_bool SDL_Vulkan_GetInstanceExtensions ( SDL_Window window,
unsigned *  count,
const char **  names 
)

Definition at line 4131 of file SDL_video.c.

4132{
4133 if (window) {
4135
4136 if (!(window->flags & SDL_WINDOW_VULKAN))
4137 {
4139 return SDL_FALSE;
4140 }
4141 }
4142
4143 if (!count) {
4144 SDL_InvalidParamError("count");
4145 return SDL_FALSE;
4146 }
4147
4149}
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1571
GLuint GLuint * names
SDL_bool(* Vulkan_GetInstanceExtensions)(_THIS, SDL_Window *window, unsigned *count, const char **names)
Definition: SDL_sysvideo.h:273

References _this, CHECK_WINDOW_MAGIC, NOT_A_VULKAN_WINDOW, SDL_FALSE, SDL_InvalidParamError, SDL_SetError, SDL_WINDOW_VULKAN, and SDL_VideoDevice::Vulkan_GetInstanceExtensions.

◆ SDL_Vulkan_GetVkGetInstanceProcAddr()

void * SDL_Vulkan_GetVkGetInstanceProcAddr ( void  )

Get the address of the vkGetInstanceProcAddr function.

Note
This should be called after either calling SDL_Vulkan_LoadLibrary or creating an SDL_Window with the SDL_WINDOW_VULKAN flag.

Definition at line 4102 of file SDL_video.c.

4103{
4104 if (!_this) {
4106 return NULL;
4107 }
4109 SDL_SetError("No Vulkan loader has been loaded");
4110 return NULL;
4111 }
4113}
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr
Definition: SDL_sysvideo.h:372
struct SDL_VideoDevice::@263 vulkan_config

References _this, SDL_VideoDevice::loader_loaded, NULL, SDL_SetError, SDL_UninitializedVideo(), SDL_VideoDevice::vkGetInstanceProcAddr, and SDL_VideoDevice::vulkan_config.

◆ SDL_Vulkan_LoadLibrary()

int SDL_Vulkan_LoadLibrary ( const char *  path)

Dynamically load a Vulkan loader library.

Parameters
[in]pathThe platform dependent Vulkan loader library name, or NULL.
Returns
0 on success, or -1 if the library couldn't be loaded.

If path is NULL SDL will use the value of the environment variable SDL_VULKAN_LIBRARY, if set, otherwise it loads the default Vulkan loader library.

This should be called after initializing the video driver, but before creating any Vulkan windows. If no Vulkan loader library is loaded, the default library will be loaded upon creation of the first Vulkan window.

Note
It is fairly common for Vulkan applications to link with libvulkan instead of explicitly loading it at run time. This will work with SDL provided the application links to a dynamic library and both it and SDL use the same search path.
If you specify a non-NULL path, an application should retrieve all of the Vulkan functions it uses from the dynamic library using SDL_Vulkan_GetVkGetInstanceProcAddr() unless you can guarantee path points to the same vulkan loader library the application linked to.
On Apple devices, if path is NULL, SDL will attempt to find the vkGetInstanceProcAddr address within all the mach-o images of the current process. This is because it is fairly common for Vulkan applications to link with libvulkan (and historically MoltenVK was provided as a static library). If it is not found then, on macOS, SDL will attempt to load vulkan.framework/vulkan, libvulkan.1.dylib, followed by libvulkan.dylib, in that order. On iOS SDL will attempt to load libvulkan.dylib only. Applications using a dynamic framework or .dylib must ensure it is included in its application bundle.
On non-Apple devices, application linking with a static libvulkan is not supported. Either do not link to the Vulkan loader or link to a dynamic library version.
This function will fail if there are no working Vulkan drivers installed.
See also
SDL_Vulkan_GetVkGetInstanceProcAddr()
SDL_Vulkan_UnloadLibrary()

Definition at line 4076 of file SDL_video.c.

4077{
4078 int retval;
4079 if (!_this) {
4081 return -1;
4082 }
4085 return SDL_SetError("Vulkan loader library already loaded");
4086 }
4087 retval = 0;
4088 } else {
4089 if (!_this->Vulkan_LoadLibrary) {
4090 return SDL_SetError("Vulkan support is either not configured in SDL "
4091 "or not available in current SDL video driver "
4092 "(%s) or platform", _this->name);
4093 }
4095 }
4096 if (retval == 0) {
4098 }
4099 return retval;
4100}
int(* Vulkan_LoadLibrary)(_THIS, const char *path)
Definition: SDL_sysvideo.h:271
char loader_path[256]
Definition: SDL_sysvideo.h:375

References _this, SDL_VideoDevice::loader_loaded, SDL_VideoDevice::loader_path, SDL_VideoDevice::name, retval, SDL_SetError, SDL_strcmp, SDL_UninitializedVideo(), SDL_VideoDevice::vulkan_config, and SDL_VideoDevice::Vulkan_LoadLibrary.

Referenced by SDL_CreateWindow().

◆ SDL_Vulkan_UnloadLibrary()

void SDL_Vulkan_UnloadLibrary ( void  )

Unload the Vulkan loader library previously loaded by SDL_Vulkan_LoadLibrary().

See also
SDL_Vulkan_LoadLibrary()

Definition at line 4115 of file SDL_video.c.

4116{
4117 if (!_this) {
4119 return;
4120 }
4122 if (--_this->vulkan_config.loader_loaded > 0) {
4123 return;
4124 }
4127 }
4128 }
4129}
void(* Vulkan_UnloadLibrary)(_THIS)
Definition: SDL_sysvideo.h:272

References _this, SDL_VideoDevice::loader_loaded, SDL_UninitializedVideo(), SDL_VideoDevice::vulkan_config, and SDL_VideoDevice::Vulkan_UnloadLibrary.

Referenced by SDL_DestroyWindow().

◆ ShouldMinimizeOnFocusLoss()

static SDL_bool ShouldMinimizeOnFocusLoss ( SDL_Window window)
static

Definition at line 2653 of file SDL_video.c.

2654{
2655 if (!(window->flags & SDL_WINDOW_FULLSCREEN) || window->is_destroying) {
2656 return SDL_FALSE;
2657 }
2658
2659#ifdef __MACOSX__
2660 if (SDL_strcmp(_this->name, "cocoa") == 0) { /* don't do this for X11, etc */
2661 if (Cocoa_IsWindowInFullscreenSpace(window)) {
2662 return SDL_FALSE;
2663 }
2664 }
2665#endif
2666
2667#ifdef __ANDROID__
2668 {
2671 return SDL_FALSE;
2672 }
2673 }
2674#endif
2675
2677}
SDL_bool Android_JNI_ShouldMinimizeOnFocusLoss(void)
#define SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS
Minimize your SDL_Window if it loses key focus when in fullscreen mode. Defaults to true.
Definition: SDL_hints.h:332

References _this, Android_JNI_ShouldMinimizeOnFocusLoss(), SDL_VideoDevice::name, SDL_FALSE, SDL_GetHintBoolean, SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, SDL_strcmp, SDL_TRUE, and SDL_WINDOW_FULLSCREEN.

Referenced by SDL_OnWindowFocusLost().

◆ ShouldUseTextureFramebuffer()

static SDL_bool ShouldUseTextureFramebuffer ( )
static

Definition at line 166 of file SDL_video.c.

167{
168 const char *hint;
169
170 /* If there's no native framebuffer support then there's no option */
172 return SDL_TRUE;
173 }
174
175 /* If this is the dummy driver there is no texture support */
176 if (_this->is_dummy) {
177 return SDL_FALSE;
178 }
179
180 /* If the user has specified a software renderer we can't use a
181 texture framebuffer, or renderer creation will go recursive.
182 */
184 if (hint && SDL_strcasecmp(hint, "software") == 0) {
185 return SDL_FALSE;
186 }
187
188 /* See if the user or application wants a specific behavior */
190 if (hint) {
191 if (*hint == '0' || SDL_strcasecmp(hint, "false") == 0) {
192 return SDL_FALSE;
193 } else {
194 return SDL_TRUE;
195 }
196 }
197
198 /* Each platform has different performance characteristics */
199#if defined(__WIN32__)
200 /* GDI BitBlt() is way faster than Direct3D dynamic textures right now.
201 */
202 return SDL_FALSE;
203
204#elif defined(__MACOSX__)
205 /* Mac OS X uses OpenGL as the native fast path (for cocoa and X11) */
206 return SDL_TRUE;
207
208#elif defined(__LINUX__)
209 /* Properly configured OpenGL drivers are faster than MIT-SHM */
210#if SDL_VIDEO_OPENGL
211 /* Ugh, find a way to cache this value! */
212 {
215 SDL_bool hasAcceleratedOpenGL = SDL_FALSE;
216
217 window = SDL_CreateWindow("OpenGL test", -32, -32, 32, 32, SDL_WINDOW_OPENGL|SDL_WINDOW_HIDDEN);
218 if (window) {
220 if (context) {
221 const GLubyte *(APIENTRY * glGetStringFunc) (GLenum);
222 const char *vendor = NULL;
223
224 glGetStringFunc = SDL_GL_GetProcAddress("glGetString");
225 if (glGetStringFunc) {
226 vendor = (const char *) glGetStringFunc(GL_VENDOR);
227 }
228 /* Add more vendors here at will... */
229 if (vendor &&
230 (SDL_strstr(vendor, "ATI Technologies") ||
231 SDL_strstr(vendor, "NVIDIA"))) {
232 hasAcceleratedOpenGL = SDL_TRUE;
233 }
235 }
237 }
238 return hasAcceleratedOpenGL;
239 }
240#elif SDL_VIDEO_OPENGL_ES || SDL_VIDEO_OPENGL_ES2
241 /* Let's be optimistic about this! */
242 return SDL_TRUE;
243#else
244 return SDL_FALSE;
245#endif
246
247#else
248 /* Play it safe, assume that if there is a framebuffer driver that it's
249 optimized for the current platform.
250 */
251 return SDL_FALSE;
252#endif
253}
#define SDL_HINT_RENDER_DRIVER
A variable specifying which render driver to use.
Definition: SDL_hints.h:85
#define GL_VENDOR
Definition: SDL_opengl.h:713
SDL_GLContext SDL_GL_CreateContext(SDL_Window *window)
Create an OpenGL context for use with an OpenGL window, and make it current.
Definition: SDL_video.c:3493
SDL_Window * SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)
Create a window with the specified position, dimensions, and flags.
Definition: SDL_video.c:1405
void SDL_GL_DeleteContext(SDL_GLContext context)
Delete an OpenGL context.
Definition: SDL_video.c:3624

References _this, APIENTRY, context, SDL_VideoDevice::CreateWindowFramebuffer, GL_VENDOR, SDL_VideoDevice::is_dummy, NULL, SDL_CreateWindow(), SDL_DestroyWindow(), SDL_FALSE, SDL_GetHint, SDL_GL_CreateContext(), SDL_GL_DeleteContext(), SDL_GL_GetProcAddress(), SDL_HINT_FRAMEBUFFER_ACCELERATION, SDL_HINT_RENDER_DRIVER, SDL_strcasecmp, SDL_strstr, SDL_TRUE, SDL_WINDOW_HIDDEN, and SDL_WINDOW_OPENGL.

Referenced by SDL_VideoInit().

Variable Documentation

◆ _this

SDL_VideoDevice* _this = NULL
static

Definition at line 118 of file SDL_video.c.

Referenced by CanMinimizeWindow(), PrepareDragAndDropSupport(), SDL_AddVideoDisplay(), SDL_CreateWindow(), SDL_CreateWindowFramebuffer(), SDL_CreateWindowFrom(), SDL_DestroyWindow(), SDL_DisableScreenSaver(), SDL_EnableScreenSaver(), SDL_GetClipboardText(), SDL_GetClosestDisplayMode(), SDL_GetCurrentDisplayMode(), SDL_GetCurrentVideoDriver(), SDL_GetDesktopDisplayMode(), SDL_GetDisplay(), SDL_GetDisplayBounds(), SDL_GetDisplayDPI(), SDL_GetDisplayDriverData(), SDL_GetDisplayForWindow(), SDL_GetDisplayMode(), SDL_GetDisplayName(), SDL_GetDisplayOrientation(), SDL_GetDisplayUsableBounds(), SDL_GetFocusWindow(), SDL_GetGrabbedWindow(), SDL_GetIndexOfDisplay(), SDL_GetNumDisplayModes(), SDL_GetNumDisplayModesForDisplay(), SDL_GetNumVideoDisplays(), SDL_GetVideoDevice(), SDL_GetWindowBordersSize(), SDL_GetWindowDisplayIndex(), SDL_GetWindowFromID(), SDL_GetWindowGammaRamp(), SDL_GetWindowGrab(), SDL_GetWindowWMInfo(), SDL_GL_CreateContext(), SDL_GL_DeleteContext(), SDL_GL_GetAttribute(), SDL_GL_GetCurrentContext(), SDL_GL_GetCurrentWindow(), SDL_GL_GetDrawableSize(), SDL_GL_GetProcAddress(), SDL_GL_GetSwapInterval(), SDL_GL_LoadLibrary(), SDL_GL_MakeCurrent(), SDL_GL_ResetAttributes(), SDL_GL_SetAttribute(), SDL_GL_SetSwapInterval(), SDL_GL_SwapWindow(), SDL_GL_UnloadLibrary(), SDL_HasClipboardText(), SDL_HasScreenKeyboardSupport(), SDL_HasWindows(), SDL_HideWindow(), SDL_IsScreenKeyboardShown(), SDL_IsScreenSaverEnabled(), SDL_MaximizeWindow(), SDL_MinimizeWindow(), SDL_OnApplicationDidBecomeActive(), SDL_OnApplicationWillResignActive(), SDL_OnWindowEnter(), SDL_OnWindowFocusGained(), SDL_OnWindowFocusLost(), SDL_PumpEvents(), SDL_RaiseWindow(), SDL_RecreateWindow(), SDL_RestoreWindow(), SDL_SetClipboardText(), SDL_SetDisplayModeForDisplay(), SDL_SetTextInputRect(), SDL_SetWindowBordered(), SDL_SetWindowGammaRamp(), SDL_SetWindowHitTest(), SDL_SetWindowIcon(), SDL_SetWindowInputFocus(), SDL_SetWindowMaximumSize(), SDL_SetWindowMinimumSize(), SDL_SetWindowModalFor(), SDL_SetWindowOpacity(), SDL_SetWindowPosition(), SDL_SetWindowResizable(), SDL_SetWindowSize(), SDL_SetWindowTitle(), SDL_ShowMessageBox(), SDL_ShowWindow(), SDL_StartTextInput(), SDL_StopTextInput(), SDL_ToggleDragAndDropSupport(), SDL_UpdateFullscreenMode(), SDL_UpdateWindowGrab(), SDL_UpdateWindowSurfaceRects(), SDL_VideoInit(), SDL_VideoQuit(), SDL_Vulkan_CreateSurface(), SDL_Vulkan_GetDrawableSize(), SDL_Vulkan_GetInstanceExtensions(), SDL_Vulkan_GetVkGetInstanceProcAddr(), SDL_Vulkan_LoadLibrary(), SDL_Vulkan_UnloadLibrary(), ShouldMinimizeOnFocusLoss(), ShouldUseTextureFramebuffer(), and videoInit().

◆ bootstrap

VideoBootStrap* bootstrap[]
static

Definition at line 60 of file SDL_video.c.

Referenced by SDL_GetNumVideoDrivers(), SDL_GetVideoDriver(), and SDL_VideoInit().