sdl-ios-xcode: include/SDL_video.h comparison

comparison include/SDL_video.h @ 1662:782fd950bd46 SDL-1.3

Revamp of the video system in progress - adding support for multiple displays, multiple windows, and a full video mode selection API. WARNING: None of the video drivers have been updated for the new API yet! The API is still under design and very fluid. The code is now run through a consistent indent format: indent -i4 -nut -nsc -br -ce The headers are being converted to automatically generate doxygen documentation.

author	Sam Lantinga <slouken@libsdl.org>
date	Sun, 28 May 2006 13:04:16 +0000
parents	8b9d79e7eacf
children	4da1ee79c9af

comparison

equal deleted inserted replaced

-:281d3f4870e5
+:782fd950bd46
 Sam Lantinga
 slouken@libsdl.org
 */
-/* Header file for access to the SDL raw framebuffer window */
+/**
+* \file SDL_video.h
+*
+* Header file for access to the SDL raw framebuffer window
+*/
 #ifndef _SDL_video_h
 #define _SDL_video_h
 #include "SDL_stdinc.h"
 #include "SDL_error.h"
+#include "SDL_pixels.h"
 #include "SDL_rwops.h"
 #include "begin_code.h"
 /* Set up for C function definitions, even when using C++ */
 #ifdef __cplusplus
+/* *INDENT-OFF* */
 extern "C" {
+/* *INDENT-ON* */
 #endif
 /* Transparency definitions: These define alpha as the opacity of a surface */
 #define SDL_ALPHA_OPAQUE 255
 #define SDL_ALPHA_TRANSPARENT 0
 /* Useful data types */
-typedef struct SDL_Rect {
+typedef struct SDL_Rect
-	Sint16 x, y;
+{
-	Uint16 w, h;
+Sint16 x, y;
+Uint16 w, h;
 } SDL_Rect;
-typedef struct SDL_Color {
-	Uint8 r;
-	Uint8 g;
-	Uint8 b;
-	Uint8 unused;
-} SDL_Color;
-#define SDL_Colour SDL_Color
-typedef struct SDL_Palette {
-	int       ncolors;
-	SDL_Color *colors;
-} SDL_Palette;
-/* Everything in the pixel format structure is read-only */
-typedef struct SDL_PixelFormat {
-	SDL_Palette *palette;
-	Uint8  BitsPerPixel;
-	Uint8  BytesPerPixel;
-	Uint8  Rloss;
-	Uint8  Gloss;
-	Uint8  Bloss;
-	Uint8  Aloss;
-	Uint8  Rshift;
-	Uint8  Gshift;
-	Uint8  Bshift;
-	Uint8  Ashift;
-	Uint32 Rmask;
-	Uint32 Gmask;
-	Uint32 Bmask;
-	Uint32 Amask;
-	/* RGB color key information */
-	Uint32 colorkey;
-	/* Alpha value information (per-surface alpha) */
-	Uint8  alpha;
-} SDL_PixelFormat;
 /* This structure should be treated as read-only, except for 'pixels',
 which, if not NULL, contains the raw pixel data for the surface.
 */
-typedef struct SDL_Surface {
+typedef struct SDL_Surface
-	Uint32 flags;				/* Read-only */
+{
-	SDL_PixelFormat *format;		/* Read-only */
+Uint32 flags;               /* Read-only */
-	int w, h;				/* Read-only */
+SDL_PixelFormat *format;    /* Read-only */
-	Uint16 pitch;				/* Read-only */
+int w, h;                   /* Read-only */
-	void *pixels;				/* Read-write */
+Uint16 pitch;               /* Read-only */
-	int offset;				/* Private */
+void *pixels;               /* Read-write */
+int offset;                 /* Private */
-	/* Hardware-specific surface info */
-	struct private_hwdata *hwdata;
+/* Hardware-specific surface info */
+struct private_hwdata *hwdata;
-	/* clipping information */
-	SDL_Rect clip_rect;			/* Read-only */
+/* clipping information */
-	Uint32 unused1;				/* for binary compatibility */
+SDL_Rect clip_rect;         /* Read-only */
+Uint32 unused1;             /* for binary compatibility */
-	/* Allow recursive locks */
-	Uint32 locked;				/* Private */
+/* Allow recursive locks */
+Uint32 locked;              /* Private */
-	/* info for fast blit mapping to other surfaces */
-	struct SDL_BlitMap *map;		/* Private */
+/* info for fast blit mapping to other surfaces */
+struct SDL_BlitMap *map;    /* Private */
-	/* format version, bumped at every change to invalidate blit maps */
-	unsigned int format_version;		/* Private */
+/* format version, bumped at every change to invalidate blit maps */
+unsigned int format_version;        /* Private */
-	/* Reference count -- used when freeing surface */
-	int refcount;				/* Read-mostly */
+/* Reference count -- used when freeing surface */
+int refcount;               /* Read-mostly */
 } SDL_Surface;
-/* These are the currently supported flags for the SDL_surface */
+/* The most common video overlay formats.
-/* Available for SDL_CreateRGBSurface() or SDL_SetVideoMode() */
+For an explanation of these pixel formats, see:
-#define SDL_SWSURFACE	0x00000000	/* Surface is in system memory */
+	http://www.webartz.com/fourcc/indexyuv.htm
-#define SDL_HWSURFACE	0x00000001	/* Surface is in video memory */
-#define SDL_ASYNCBLIT	0x00000004	/* Use asynchronous blits if possible */
+For information on the relationship between color spaces, see:
-/* Available for SDL_SetVideoMode() */
+http://www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html
-#define SDL_ANYFORMAT	0x10000000	/* Allow any video depth/pixel-format */
+*/
-#define SDL_HWPALETTE	0x20000000	/* Surface has exclusive palette */
+#define SDL_YV12_OVERLAY  0x32315659    /* Planar mode: Y + V + U  (3 planes) */
-#define SDL_DOUBLEBUF	0x40000000	/* Set up double-buffered video mode */
+#define SDL_IYUV_OVERLAY  0x56555949    /* Planar mode: Y + U + V  (3 planes) */
-#define SDL_FULLSCREEN	0x80000000	/* Surface is a full screen display */
+#define SDL_YUY2_OVERLAY  0x32595559    /* Packed mode: Y0+U0+Y1+V0 (1 plane) */
-#define SDL_OPENGL      0x00000002      /* Create an OpenGL rendering context */
+#define SDL_UYVY_OVERLAY  0x59565955    /* Packed mode: U0+Y0+V0+Y1 (1 plane) */
-#define SDL_INTERNALOPENGL 0x00000008   /* SDL uses OpenGL internally for this window */
+#define SDL_YVYU_OVERLAY  0x55595659    /* Packed mode: Y0+V0+Y1+U0 (1 plane) */
-#define SDL_RESIZABLE	0x00000010	/* This video mode may be resized */
-#define SDL_NOFRAME	0x00000020	/* No window caption or edge frame */
+/* The YUV hardware video overlay */
-/* Used internally (read-only) */
+typedef struct SDL_Overlay
-#define SDL_HWACCEL	0x00000100	/* Blit uses hardware acceleration */
+{
-#define SDL_SRCCOLORKEY	0x00001000	/* Blit uses a source color key */
+Uint32 format;              /* Read-only */
-#define SDL_RLEACCELOK	0x00002000	/* Private flag */
+int w, h;                   /* Read-only */
-#define SDL_RLEACCEL	0x00004000	/* Surface is RLE encoded */
+int planes;                 /* Read-only */
-#define SDL_SRCALPHA	0x00010000	/* Blit uses source alpha blending */
+Uint16 *pitches;            /* Read-only */
-#define SDL_PREALLOC	0x01000000	/* Surface uses preallocated memory */
+Uint8 **pixels;             /* Read-write */
+/* Hardware-specific surface info */
+struct private_yuvhwfuncs *hwfuncs;
+struct private_yuvhwdata *hwdata;
+/* Special flags */
+Uint32 hw_overlay:1;        /* Flag: This overlay hardware accelerated? */
+Uint32 UnusedBits:31;
+} SDL_Overlay;
 /* Evaluates to true if the surface needs to be locked before access */
 #define SDL_MUSTLOCK(surface)	\
 (surface->offset ||		\
-((surface->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_RLEACCEL)) != 0))
+((surface->flags & (SDL_HWSURFACE|SDL_RLEACCEL)) != 0))
 /* typedef for private surface blitting functions */
-typedef int (*SDL_blit)(struct SDL_Surface *src, SDL_Rect *srcrect,
+typedef int (*SDL_blit) (struct SDL_Surface * src, SDL_Rect * srcrect,
-			struct SDL_Surface *dst, SDL_Rect *dstrect);
+struct SDL_Surface * dst, SDL_Rect * dstrect);
 /* Useful for determining the video hardware capabilities */
-typedef struct SDL_VideoInfo {
+typedef struct SDL_VideoInfo
-	Uint32 hw_available :1;	/* Flag: Can you create hardware surfaces? */
+{
-	Uint32 wm_available :1;	/* Flag: Can you talk to a window manager? */
+Uint32 hw_available:1;      /* Flag: Can you create hardware surfaces? */
-	Uint32 UnusedBits1  :6;
+Uint32 wm_available:1;      /* Flag: Can you talk to a window manager? */
-	Uint32 UnusedBits2  :1;
+Uint32 UnusedBits1:6;
-	Uint32 blit_hw      :1;	/* Flag: Accelerated blits HW --> HW */
+Uint32 UnusedBits2:1;
-	Uint32 blit_hw_CC   :1;	/* Flag: Accelerated blits with Colorkey */
+Uint32 blit_hw:1;           /* Flag: Accelerated blits HW --> HW */
-	Uint32 blit_hw_A    :1;	/* Flag: Accelerated blits with Alpha */
+Uint32 blit_hw_CC:1;        /* Flag: Accelerated blits with Colorkey */
-	Uint32 blit_sw      :1;	/* Flag: Accelerated blits SW --> HW */
+Uint32 blit_hw_A:1;         /* Flag: Accelerated blits with Alpha */
-	Uint32 blit_sw_CC   :1;	/* Flag: Accelerated blits with Colorkey */
+Uint32 blit_sw:1;           /* Flag: Accelerated blits SW --> HW */
-	Uint32 blit_sw_A    :1;	/* Flag: Accelerated blits with Alpha */
+Uint32 blit_sw_CC:1;        /* Flag: Accelerated blits with Colorkey */
-	Uint32 blit_fill    :1;	/* Flag: Accelerated color fill */
+Uint32 blit_sw_A:1;         /* Flag: Accelerated blits with Alpha */
-	Uint32 UnusedBits3  :16;
+Uint32 blit_fill:1;         /* Flag: Accelerated color fill */
-	Uint32 video_mem;	/* The total amount of video memory (in K) */
+Uint32 UnusedBits3:16;
-	SDL_PixelFormat *vfmt;	/* Value: The format of the video surface */
+Uint32 video_mem;           /* The total amount of video memory (in K) */
-	int    current_w;	/* Value: The current video mode width */
-	int    current_h;	/* Value: The current video mode height */
 } SDL_VideoInfo;
+/**
-/* The most common video overlay formats.
+* \struct SDL_DisplayMode
-For an explanation of these pixel formats, see:
+*
-	http://www.webartz.com/fourcc/indexyuv.htm
+* \brief  The structure that defines a display mode
+*
-For information on the relationship between color spaces, see:
+* \sa SDL_GetNumDisplayModes()
-http://www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html
+* \sa SDL_GetDisplayMode()
-*/
+* \sa SDL_GetDesktopDisplayMode()
-#define SDL_YV12_OVERLAY  0x32315659	/* Planar mode: Y + V + U  (3 planes) */
+* \sa SDL_GetCurrentDisplayMode()
-#define SDL_IYUV_OVERLAY  0x56555949	/* Planar mode: Y + U + V  (3 planes) */
+* \sa SDL_GetClosestDisplayMode()
-#define SDL_YUY2_OVERLAY  0x32595559	/* Packed mode: Y0+U0+Y1+V0 (1 plane) */
+* \sa SDL_SetDisplayMode()
-#define SDL_UYVY_OVERLAY  0x59565955	/* Packed mode: U0+Y0+V0+Y1 (1 plane) */
+*/
-#define SDL_YVYU_OVERLAY  0x55595659	/* Packed mode: Y0+V0+Y1+U0 (1 plane) */
+typedef struct
+{
-/* The YUV hardware video overlay */
+Uint32 format;              /**< pixel format */
-typedef struct SDL_Overlay {
+int w;                      /**< width */
-	Uint32 format;				/* Read-only */
+int h;                      /**< height */
-	int w, h;				/* Read-only */
+int refresh_rate;           /**< refresh rate (or zero for unspecified) */
-	int planes;				/* Read-only */
+} SDL_DisplayMode;
-	Uint16 *pitches;			/* Read-only */
-	Uint8 **pixels;				/* Read-write */
+/**
+* \typedef SDL_WindowID
-	/* Hardware-specific surface info */
+*
-	struct private_yuvhwfuncs *hwfuncs;
+* \brief The type used to identify a window
-	struct private_yuvhwdata *hwdata;
+*
+* \sa SDL_CreateWindow()
-	/* Special flags */
+* \sa SDL_CreateWindowFrom()
-	Uint32 hw_overlay :1;	/* Flag: This overlay hardware accelerated? */
+* \sa SDL_DestroyWindow()
-	Uint32 UnusedBits :31;
+* \sa SDL_GetWindowData()
-} SDL_Overlay;
+* \sa SDL_GetWindowFlags()
+* \sa SDL_GetWindowGrab()
+* \sa SDL_GetWindowPosition()
-/* Public enumeration for setting the OpenGL window attributes. */
+* \sa SDL_GetWindowSize()
-typedef enum {
+* \sa SDL_GetWindowTitle()
+* \sa SDL_HideWindow()
+* \sa SDL_MaximizeWindow()
+* \sa SDL_MinimizeWindow()
+* \sa SDL_RaiseWindow()
+* \sa SDL_RestoreWindow()
+* \sa SDL_SetWindowData()
+* \sa SDL_SetWindowGrab()
+* \sa SDL_SetWindowIcon()
+* \sa SDL_SetWindowPosition()
+* \sa SDL_SetWindowSize()
+* \sa SDL_SetWindowTitle()
+* \sa SDL_ShowWindow()
+*/
+typedef Uint32 SDL_WindowID;
+/**
+* \enum SDL_WindowFlags
+*
+* \brief The flags on a window
+*/
+typedef enum
+{
+SDL_WINDOW_FULLSCREEN = 0x00000001,         /**< fullscreen window, implies borderless */
+SDL_WINDOW_BORDERLESS = 0x00000002,         /**< no window decoration */
+SDL_WINDOW_SHOWN = 0x00000004,              /**< window is visible */
+SDL_WINDOW_OPENGL = 0x00000008,             /**< window usable with OpenGL context */
+SDL_WINDOW_RESIZABLE = 0x00000010,          /**< window can be resized */
+SDL_WINDOW_MAXIMIZED = 0x00000020,          /**< maximized */
+SDL_WINDOW_MINIMIZED = 0x00000040,          /**< minimized */
+SDL_WINDOW_INPUT_GRABBED = 0x00000080,      /**< window has grabbed input focus */
+SDL_WINDOW_KEYBOARD_FOCUS = 0x00000100,     /**< window has keyboard focus */
+SDL_WINDOW_MOUSE_FOCUS = 0x00000200,        /**< window has mouse focus */
+} SDL_WindowFlags;
+/**
+* \enum SDL_WindowEventID
+*
+* \brief Event subtype for window events
+*/
+typedef enum
+{
+SDL_WINDOWEVENT_NONE,               /**< Never used */
+SDL_WINDOWEVENT_SHOWN,              /**< Window has been shown */
+SDL_WINDOWEVENT_HIDDEN,             /**< Window has been hidden */
+SDL_WINDOWEVENT_MOVED,              /**< Window has been moved to data1,data2 */
+SDL_WINDOWEVENT_RESIZED,            /**< Window size changed to data1xdata2 */
+SDL_WINDOWEVENT_MINIMIZED,          /**< Window has been minimized */
+SDL_WINDOWEVENT_MAXIMIZED,          /**< Window has been maximized */
+SDL_WINDOWEVENT_RESTORED,           /**< Window has been restored to normal size and position */
+SDL_WINDOWEVENT_ENTER,              /**< The window has gained mouse focus */
+SDL_WINDOWEVENT_LEAVE,              /**< The window has lost mouse focus */
+SDL_WINDOWEVENT_FOCUS_GAINED,       /**< The window has gained keyboard focus */
+SDL_WINDOWEVENT_FOCUS_LOST,         /**< The window has lost keyboard focus */
+} SDL_WindowEventID;
+/**
+* \enum SDL_GLattr
+*
+* \brief OpenGL configuration attributes
+*/
+typedef enum
+{
 SDL_GL_RED_SIZE,
 SDL_GL_GREEN_SIZE,
 SDL_GL_BLUE_SIZE,
 SDL_GL_ALPHA_SIZE,
 SDL_GL_BUFFER_SIZE,
 SDL_GL_MULTISAMPLESAMPLES,
 SDL_GL_ACCELERATED_VISUAL,
 SDL_GL_SWAP_CONTROL
 } SDL_GLattr;
-/* flags for SDL_SetPalette() */
+/* These are the currently supported flags for the SDL_surface */
-#define SDL_LOGPAL 0x01
+#define SDL_SWSURFACE	0x00000000      /* Surface is in system memory */
-#define SDL_PHYSPAL 0x02
+#define SDL_HWSURFACE	0x00000001      /* Surface is in video memory */
+/* Available for SDL_CreateWindowSurface() */
+#define SDL_ANYFORMAT	0x10000000      /* Allow any video depth/pixel-format */
+#define SDL_HWPALETTE	0x20000000      /* Surface has exclusive palette */
+#define SDL_DOUBLEBUF	0x40000000      /* Set up double-buffered surface */
+/* Used internally (read-only) */
+#define SDL_HWACCEL	0x00000100      /* Blit uses hardware acceleration */
+#define SDL_SRCCOLORKEY	0x00001000      /* Blit uses a source color key */
+#define SDL_RLEACCELOK	0x00002000      /* Private flag */
+#define SDL_RLEACCEL	0x00004000      /* Surface is RLE encoded */
+#define SDL_SRCALPHA	0x00010000      /* Blit uses source alpha blending */
+#define SDL_PREALLOC	0x00100000      /* Surface uses preallocated memory */
+#define SDL_SCREEN_SURFACE 0x01000000   /* Surface is a window screen surface */
+#define SDL_SHADOW_SURFACE 0x02000000   /* Surface is a window shadow surface */
 /* Function prototypes */
-/* These functions return the list of built in video drivers, in the
+/**
-* order that they are normally initialized by default.
+* \fn int SDL_GetNumVideoDrivers(void)
-*/
+*
-extern DECLSPEC int SDLCALL SDL_GetNumVideoDrivers(void);
+* \brief Get the number of video drivers compiled into SDL
-extern DECLSPEC const char * SDLCALL SDL_GetVideoDriver(int index);
+*
+* \sa SDL_GetVideoDriver()
-/* These functions are used internally, and should not be used unless you
+*/
-* have a specific need to specify the video driver you want to use.
+extern DECLSPEC int SDLCALL SDL_GetNumVideoDrivers (void);
-* You should normally use SDL_Init() or SDL_InitSubSystem().
-*
+/**
-* SDL_VideoInit() initializes the video subsystem -- sets up a connection
+* \fn const char *SDL_GetVideoDriver(int index)
-* to the window manager, etc, and determines the current video mode and
+*
-* pixel format, but does not initialize a window or graphics mode.
+* \brief Get the name of a built in video driver.
-* Note that event handling is activated by this routine.
+*
-*
+* \note The video drivers are presented in the order in which they are
-* If you use both sound and video in your application, you need to call
+* normally checked during initialization.
-* SDL_Init() before opening the sound device, otherwise under Win32 DirectX,
+*
-* you won't be able to set full-screen display modes.
+* \sa SDL_GetNumVideoDrivers()
 */
-extern DECLSPEC int SDLCALL SDL_VideoInit(const char *driver_name, Uint32 flags);
+extern DECLSPEC const char *SDLCALL SDL_GetVideoDriver (int index);
-extern DECLSPEC void SDLCALL SDL_VideoQuit(void);
+/**
-/* This function returns the name of the current video driver, or NULL
+* \fn int SDL_VideoInit(const char *driver_name, Uint32 flags)
-* if no driver has been initialized.
+*
-*/
+* \brief Initialize the video subsystem, optionally specifying a video driver.
-extern DECLSPEC const char * SDLCALL SDL_GetCurrentVideoDriver(void);
+*
+* \param driver_name Initialize a specific driver by name, or NULL for the default video driver.
-/*
+* \param flags FIXME: Still needed?
-* This function returns a pointer to the current display surface.
+*
-* If SDL is doing format conversion on the display surface, this
+* \return 0 on success, -1 on error
-* function returns the publicly visible surface, not the real video
+*
-* surface.
+* This function initializes the video subsystem; setting up a connection
-*/
+* to the window manager, etc, and determines the available display modes
-extern DECLSPEC SDL_Surface * SDLCALL SDL_GetVideoSurface(void);
+* and pixel formats, but does not initialize a window or graphics mode.
+*
-/*
+* \sa SDL_VideoQuit()
-* This function returns a read-only pointer to information about the
+*/
-* video hardware.  If this is called before SDL_SetVideoMode(), the 'vfmt'
+extern DECLSPEC int SDLCALL SDL_VideoInit (const char *driver_name,
-* member of the returned structure will contain the pixel format of the
+Uint32 flags);
-* "best" video mode.
-*/
+/**
-extern DECLSPEC const SDL_VideoInfo * SDLCALL SDL_GetVideoInfo(void);
+* \fn void SDL_VideoQuit(void)
+*
-/*
+* \brief Shuts down the video subsystem.
-* Check to see if a particular video mode is supported.
+*
-* It returns 0 if the requested mode is not supported under any bit depth,
+* This function closes all windows, and restores the original video mode.
-* or returns the bits-per-pixel of the closest available mode with the
+*
-* given width and height.  If this bits-per-pixel is different from the
+* \sa SDL_VideoInit()
-* one used when setting the video mode, SDL_SetVideoMode() will succeed,
+*/
-* but will emulate the requested bits-per-pixel with a shadow surface.
+extern DECLSPEC void SDLCALL SDL_VideoQuit (void);
-*
-* The arguments to SDL_VideoModeOK() are the same ones you would pass to
+/**
-* SDL_SetVideoMode()
+* \fn const char *SDL_GetCurrentVideoDriver(void)
-*/
+*
-extern DECLSPEC int SDLCALL SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags);
+* \brief Returns the name of the currently initialized video driver.
+*
-/*
+* \return The name of the current video driver or NULL if no driver
-* Return a pointer to an array of available screen dimensions for the
+*         has been initialized
-* given format and video flags, sorted largest to smallest.  Returns
+*
-* NULL if there are no dimensions available for a particular format,
+* \sa SDL_GetNumVideoDrivers()
-* or (SDL_Rect **)-1 if any dimension is okay for the given format.
+* \sa SDL_GetVideoDriver()
-*
+*/
-* If 'format' is NULL, the mode list will be for the format given
+extern DECLSPEC const char *SDLCALL SDL_GetCurrentVideoDriver (void);
-* by SDL_GetVideoInfo()->vfmt
-*/
+/**
-extern DECLSPEC SDL_Rect ** SDLCALL SDL_ListModes(SDL_PixelFormat *format, Uint32 flags);
+* \fn const SDL_VideoInfo *SDL_GetVideoInfo(void)
+*
-/*
+* \brief Returns information about the currently initialized video driver.
-* Set up a video mode with the specified width, height and bits-per-pixel.
+*
-*
+* \return A read-only pointer to information about the video hardware,
-* If 'bpp' is 0, it is treated as the current display bits per pixel.
+*         or NULL if no video driver has been initialized.
-*
+*/
-* If SDL_ANYFORMAT is set in 'flags', the SDL library will try to set the
+extern DECLSPEC const SDL_VideoInfo *SDLCALL SDL_GetVideoInfo (void);
-* requested bits-per-pixel, but will return whatever video pixel format is
-* available.  The default is to emulate the requested pixel format if it
+/**
-* is not natively available.
+* \fn int SDL_GetNumVideoDisplays(void)
 *
-* If SDL_HWSURFACE is set in 'flags', the video surface will be placed in
+* \brief Returns the number of available video displays.
-* video memory, if possible, and you may have to call SDL_LockSurface()
+*
-* in order to access the raw framebuffer.  Otherwise, the video surface
+* \sa SDL_SelectVideoDisplay()
-* will be created in system memory.
+*/
-*
+extern DECLSPEC int SDLCALL SDL_GetNumVideoDisplays (void);
-* If SDL_ASYNCBLIT is set in 'flags', SDL will try to perform rectangle
-* updates asynchronously, but you must always lock before accessing pixels.
+/**
-* SDL will wait for updates to complete before returning from the lock.
+* \fn int SDL_SelectVideoDisplay(int index)
 *
-* If SDL_HWPALETTE is set in 'flags', the SDL library will guarantee
+* \brief Set the index of the currently selected display.
-* that the colors set by SDL_SetColors() will be the colors you get.
+*
-* Otherwise, in 8-bit mode, SDL_SetColors() may not be able to set all
+* \note You can query the currently selected display by passing an index of -1.
-* of the colors exactly the way they are requested, and you should look
+*
-* at the video surface structure to determine the actual palette.
+* \sa SDL_GetNumVideoDisplays()
-* If SDL cannot guarantee that the colors you request can be set,
+*/
-* i.e. if the colormap is shared, then the video surface may be created
+extern DECLSPEC int SDLCALL SDL_SelectVideoDisplay (int index);
-* under emulation in system memory, overriding the SDL_HWSURFACE flag.
-*
+/**
-* If SDL_FULLSCREEN is set in 'flags', the SDL library will try to set
+* \fn int SDL_GetNumDisplayModes(void)
-* a fullscreen video mode.  The default is to create a windowed mode
+*
-* if the current graphics system has a window manager.
+* \brief Returns the number of available display modes for the current display.
-* If the SDL library is able to set a fullscreen video mode, this flag
+*
-* will be set in the surface that is returned.
+* \sa SDL_GetDisplayMode()
-*
+*/
-* If SDL_DOUBLEBUF is set in 'flags', the SDL library will try to set up
+extern DECLSPEC int SDLCALL SDL_GetNumDisplayModes (void);
-* two surfaces in video memory and swap between them when you call
-* SDL_Flip().  This is usually slower than the normal single-buffering
+/**
-* scheme, but prevents "tearing" artifacts caused by modifying video
+* \fn const SDL_DisplayMode *SDL_GetDisplayMode(int index)
-* memory while the monitor is refreshing.  It should only be used by
+*
-* applications that redraw the entire screen on every update.
+* \brief Retrieve information about a specific display mode.
 *
-* If SDL_RESIZABLE is set in 'flags', the SDL library will allow the
+* \note The display modes are sorted in this priority:
-* window manager, if any, to resize the window at runtime.  When this
+*       \li bits per pixel -> more colors to fewer colors
-* occurs, SDL will send a SDL_VIDEORESIZE event to you application,
+*       \li width -> largest to smallest
-* and you must respond to the event by re-calling SDL_SetVideoMode()
+*       \li height -> largest to smallest
-* with the requested size (or another size that suits the application).
+*       \li refresh rate -> highest to lowest
 *
-* If SDL_NOFRAME is set in 'flags', the SDL library will create a window
+* \sa SDL_GetNumDisplayModes()
-* without any title bar or frame decoration.  Fullscreen video modes have
+*/
-* this flag set automatically.
+extern DECLSPEC const SDL_DisplayMode *SDLCALL SDL_GetDisplayMode (int index);
-*
-* This function returns the video framebuffer surface, or NULL if it fails.
+/**
-*
+* \fn const SDL_DisplayMode *SDL_GetDesktopDisplayMode(void)
-* If you rely on functionality provided by certain video flags, check the
+*
-* flags of the returned surface to make sure that functionality is available.
+* \brief Retrieve information about the desktop display mode for the current display.
-* SDL will fall back to reduced functionality if the exact flags you wanted
+*/
-* are not available.
+extern DECLSPEC const SDL_DisplayMode *SDLCALL
-*/
+SDL_GetDesktopDisplayMode (void);
-extern DECLSPEC SDL_Surface * SDLCALL SDL_SetVideoMode
-			(int width, int height, int bpp, Uint32 flags);
+/**
+* \fn const SDL_DisplayMode *SDL_GetCurrentDisplayMode(void)
+*
+* \brief Retrieve information about the current display mode.
+*/
+extern DECLSPEC const SDL_DisplayMode *SDLCALL
+SDL_GetCurrentDisplayMode (void);
+/**
+* \fn SDL_DisplayMode *SDL_GetClosestDisplayMode(const SDL_DisplayMode *mode, SDL_DisplayMode *closest)
+*
+* \brief Get the closest match to the requested display mode.
+*
+* \param mode The desired display mode
+* \param closest A pointer to a display mode to be filled in with the closest match of the available display modes.
+*
+* \return 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.
+*
+* \sa SDL_GetNumDisplayModes()
+* \sa SDL_GetDisplayMode()
+*/
+extern DECLSPEC SDL_DisplayMode *SDLCALL SDL_GetClosestDisplayMode (const
+SDL_DisplayMode
+* mode,
+SDL_DisplayMode
+*
+closest);
+/**
+* \fn int SDL_SetDisplayMode(const SDL_DisplayMode *mode)
+*
+* \brief Set up the closest available mode on the current display.
+*
+* \param mode The desired display mode
+*
+* \return 0 on success, or -1 if setting the display mode failed.
+*/
+extern DECLSPEC int SDLCALL SDL_SetDisplayMode (const SDL_DisplayMode * mode);
+/**
+* \fn SDL_WindowID SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)
+*
+* \brief Create a window with the specified position, dimensions, and flags.
+*
+* \param title The title of the window
+* \param x The x position of the window
+* \param y The y position of the window
+* \param w The width of the window
+* \param h The height of the window
+* \param flags The flags for the window
+*
+* \return The id of the window created, or zero if window creation failed.
+*
+* \note Setting the position to -1, -1, indicates any position is fine.
+*
+* \sa SDL_DestroyWindow()
+*/
+extern DECLSPEC SDL_WindowID SDLCALL SDL_CreateWindow (const char *title,
+int x, int y, int w,
+int h, Uint32 flags);
+/**
+* \fn SDL_WindowID SDL_CreateWindowFrom(void *data)
+*
+* \brief Create an SDL window struct from an existing native window.
+*
+* \param data A pointer to driver-dependent window creation data
+*
+* \return The id of the window created, or zero if window creation failed.
+*
+* \warning This function is NOT SUPPORTED, use at your own risk!
+*
+* \sa SDL_DestroyWindow()
+*/
+extern DECLSPEC SDL_WindowID SDLCALL SDL_CreateWindowFrom (void *data);
+/**
+* \fn Uint32 SDL_GetWindowFlags(SDL_WindowID windowID)
+*
+* \brief Get the window flags.
+*/
+extern DECLSPEC Uint32 SDLCALL SDL_GetWindowFlags (SDL_WindowID windowID);
+/**
+* \fn void SDL_SetWindowTitle(SDL_WindowID windowID, const char *title)
+*
+* \brief Set the title of the window, in UTF-8 format.
+*
+* \sa SDL_GetWindowTitle()
+*/
+extern DECLSPEC void SDLCALL SDL_SetWindowTitle (SDL_WindowID windowID,
+const char *title);
+/**
+* \fn const char *SDL_GetWindowTitle(SDL_WindowID windowID)
+*
+* \brief Get the title of the window, in UTF-8 format.
+*
+* \sa SDL_SetWindowTitle()
+*/
+extern DECLSPEC const char *SDLCALL SDL_GetWindowTitle (SDL_WindowID
+windowID);
+/**
+* \fn void SDL_SetWindowIcon(SDL_Surface *icon)
+*
+* \brief Set the icon of the window.
+*
+* \param icon The icon for the window
+*
+* FIXME: The icon needs to be set before the window is first shown.  Should some icon representation be part of the window creation data?
+*/
+extern DECLSPEC void SDLCALL SDL_SetWindowIcon (SDL_Surface * icon);
+/**
+* \fn void SDL_SetWindowData(SDL_WindowID windowID, void *userdata)
+*
+* \brief Associate an arbitrary pointer with the window.
+*
+* \sa SDL_GetWindowData()
+*/
+extern DECLSPEC void SDLCALL SDL_SetWindowData (SDL_WindowID windowID,
+void *userdata);
+/**
+* \fn void *SDL_GetWindowData(SDL_WindowID windowID)
+*
+* \brief Retrieve the data pointer associated with the window.
+*
+* \sa SDL_SetWindowData()
+*/
+extern DECLSPEC void *SDLCALL SDL_GetWindowData (SDL_WindowID windowID);
+/**
+* \fn void SDL_SetWindowPosition(SDL_WindowID windowID, int x, int y)
+*
+* \brief Set the position of the window.
+*
+* \sa SDL_GetWindowPosition()
+*/
+extern DECLSPEC void SDLCALL SDL_SetWindowPosition (SDL_WindowID windowID,
+int x, int y);
+/**
+* \fn void SDL_GetWindowPosition(SDL_WindowID windowID, int *x, int *y)
+*
+* \brief Get the position of the window.
+*
+* \sa SDL_SetWindowPosition()
+*/
+extern DECLSPEC void SDLCALL SDL_GetWindowPosition (SDL_WindowID windowID,
+int *x, int *y);
+/**
+* \fn void SDL_SetWindowSize(SDL_WindowID windowID, int w, int w)
+*
+* \brief Set the size of the window's client area.
+*
+* \note You can't change the size of a fullscreen window, it automatically
+* matches the size of the display mode.
+*
+* \sa SDL_GetWindowSize()
+*/
+extern DECLSPEC void SDLCALL SDL_SetWindowSize (SDL_WindowID windowID, int w,
+int h);
+/**
+* \fn void SDL_GetWindowSize(SDL_WindowID windowID, int *w, int *w)
+*
+* \brief Get the size of the window's client area.
+*
+* \sa SDL_SetWindowSize()
+*/
+extern DECLSPEC void SDLCALL SDL_GetWindowSize (SDL_WindowID windowID, int *w,
+int *h);
+/**
+* \fn void SDL_ShowWindow(SDL_WindowID windowID)
+*
+* \brief Show the window
+*
+* \sa SDL_HideWindow()
+*/
+extern DECLSPEC void SDLCALL SDL_ShowWindow (SDL_WindowID windowID);
+/**
+* \fn void SDL_HideWindow(SDL_WindowID windowID)
+*
+* \brief Hide the window
+*
+* \sa SDL_ShowWindow()
+*/
+extern DECLSPEC void SDLCALL SDL_HideWindow (SDL_WindowID windowID);
+/**
+* \fn void SDL_RaiseWindow(SDL_WindowID windowID)
+*
+* \brief Raise the window so it's above other windows.
+*/
+extern DECLSPEC void SDLCALL SDL_RaiseWindow (SDL_WindowID windowID);
+/**
+* \fn void SDL_MaximizeWindow(SDL_WindowID windowID)
+*
+* \brief Make the window as large as possible.
+*
+* \sa SDL_RestoreWindow()
+*/
+extern DECLSPEC void SDLCALL SDL_MaximizeWindow (SDL_WindowID windowID);
+/**
+* \fn void SDL_MinimizeWindow(SDL_WindowID windowID)
+*
+* \brief Minimize the window to an iconic representation.
+*
+* \sa SDL_RestoreWindow()
+*/
+extern DECLSPEC void SDLCALL SDL_MinimizeWindow (SDL_WindowID windowID);
+/**
+* \fn void SDL_RestoreWindow(SDL_WindowID windowID)
+*
+* \brief Restore the size and position of a minimized or maximized window.
+*
+* \sa SDL_MaximizeWindow()
+* \sa SDL_MinimizeWindow()
+*/
+extern DECLSPEC void SDLCALL SDL_RestoreWindow (SDL_WindowID windowID);
+/**
+* \fn void SDL_SetWindowGrab(SDL_WindowID windowID, int mode)
+*
+* \brief Set the window's input grab mode.
+*
+* \param mode This is 1 to grab input, and 0 to release input.
+*
+* \sa SDL_GrabMode
+* \sa SDL_GetWindowGrab()
+*/
+extern DECLSPEC void SDLCALL SDL_SetWindowGrab (SDL_WindowID windowID,
+int mode);
+/**
+* \fn int SDL_GetWindowGrab(SDL_WindowID windowID)
+*
+* \brief Get the window's input grab mode.
+*
+* \return This returns 1 if input is grabbed, and 0 otherwise.
+*
+* \sa SDL_GrabMode
+* \sa SDL_SetWindowGrab()
+*/
+extern DECLSPEC int SDLCALL SDL_GetWindowGrab (SDL_WindowID windowID);
+/**
+* \fn void SDL_DestroyWindow(SDL_WindowID windowID)
+*
+* \brief Destroy a window.
+*/
+extern DECLSPEC void SDLCALL SDL_DestroyWindow (SDL_WindowID windowID);
+/**
+* \fn SDL_Surface *SDL_CreateWindowSurface (SDL_WindowID windowID, Uint32 format, Uint32 flags)
+*
+* \brief Create an SDL_Surface representing the drawing area of the window.
+*/
+extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateWindowSurface (SDL_WindowID
+windowID,
+Uint32 format,
+Uint32 flags);
 /*
 * Makes sure the given list of rectangles is updated on the given screen.
 * If 'x', 'y', 'w' and 'h' are all 0, SDL_UpdateRect will update the entire
 * screen.
 * These functions should not be called while 'screen' is locked.
 */
 extern DECLSPEC void SDLCALL SDL_UpdateRects
-		(SDL_Surface *screen, int numrects, SDL_Rect *rects);
+(SDL_Surface * screen, int numrects, SDL_Rect * rects);
 extern DECLSPEC void SDLCALL SDL_UpdateRect
-		(SDL_Surface *screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h);
+(SDL_Surface * screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h);
 /*
 * On hardware that supports double-buffering, this function sets up a flip
 * and returns.  The hardware will wait for vertical retrace, and then swap
 * video buffers before the next video surface blit or lock will return.
 * to calling SDL_UpdateRect(screen, 0, 0, 0, 0);
 * The SDL_DOUBLEBUF flag must have been passed to SDL_SetVideoMode() when
 * setting the video mode for this function to perform hardware flipping.
 * This function returns 0 if successful, or -1 if there was an error.
 */
-extern DECLSPEC int SDLCALL SDL_Flip(SDL_Surface *screen);
+extern DECLSPEC int SDLCALL SDL_Flip (SDL_Surface * screen);
 /*
 * Set the gamma correction for each of the color channels.
 * The gamma values range (approximately) between 0.1 and 10.0
 *
 * If this function isn't supported directly by the hardware, it will
 * be emulated using gamma ramps, if available.  If successful, this
 * function returns 0, otherwise it returns -1.
 */
-extern DECLSPEC int SDLCALL SDL_SetGamma(float red, float green, float blue);
+extern DECLSPEC int SDLCALL SDL_SetGamma (float red, float green, float blue);
 /*
 * 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.
 * You may pass NULL for any of the channels to leave it unchanged.
 * If the call succeeds, it will return 0.  If the display driver or
 * hardware does not support gamma translation, or otherwise fails,
 * this function will return -1.
 */
-extern DECLSPEC int SDLCALL SDL_SetGammaRamp(const Uint16 *red, const Uint16 *green, const Uint16 *blue);
+extern DECLSPEC int SDLCALL SDL_SetGammaRamp (const Uint16 * red,
+const Uint16 * green,
+const Uint16 * blue);
 /*
 * Retrieve the current values of the gamma translation tables.
 *
 * You must pass in valid pointers to arrays of 256 16-bit quantities.
 * Any of the pointers may be NULL to ignore that channel.
 * If the call succeeds, it will return 0.  If the display driver or
 * hardware does not support gamma translation, or otherwise fails,
 * this function will return -1.
 */
-extern DECLSPEC int SDLCALL SDL_GetGammaRamp(Uint16 *red, Uint16 *green, Uint16 *blue);
+extern DECLSPEC int SDLCALL SDL_GetGammaRamp (Uint16 * red, Uint16 * green,
+Uint16 * blue);
 /*
 * Sets a portion of the colormap for the given 8-bit surface.  If 'surface'
 * is not a palettized surface, this function does nothing, returning 0.
 * If all of the colors were set as passed to SDL_SetColors(), it will
 * SDL_HWPALETTE was set in SDL_SetVideoMode() flags, SDL_SetColors()
 * will always return 1, and the palette is guaranteed to be set the way
 * you desire, even if the window colormap has to be warped or run under
 * emulation.
 */
-extern DECLSPEC int SDLCALL SDL_SetColors(SDL_Surface *surface,
+extern DECLSPEC int SDLCALL SDL_SetColors (SDL_Surface * surface,
-			SDL_Color *colors, int firstcolor, int ncolors);
+SDL_Color * colors, int firstcolor,
+int ncolors);
-/*
-* Sets a portion of the colormap for a given 8-bit surface.
-* 'flags' is one or both of:
-* SDL_LOGPAL  -- set logical palette, which controls how blits are mapped
-*                to/from the surface,
-* SDL_PHYSPAL -- set physical palette, which controls how pixels look on
-*                the screen
-* Only screens have physical palettes. Separate change of physical/logical
-* palettes is only possible if the screen has SDL_HWPALETTE set.
-*
-* The return value is 1 if all colours could be set as requested, and 0
-* otherwise.
-*
-* SDL_SetColors() is equivalent to calling this function with
-*     flags = (SDL_LOGPAL|SDL_PHYSPAL).
-*/
-extern DECLSPEC int SDLCALL SDL_SetPalette(SDL_Surface *surface, int flags,
-				   SDL_Color *colors, int firstcolor,
-				   int ncolors);
 /*
 * Maps an RGB triple to an opaque pixel value for a given pixel format
 */
 extern DECLSPEC Uint32 SDLCALL SDL_MapRGB
-			(SDL_PixelFormat *format, Uint8 r, Uint8 g, Uint8 b);
+(SDL_PixelFormat * format, Uint8 r, Uint8 g, Uint8 b);
 /*
 * Maps an RGBA quadruple to a pixel value for a given pixel format
 */
-extern DECLSPEC Uint32 SDLCALL SDL_MapRGBA(SDL_PixelFormat *format,
+extern DECLSPEC Uint32 SDLCALL SDL_MapRGBA (SDL_PixelFormat * format,
-				   Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+Uint8 r, Uint8 g, Uint8 b,
+Uint8 a);
 /*
 * Maps a pixel value into the RGB components for a given pixel format
 */
-extern DECLSPEC void SDLCALL SDL_GetRGB(Uint32 pixel, SDL_PixelFormat *fmt,
+extern DECLSPEC void SDLCALL SDL_GetRGB (Uint32 pixel, SDL_PixelFormat * fmt,
-				Uint8 *r, Uint8 *g, Uint8 *b);
+Uint8 * r, Uint8 * g, Uint8 * b);
 /*
 * Maps a pixel value into the RGBA components for a given pixel format
 */
-extern DECLSPEC void SDLCALL SDL_GetRGBA(Uint32 pixel, SDL_PixelFormat *fmt,
+extern DECLSPEC void SDLCALL SDL_GetRGBA (Uint32 pixel, SDL_PixelFormat * fmt,
-				 Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a);
+Uint8 * r, Uint8 * g, Uint8 * b,
+Uint8 * a);
 /*
 * Allocate and free an RGB surface (must be called after SDL_SetVideoMode)
 * If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
 * If the depth is greater than 8 bits, the pixel format is set using the
 * will be set in the flags member of the returned surface.  If for some
 * reason the surface could not be placed in video memory, it will not have
 * the SDL_HWSURFACE flag set, and will be created in system memory instead.
 */
 #define SDL_AllocSurface    SDL_CreateRGBSurface
-extern DECLSPEC SDL_Surface * SDLCALL SDL_CreateRGBSurface
+extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurface
-			(Uint32 flags, int width, int height, int depth,
+(Uint32 flags, int width, int height, int depth,
-			Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
+Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
-extern DECLSPEC SDL_Surface * SDLCALL SDL_CreateRGBSurfaceFrom(void *pixels,
+extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceFrom (void *pixels,
-			int width, int height, int depth, int pitch,
+int width,
-			Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
+int height,
-extern DECLSPEC void SDLCALL SDL_FreeSurface(SDL_Surface *surface);
+int depth,
+int pitch,
+Uint32 Rmask,
+Uint32 Gmask,
+Uint32 Bmask,
+Uint32 Amask);
+extern DECLSPEC void SDLCALL SDL_FreeSurface (SDL_Surface * surface);
 /*
 * SDL_LockSurface() sets up a surface for directly accessing the pixels.
 * Between calls to SDL_LockSurface()/SDL_UnlockSurface(), you can write
 * to and read from 'surface->pixels', using the pixel format stored in
 * No operating system or library calls should be made between lock/unlock
 * pairs, as critical system locks may be held during this time.
 *
 * SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.
 */
-extern DECLSPEC int SDLCALL SDL_LockSurface(SDL_Surface *surface);
+extern DECLSPEC int SDLCALL SDL_LockSurface (SDL_Surface * surface);
-extern DECLSPEC void SDLCALL SDL_UnlockSurface(SDL_Surface *surface);
+extern DECLSPEC void SDLCALL SDL_UnlockSurface (SDL_Surface * surface);
 /*
 * Load a surface from a seekable SDL data source (memory or file.)
 * If 'freesrc' is non-zero, the source will be closed after being read.
 * Returns the new surface, or NULL if there was an error.
 * The new surface should be freed with SDL_FreeSurface().
 */
-extern DECLSPEC SDL_Surface * SDLCALL SDL_LoadBMP_RW(SDL_RWops *src, int freesrc);
+extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP_RW (SDL_RWops * src,
+int freesrc);
 /* Convenience macro -- load a surface from a file */
 #define SDL_LoadBMP(file)	SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)
 /*
 * Save a surface to a seekable SDL data source (memory or file.)
 * If 'freedst' is non-zero, the source will be closed after being written.
 * Returns 0 if successful or -1 if there was an error.
 */
 extern DECLSPEC int SDLCALL SDL_SaveBMP_RW
-		(SDL_Surface *surface, SDL_RWops *dst, int freedst);
+(SDL_Surface * surface, SDL_RWops * dst, int freedst);
 /* Convenience macro -- save a surface to a file */
 #define SDL_SaveBMP(surface, file) \
 		SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)
 * and removes RLE acceleration if absent.
 * If 'flag' is 0, this function clears any current color key.
 * This function returns 0, or -1 if there was an error.
 */
 extern DECLSPEC int SDLCALL SDL_SetColorKey
-			(SDL_Surface *surface, Uint32 flag, Uint32 key);
+(SDL_Surface * surface, Uint32 flag, Uint32 key);
 /*
 * This function sets the alpha value for the entire surface, as opposed to
 * using the alpha component of each pixel. This value measures the range
 * of transparency of the surface, 0 being completely transparent to 255
 * OR:ing the flag with SDL_RLEACCEL requests RLE acceleration for the
 * surface; if SDL_RLEACCEL is not specified, the RLE accel will be removed.
 *
 * The 'alpha' parameter is ignored for surfaces that have an alpha channel.
 */
-extern DECLSPEC int SDLCALL SDL_SetAlpha(SDL_Surface *surface, Uint32 flag, Uint8 alpha);
+extern DECLSPEC int SDLCALL SDL_SetAlpha (SDL_Surface * surface, Uint32 flag,
+Uint8 alpha);
 /*
 * Sets the clipping rectangle for the destination surface in a blit.
 *
 * If the clip rectangle is NULL, clipping will be disabled.
 * the intersection of the surface area and the clipping rectangle.
 *
 * Note that blits are automatically clipped to the edges of the source
 * and destination surfaces.
 */
-extern DECLSPEC SDL_bool SDLCALL SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect);
+extern DECLSPEC SDL_bool SDLCALL SDL_SetClipRect (SDL_Surface * surface,
+const SDL_Rect * rect);
 /*
 * Gets the clipping rectangle for the destination surface in a blit.
 * 'rect' must be a pointer to a valid rectangle which will be filled
 * with the correct values.
 */
-extern DECLSPEC void SDLCALL SDL_GetClipRect(SDL_Surface *surface, SDL_Rect *rect);
+extern DECLSPEC void SDLCALL SDL_GetClipRect (SDL_Surface * surface,
+SDL_Rect * rect);
 /*
 * Creates a new surface of the specified format, and then copies and maps
 * the given surface to it so the blit of the converted surface will be as
 * fast as possible.  If this function fails, it returns NULL.
 * SDL will try to RLE accelerate colorkey and alpha blits in the resulting
 * surface.
 *
 * This function is used internally by SDL_DisplayFormat().
 */
-extern DECLSPEC SDL_Surface * SDLCALL SDL_ConvertSurface
+extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurface
-			(SDL_Surface *src, SDL_PixelFormat *fmt, Uint32 flags);
+(SDL_Surface * src, SDL_PixelFormat * fmt, Uint32 flags);
 /*
 * This performs a fast blit from the source surface to the destination
 * surface.  It assumes that the source and destination rectangles are
 * the same size.  If either 'srcrect' or 'dstrect' are NULL, the entire
 /* This is the public blit function, SDL_BlitSurface(), and it performs
 rectangle validation and clipping before passing it to SDL_LowerBlit()
 */
 extern DECLSPEC int SDLCALL SDL_UpperBlit
-			(SDL_Surface *src, SDL_Rect *srcrect,
+(SDL_Surface * src, SDL_Rect * srcrect,
-			 SDL_Surface *dst, SDL_Rect *dstrect);
+SDL_Surface * dst, SDL_Rect * dstrect);
 /* This is a semi-private blit function and it performs low-level surface
 blitting only.
 */
 extern DECLSPEC int SDLCALL SDL_LowerBlit
-			(SDL_Surface *src, SDL_Rect *srcrect,
+(SDL_Surface * src, SDL_Rect * srcrect,
-			 SDL_Surface *dst, SDL_Rect *dstrect);
+SDL_Surface * dst, SDL_Rect * dstrect);
 /*
 * This function performs a fast fill of the given rectangle with 'color'
 * The given rectangle is clipped to the destination surface clip area
 * and the final fill rectangle is saved in the passed in pointer.
 * The color should be a pixel of the format used by the surface, and
 * can be generated by the SDL_MapRGB() function.
 * This function returns 0 on success, or -1 on error.
 */
 extern DECLSPEC int SDLCALL SDL_FillRect
-		(SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color);
+(SDL_Surface * dst, SDL_Rect * dstrect, Uint32 color);
 /*
 * This function takes a surface and copies it to a new surface of the
 * pixel format and colors of the video framebuffer, suitable for fast
 * blitting onto the display surface.  It calls SDL_ConvertSurface()
 * acceleration, you should set the colorkey and alpha value before
 * calling this function.
 *
 * If the conversion fails or runs out of memory, it returns NULL
 */
-extern DECLSPEC SDL_Surface * SDLCALL SDL_DisplayFormat(SDL_Surface *surface);
+extern DECLSPEC SDL_Surface *SDLCALL SDL_DisplayFormat (SDL_Surface *
+surface);
 /*
 * This function takes a surface and copies it to a new surface of the
 * pixel format and colors of the video framebuffer (if possible),
 * suitable for fast alpha blitting onto the display surface.
 * acceleration, you should set the colorkey and alpha value before
 * calling this function.
 *
 * If the conversion fails or runs out of memory, it returns NULL
 */
-extern DECLSPEC SDL_Surface * SDLCALL SDL_DisplayFormatAlpha(SDL_Surface *surface);
+extern DECLSPEC SDL_Surface *SDLCALL SDL_DisplayFormatAlpha (SDL_Surface *
+surface);
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /* YUV video surface overlay functions                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /* This function creates a video output overlay
 Calling the returned surface an overlay is something of a misnomer because
 the contents of the display surface underneath the area where the overlay
 is shown is undefined - it may be overwritten with the converted YUV data.
 */
-extern DECLSPEC SDL_Overlay * SDLCALL SDL_CreateYUVOverlay(int width, int height,
+extern DECLSPEC SDL_Overlay *SDLCALL SDL_CreateYUVOverlay (int width,
-				Uint32 format, SDL_Surface *display);
+int height,
+Uint32 format,
+SDL_Surface *
+display);
 /* Lock an overlay for direct access, and unlock it when you are done */
-extern DECLSPEC int SDLCALL SDL_LockYUVOverlay(SDL_Overlay *overlay);
+extern DECLSPEC int SDLCALL SDL_LockYUVOverlay (SDL_Overlay * overlay);
-extern DECLSPEC void SDLCALL SDL_UnlockYUVOverlay(SDL_Overlay *overlay);
+extern DECLSPEC void SDLCALL SDL_UnlockYUVOverlay (SDL_Overlay * overlay);
 /* Blit a video overlay to the display surface.
 The contents of the video surface underneath the blit destination are
 not defined.
 The width and height of the destination rectangle may be different from
 that of the overlay, but currently only 2x scaling is supported.
 */
-extern DECLSPEC int SDLCALL SDL_DisplayYUVOverlay(SDL_Overlay *overlay, SDL_Rect *dstrect);
+extern DECLSPEC int SDLCALL SDL_DisplayYUVOverlay (SDL_Overlay * overlay,
+SDL_Rect * dstrect);
 /* Free a video overlay */
-extern DECLSPEC void SDLCALL SDL_FreeYUVOverlay(SDL_Overlay *overlay);
+extern DECLSPEC void SDLCALL SDL_FreeYUVOverlay (SDL_Overlay * overlay);
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /* OpenGL support functions.                                                 */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 * Dynamically load an OpenGL library, or the default one if path is NULL
 *
 * 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().
 */
-extern DECLSPEC int SDLCALL SDL_GL_LoadLibrary(const char *path);
+extern DECLSPEC int SDLCALL SDL_GL_LoadLibrary (const char *path);
 /*
 * Get the address of a GL function
 */
-extern DECLSPEC void * SDLCALL SDL_GL_GetProcAddress(const char* proc);
+extern DECLSPEC void *SDLCALL SDL_GL_GetProcAddress (const char *proc);
 /*
-* Set an attribute of the OpenGL subsystem before intialization.
+* Set an attribute of the OpenGL subsystem before window creation.
 */
-extern DECLSPEC int SDLCALL SDL_GL_SetAttribute(SDL_GLattr attr, int value);
+extern DECLSPEC int SDLCALL SDL_GL_SetAttribute (SDL_GLattr attr, int value);
 /*
 * Get an attribute of the OpenGL subsystem from the windowing
 * interface, such as glX. This is of course different from getting
 * the values from SDL's internal OpenGL subsystem, which only
 * stores the values you request before initialization.
 *
 * Developers should track the values they pass into SDL_GL_SetAttribute
 * themselves if they want to retrieve these values.
 */
-extern DECLSPEC int SDLCALL SDL_GL_GetAttribute(SDL_GLattr attr, int* value);
+extern DECLSPEC int SDLCALL SDL_GL_GetAttribute (SDL_GLattr attr, int *value);
 /*
 * Swap the OpenGL buffers, if double-buffering is supported.
 */
-extern DECLSPEC void SDLCALL SDL_GL_SwapBuffers(void);
+extern DECLSPEC void SDLCALL SDL_GL_SwapBuffers (void);
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-/* These functions allow interaction with the window manager, if any.        */
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-/*
-* Sets/Gets the title and icon text of the display window (UTF-8 encoded)
-*/
-extern DECLSPEC void SDLCALL SDL_WM_SetCaption(const char *title, const char *icon);
-extern DECLSPEC void SDLCALL SDL_WM_GetCaption(char **title, char **icon);
-/*
-* Sets the icon for the display window.
-* This function must be called before the first call to SDL_SetVideoMode().
-* It takes an icon surface, and a mask in MSB format.
-* If 'mask' is NULL, the entire icon surface will be used as the icon.
-*/
-extern DECLSPEC void SDLCALL SDL_WM_SetIcon(SDL_Surface *icon, Uint8 *mask);
-/*
-* This function iconifies the window, and returns 1 if it succeeded.
-* If the function succeeds, it generates an SDL_APPACTIVE loss event.
-* This function is a noop and returns 0 in non-windowed environments.
-*/
-extern DECLSPEC int SDLCALL SDL_WM_IconifyWindow(void);
-/*
-* Toggle fullscreen mode without changing the contents of the screen.
-* If the display surface does not require locking before accessing
-* the pixel information, then the memory pointers will not change.
-*
-* If this function was able to toggle fullscreen mode (change from
-* running in a window to fullscreen, or vice-versa), it will return 1.
-* If it is not implemented, or fails, it returns 0.
-*
-* The next call to SDL_SetVideoMode() will set the mode fullscreen
-* attribute based on the flags parameter - if SDL_FULLSCREEN is not
-* set, then the display will be windowed by default where supported.
-*
-* This is currently only implemented in the X11 video driver.
-*/
-extern DECLSPEC int SDLCALL SDL_WM_ToggleFullScreen(SDL_Surface *surface);
-/*
-* This function allows you to set and query the input grab state of
-* the application.  It returns the new input grab state.
-*/
-typedef enum {
-	SDL_GRAB_QUERY = -1,
-	SDL_GRAB_OFF = 0,
-	SDL_GRAB_ON = 1,
-	SDL_GRAB_FULLSCREEN	/* Used internally */
-} SDL_GrabMode;
-/*
-* Grabbing means that the mouse is confined to the application window,
-* and nearly all keyboard input is passed directly to the application,
-* and not interpreted by a window manager, if any.
-*/
-extern DECLSPEC SDL_GrabMode SDLCALL SDL_WM_GrabInput(SDL_GrabMode mode);
 /* Not in public API at the moment - do not use! */
-extern DECLSPEC int SDLCALL SDL_SoftStretch(SDL_Surface *src, SDL_Rect *srcrect,
+extern DECLSPEC int SDLCALL SDL_SoftStretch (SDL_Surface * src,
-SDL_Surface *dst, SDL_Rect *dstrect);
+SDL_Rect * srcrect,
+SDL_Surface * dst,
+SDL_Rect * dstrect);
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
+/* *INDENT-OFF* */
 }
+/* *INDENT-ON* */
 #endif
 #include "close_code.h"
 #endif /* _SDL_video_h */
+/* vi: set ts=4 sw=4 expandtab: */

Mercurial > sdl-ios-xcode

comparison include/SDL_video.h @ 1662:782fd950bd46 SDL-1.3