include/SDL_video.h
branchSDL-1.3
changeset 1662 782fd950bd46
parent 1660 8b9d79e7eacf
child 1668 4da1ee79c9af
     1.1 --- a/include/SDL_video.h	Sun May 21 17:27:13 2006 +0000
     1.2 +++ b/include/SDL_video.h	Sun May 28 13:04:16 2006 +0000
     1.3 @@ -20,19 +20,26 @@
     1.4      slouken@libsdl.org
     1.5  */
     1.6  
     1.7 -/* Header file for access to the SDL raw framebuffer window */
     1.8 +/**
     1.9 + * \file SDL_video.h
    1.10 + *
    1.11 + * Header file for access to the SDL raw framebuffer window
    1.12 + */
    1.13  
    1.14  #ifndef _SDL_video_h
    1.15  #define _SDL_video_h
    1.16  
    1.17  #include "SDL_stdinc.h"
    1.18  #include "SDL_error.h"
    1.19 +#include "SDL_pixels.h"
    1.20  #include "SDL_rwops.h"
    1.21  
    1.22  #include "begin_code.h"
    1.23  /* Set up for C function definitions, even when using C++ */
    1.24  #ifdef __cplusplus
    1.25 +/* *INDENT-OFF* */
    1.26  extern "C" {
    1.27 +/* *INDENT-ON* */
    1.28  #endif
    1.29  
    1.30  /* Transparency definitions: These define alpha as the opacity of a surface */
    1.31 @@ -40,131 +47,43 @@
    1.32  #define SDL_ALPHA_TRANSPARENT 0
    1.33  
    1.34  /* Useful data types */
    1.35 -typedef struct SDL_Rect {
    1.36 -	Sint16 x, y;
    1.37 -	Uint16 w, h;
    1.38 +typedef struct SDL_Rect
    1.39 +{
    1.40 +    Sint16 x, y;
    1.41 +    Uint16 w, h;
    1.42  } SDL_Rect;
    1.43  
    1.44 -typedef struct SDL_Color {
    1.45 -	Uint8 r;
    1.46 -	Uint8 g;
    1.47 -	Uint8 b;
    1.48 -	Uint8 unused;
    1.49 -} SDL_Color;
    1.50 -#define SDL_Colour SDL_Color
    1.51 -
    1.52 -typedef struct SDL_Palette {
    1.53 -	int       ncolors;
    1.54 -	SDL_Color *colors;
    1.55 -} SDL_Palette;
    1.56 -
    1.57 -/* Everything in the pixel format structure is read-only */
    1.58 -typedef struct SDL_PixelFormat {
    1.59 -	SDL_Palette *palette;
    1.60 -	Uint8  BitsPerPixel;
    1.61 -	Uint8  BytesPerPixel;
    1.62 -	Uint8  Rloss;
    1.63 -	Uint8  Gloss;
    1.64 -	Uint8  Bloss;
    1.65 -	Uint8  Aloss;
    1.66 -	Uint8  Rshift;
    1.67 -	Uint8  Gshift;
    1.68 -	Uint8  Bshift;
    1.69 -	Uint8  Ashift;
    1.70 -	Uint32 Rmask;
    1.71 -	Uint32 Gmask;
    1.72 -	Uint32 Bmask;
    1.73 -	Uint32 Amask;
    1.74 -
    1.75 -	/* RGB color key information */
    1.76 -	Uint32 colorkey;
    1.77 -	/* Alpha value information (per-surface alpha) */
    1.78 -	Uint8  alpha;
    1.79 -} SDL_PixelFormat;
    1.80 -
    1.81  /* This structure should be treated as read-only, except for 'pixels',
    1.82     which, if not NULL, contains the raw pixel data for the surface.
    1.83  */
    1.84 -typedef struct SDL_Surface {
    1.85 -	Uint32 flags;				/* Read-only */
    1.86 -	SDL_PixelFormat *format;		/* Read-only */
    1.87 -	int w, h;				/* Read-only */
    1.88 -	Uint16 pitch;				/* Read-only */
    1.89 -	void *pixels;				/* Read-write */
    1.90 -	int offset;				/* Private */
    1.91 -
    1.92 -	/* Hardware-specific surface info */
    1.93 -	struct private_hwdata *hwdata;
    1.94 +typedef struct SDL_Surface
    1.95 +{
    1.96 +    Uint32 flags;               /* Read-only */
    1.97 +    SDL_PixelFormat *format;    /* Read-only */
    1.98 +    int w, h;                   /* Read-only */
    1.99 +    Uint16 pitch;               /* Read-only */
   1.100 +    void *pixels;               /* Read-write */
   1.101 +    int offset;                 /* Private */
   1.102  
   1.103 -	/* clipping information */
   1.104 -	SDL_Rect clip_rect;			/* Read-only */
   1.105 -	Uint32 unused1;				/* for binary compatibility */
   1.106 -
   1.107 -	/* Allow recursive locks */
   1.108 -	Uint32 locked;				/* Private */
   1.109 -
   1.110 -	/* info for fast blit mapping to other surfaces */
   1.111 -	struct SDL_BlitMap *map;		/* Private */
   1.112 -
   1.113 -	/* format version, bumped at every change to invalidate blit maps */
   1.114 -	unsigned int format_version;		/* Private */
   1.115 -
   1.116 -	/* Reference count -- used when freeing surface */
   1.117 -	int refcount;				/* Read-mostly */
   1.118 -} SDL_Surface;
   1.119 +    /* Hardware-specific surface info */
   1.120 +    struct private_hwdata *hwdata;
   1.121  
   1.122 -/* These are the currently supported flags for the SDL_surface */
   1.123 -/* Available for SDL_CreateRGBSurface() or SDL_SetVideoMode() */
   1.124 -#define SDL_SWSURFACE	0x00000000	/* Surface is in system memory */
   1.125 -#define SDL_HWSURFACE	0x00000001	/* Surface is in video memory */
   1.126 -#define SDL_ASYNCBLIT	0x00000004	/* Use asynchronous blits if possible */
   1.127 -/* Available for SDL_SetVideoMode() */
   1.128 -#define SDL_ANYFORMAT	0x10000000	/* Allow any video depth/pixel-format */
   1.129 -#define SDL_HWPALETTE	0x20000000	/* Surface has exclusive palette */
   1.130 -#define SDL_DOUBLEBUF	0x40000000	/* Set up double-buffered video mode */
   1.131 -#define SDL_FULLSCREEN	0x80000000	/* Surface is a full screen display */
   1.132 -#define SDL_OPENGL      0x00000002      /* Create an OpenGL rendering context */
   1.133 -#define SDL_INTERNALOPENGL 0x00000008   /* SDL uses OpenGL internally for this window */
   1.134 -#define SDL_RESIZABLE	0x00000010	/* This video mode may be resized */
   1.135 -#define SDL_NOFRAME	0x00000020	/* No window caption or edge frame */
   1.136 -/* Used internally (read-only) */
   1.137 -#define SDL_HWACCEL	0x00000100	/* Blit uses hardware acceleration */
   1.138 -#define SDL_SRCCOLORKEY	0x00001000	/* Blit uses a source color key */
   1.139 -#define SDL_RLEACCELOK	0x00002000	/* Private flag */
   1.140 -#define SDL_RLEACCEL	0x00004000	/* Surface is RLE encoded */
   1.141 -#define SDL_SRCALPHA	0x00010000	/* Blit uses source alpha blending */
   1.142 -#define SDL_PREALLOC	0x01000000	/* Surface uses preallocated memory */
   1.143 +    /* clipping information */
   1.144 +    SDL_Rect clip_rect;         /* Read-only */
   1.145 +    Uint32 unused1;             /* for binary compatibility */
   1.146 +
   1.147 +    /* Allow recursive locks */
   1.148 +    Uint32 locked;              /* Private */
   1.149  
   1.150 -/* Evaluates to true if the surface needs to be locked before access */
   1.151 -#define SDL_MUSTLOCK(surface)	\
   1.152 -  (surface->offset ||		\
   1.153 -  ((surface->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_RLEACCEL)) != 0))
   1.154 -
   1.155 -/* typedef for private surface blitting functions */
   1.156 -typedef int (*SDL_blit)(struct SDL_Surface *src, SDL_Rect *srcrect,
   1.157 -			struct SDL_Surface *dst, SDL_Rect *dstrect);
   1.158 -
   1.159 +    /* info for fast blit mapping to other surfaces */
   1.160 +    struct SDL_BlitMap *map;    /* Private */
   1.161  
   1.162 -/* Useful for determining the video hardware capabilities */
   1.163 -typedef struct SDL_VideoInfo {
   1.164 -	Uint32 hw_available :1;	/* Flag: Can you create hardware surfaces? */
   1.165 -	Uint32 wm_available :1;	/* Flag: Can you talk to a window manager? */
   1.166 -	Uint32 UnusedBits1  :6;
   1.167 -	Uint32 UnusedBits2  :1;
   1.168 -	Uint32 blit_hw      :1;	/* Flag: Accelerated blits HW --> HW */
   1.169 -	Uint32 blit_hw_CC   :1;	/* Flag: Accelerated blits with Colorkey */
   1.170 -	Uint32 blit_hw_A    :1;	/* Flag: Accelerated blits with Alpha */
   1.171 -	Uint32 blit_sw      :1;	/* Flag: Accelerated blits SW --> HW */
   1.172 -	Uint32 blit_sw_CC   :1;	/* Flag: Accelerated blits with Colorkey */
   1.173 -	Uint32 blit_sw_A    :1;	/* Flag: Accelerated blits with Alpha */
   1.174 -	Uint32 blit_fill    :1;	/* Flag: Accelerated color fill */
   1.175 -	Uint32 UnusedBits3  :16;
   1.176 -	Uint32 video_mem;	/* The total amount of video memory (in K) */
   1.177 -	SDL_PixelFormat *vfmt;	/* Value: The format of the video surface */
   1.178 -	int    current_w;	/* Value: The current video mode width */
   1.179 -	int    current_h;	/* Value: The current video mode height */
   1.180 -} SDL_VideoInfo;
   1.181 +    /* format version, bumped at every change to invalidate blit maps */
   1.182 +    unsigned int format_version;        /* Private */
   1.183  
   1.184 +    /* Reference count -- used when freeing surface */
   1.185 +    int refcount;               /* Read-mostly */
   1.186 +} SDL_Surface;
   1.187  
   1.188  /* The most common video overlay formats.
   1.189     For an explanation of these pixel formats, see:
   1.190 @@ -173,32 +92,154 @@
   1.191     For information on the relationship between color spaces, see:
   1.192     http://www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html
   1.193   */
   1.194 -#define SDL_YV12_OVERLAY  0x32315659	/* Planar mode: Y + V + U  (3 planes) */
   1.195 -#define SDL_IYUV_OVERLAY  0x56555949	/* Planar mode: Y + U + V  (3 planes) */
   1.196 -#define SDL_YUY2_OVERLAY  0x32595559	/* Packed mode: Y0+U0+Y1+V0 (1 plane) */
   1.197 -#define SDL_UYVY_OVERLAY  0x59565955	/* Packed mode: U0+Y0+V0+Y1 (1 plane) */
   1.198 -#define SDL_YVYU_OVERLAY  0x55595659	/* Packed mode: Y0+V0+Y1+U0 (1 plane) */
   1.199 +#define SDL_YV12_OVERLAY  0x32315659    /* Planar mode: Y + V + U  (3 planes) */
   1.200 +#define SDL_IYUV_OVERLAY  0x56555949    /* Planar mode: Y + U + V  (3 planes) */
   1.201 +#define SDL_YUY2_OVERLAY  0x32595559    /* Packed mode: Y0+U0+Y1+V0 (1 plane) */
   1.202 +#define SDL_UYVY_OVERLAY  0x59565955    /* Packed mode: U0+Y0+V0+Y1 (1 plane) */
   1.203 +#define SDL_YVYU_OVERLAY  0x55595659    /* Packed mode: Y0+V0+Y1+U0 (1 plane) */
   1.204  
   1.205  /* The YUV hardware video overlay */
   1.206 -typedef struct SDL_Overlay {
   1.207 -	Uint32 format;				/* Read-only */
   1.208 -	int w, h;				/* Read-only */
   1.209 -	int planes;				/* Read-only */
   1.210 -	Uint16 *pitches;			/* Read-only */
   1.211 -	Uint8 **pixels;				/* Read-write */
   1.212 +typedef struct SDL_Overlay
   1.213 +{
   1.214 +    Uint32 format;              /* Read-only */
   1.215 +    int w, h;                   /* Read-only */
   1.216 +    int planes;                 /* Read-only */
   1.217 +    Uint16 *pitches;            /* Read-only */
   1.218 +    Uint8 **pixels;             /* Read-write */
   1.219  
   1.220 -	/* Hardware-specific surface info */
   1.221 -	struct private_yuvhwfuncs *hwfuncs;
   1.222 -	struct private_yuvhwdata *hwdata;
   1.223 +    /* Hardware-specific surface info */
   1.224 +    struct private_yuvhwfuncs *hwfuncs;
   1.225 +    struct private_yuvhwdata *hwdata;
   1.226  
   1.227 -	/* Special flags */
   1.228 -	Uint32 hw_overlay :1;	/* Flag: This overlay hardware accelerated? */
   1.229 -	Uint32 UnusedBits :31;
   1.230 +    /* Special flags */
   1.231 +    Uint32 hw_overlay:1;        /* Flag: This overlay hardware accelerated? */
   1.232 +    Uint32 UnusedBits:31;
   1.233  } SDL_Overlay;
   1.234  
   1.235 +/* Evaluates to true if the surface needs to be locked before access */
   1.236 +#define SDL_MUSTLOCK(surface)	\
   1.237 +  (surface->offset ||		\
   1.238 +  ((surface->flags & (SDL_HWSURFACE|SDL_RLEACCEL)) != 0))
   1.239  
   1.240 -/* Public enumeration for setting the OpenGL window attributes. */
   1.241 -typedef enum {
   1.242 +/* typedef for private surface blitting functions */
   1.243 +typedef int (*SDL_blit) (struct SDL_Surface * src, SDL_Rect * srcrect,
   1.244 +                         struct SDL_Surface * dst, SDL_Rect * dstrect);
   1.245 +
   1.246 +
   1.247 +/* Useful for determining the video hardware capabilities */
   1.248 +typedef struct SDL_VideoInfo
   1.249 +{
   1.250 +    Uint32 hw_available:1;      /* Flag: Can you create hardware surfaces? */
   1.251 +    Uint32 wm_available:1;      /* Flag: Can you talk to a window manager? */
   1.252 +    Uint32 UnusedBits1:6;
   1.253 +    Uint32 UnusedBits2:1;
   1.254 +    Uint32 blit_hw:1;           /* Flag: Accelerated blits HW --> HW */
   1.255 +    Uint32 blit_hw_CC:1;        /* Flag: Accelerated blits with Colorkey */
   1.256 +    Uint32 blit_hw_A:1;         /* Flag: Accelerated blits with Alpha */
   1.257 +    Uint32 blit_sw:1;           /* Flag: Accelerated blits SW --> HW */
   1.258 +    Uint32 blit_sw_CC:1;        /* Flag: Accelerated blits with Colorkey */
   1.259 +    Uint32 blit_sw_A:1;         /* Flag: Accelerated blits with Alpha */
   1.260 +    Uint32 blit_fill:1;         /* Flag: Accelerated color fill */
   1.261 +    Uint32 UnusedBits3:16;
   1.262 +    Uint32 video_mem;           /* The total amount of video memory (in K) */
   1.263 +} SDL_VideoInfo;
   1.264 +
   1.265 +/**
   1.266 + * \struct SDL_DisplayMode
   1.267 + *
   1.268 + * \brief  The structure that defines a display mode
   1.269 + *
   1.270 + * \sa SDL_GetNumDisplayModes()
   1.271 + * \sa SDL_GetDisplayMode()
   1.272 + * \sa SDL_GetDesktopDisplayMode()
   1.273 + * \sa SDL_GetCurrentDisplayMode()
   1.274 + * \sa SDL_GetClosestDisplayMode()
   1.275 + * \sa SDL_SetDisplayMode()
   1.276 + */
   1.277 +typedef struct
   1.278 +{
   1.279 +    Uint32 format;              /**< pixel format */
   1.280 +    int w;                      /**< width */
   1.281 +    int h;                      /**< height */
   1.282 +    int refresh_rate;           /**< refresh rate (or zero for unspecified) */
   1.283 +} SDL_DisplayMode;
   1.284 +
   1.285 +/**
   1.286 + * \typedef SDL_WindowID
   1.287 + *
   1.288 + * \brief The type used to identify a window
   1.289 + *
   1.290 + * \sa SDL_CreateWindow()
   1.291 + * \sa SDL_CreateWindowFrom()
   1.292 + * \sa SDL_DestroyWindow()
   1.293 + * \sa SDL_GetWindowData()
   1.294 + * \sa SDL_GetWindowFlags()
   1.295 + * \sa SDL_GetWindowGrab()
   1.296 + * \sa SDL_GetWindowPosition()
   1.297 + * \sa SDL_GetWindowSize()
   1.298 + * \sa SDL_GetWindowTitle()
   1.299 + * \sa SDL_HideWindow()
   1.300 + * \sa SDL_MaximizeWindow()
   1.301 + * \sa SDL_MinimizeWindow()
   1.302 + * \sa SDL_RaiseWindow()
   1.303 + * \sa SDL_RestoreWindow()
   1.304 + * \sa SDL_SetWindowData()
   1.305 + * \sa SDL_SetWindowGrab()
   1.306 + * \sa SDL_SetWindowIcon()
   1.307 + * \sa SDL_SetWindowPosition()
   1.308 + * \sa SDL_SetWindowSize()
   1.309 + * \sa SDL_SetWindowTitle()
   1.310 + * \sa SDL_ShowWindow()
   1.311 + */
   1.312 +typedef Uint32 SDL_WindowID;
   1.313 +
   1.314 +/**
   1.315 + * \enum SDL_WindowFlags
   1.316 + *
   1.317 + * \brief The flags on a window
   1.318 + */
   1.319 +typedef enum
   1.320 +{
   1.321 +    SDL_WINDOW_FULLSCREEN = 0x00000001,         /**< fullscreen window, implies borderless */
   1.322 +    SDL_WINDOW_BORDERLESS = 0x00000002,         /**< no window decoration */
   1.323 +    SDL_WINDOW_SHOWN = 0x00000004,              /**< window is visible */
   1.324 +    SDL_WINDOW_OPENGL = 0x00000008,             /**< window usable with OpenGL context */
   1.325 +    SDL_WINDOW_RESIZABLE = 0x00000010,          /**< window can be resized */
   1.326 +    SDL_WINDOW_MAXIMIZED = 0x00000020,          /**< maximized */
   1.327 +    SDL_WINDOW_MINIMIZED = 0x00000040,          /**< minimized */
   1.328 +    SDL_WINDOW_INPUT_GRABBED = 0x00000080,      /**< window has grabbed input focus */
   1.329 +    SDL_WINDOW_KEYBOARD_FOCUS = 0x00000100,     /**< window has keyboard focus */
   1.330 +    SDL_WINDOW_MOUSE_FOCUS = 0x00000200,        /**< window has mouse focus */
   1.331 +} SDL_WindowFlags;
   1.332 +
   1.333 +/**
   1.334 + * \enum SDL_WindowEventID
   1.335 + *
   1.336 + * \brief Event subtype for window events
   1.337 + */
   1.338 +typedef enum
   1.339 +{
   1.340 +    SDL_WINDOWEVENT_NONE,               /**< Never used */
   1.341 +    SDL_WINDOWEVENT_SHOWN,              /**< Window has been shown */
   1.342 +    SDL_WINDOWEVENT_HIDDEN,             /**< Window has been hidden */
   1.343 +    SDL_WINDOWEVENT_MOVED,              /**< Window has been moved to data1,data2 */
   1.344 +    SDL_WINDOWEVENT_RESIZED,            /**< Window size changed to data1xdata2 */
   1.345 +    SDL_WINDOWEVENT_MINIMIZED,          /**< Window has been minimized */
   1.346 +    SDL_WINDOWEVENT_MAXIMIZED,          /**< Window has been maximized */
   1.347 +    SDL_WINDOWEVENT_RESTORED,           /**< Window has been restored to normal size and position */
   1.348 +    SDL_WINDOWEVENT_ENTER,              /**< The window has gained mouse focus */
   1.349 +    SDL_WINDOWEVENT_LEAVE,              /**< The window has lost mouse focus */
   1.350 +    SDL_WINDOWEVENT_FOCUS_GAINED,       /**< The window has gained keyboard focus */
   1.351 +    SDL_WINDOWEVENT_FOCUS_LOST,         /**< The window has lost keyboard focus */
   1.352 +} SDL_WindowEventID;
   1.353 +
   1.354 +/**
   1.355 + * \enum SDL_GLattr
   1.356 + *
   1.357 + * \brief OpenGL configuration attributes
   1.358 + */
   1.359 +typedef enum
   1.360 +{
   1.361      SDL_GL_RED_SIZE,
   1.362      SDL_GL_GREEN_SIZE,
   1.363      SDL_GL_BLUE_SIZE,
   1.364 @@ -218,139 +259,423 @@
   1.365      SDL_GL_SWAP_CONTROL
   1.366  } SDL_GLattr;
   1.367  
   1.368 -/* flags for SDL_SetPalette() */
   1.369 -#define SDL_LOGPAL 0x01
   1.370 -#define SDL_PHYSPAL 0x02
   1.371 +/* These are the currently supported flags for the SDL_surface */
   1.372 +#define SDL_SWSURFACE	0x00000000      /* Surface is in system memory */
   1.373 +#define SDL_HWSURFACE	0x00000001      /* Surface is in video memory */
   1.374 +/* Available for SDL_CreateWindowSurface() */
   1.375 +#define SDL_ANYFORMAT	0x10000000      /* Allow any video depth/pixel-format */
   1.376 +#define SDL_HWPALETTE	0x20000000      /* Surface has exclusive palette */
   1.377 +#define SDL_DOUBLEBUF	0x40000000      /* Set up double-buffered surface */
   1.378 +/* Used internally (read-only) */
   1.379 +#define SDL_HWACCEL	0x00000100      /* Blit uses hardware acceleration */
   1.380 +#define SDL_SRCCOLORKEY	0x00001000      /* Blit uses a source color key */
   1.381 +#define SDL_RLEACCELOK	0x00002000      /* Private flag */
   1.382 +#define SDL_RLEACCEL	0x00004000      /* Surface is RLE encoded */
   1.383 +#define SDL_SRCALPHA	0x00010000      /* Blit uses source alpha blending */
   1.384 +#define SDL_PREALLOC	0x00100000      /* Surface uses preallocated memory */
   1.385 +#define SDL_SCREEN_SURFACE 0x01000000   /* Surface is a window screen surface */
   1.386 +#define SDL_SHADOW_SURFACE 0x02000000   /* Surface is a window shadow surface */
   1.387  
   1.388  /* Function prototypes */
   1.389  
   1.390 -/* These functions return the list of built in video drivers, in the 
   1.391 - * order that they are normally initialized by default.
   1.392 +/**
   1.393 + * \fn int SDL_GetNumVideoDrivers(void)
   1.394 + *
   1.395 + * \brief Get the number of video drivers compiled into SDL
   1.396 + *
   1.397 + * \sa SDL_GetVideoDriver()
   1.398 + */
   1.399 +extern DECLSPEC int SDLCALL SDL_GetNumVideoDrivers (void);
   1.400 +
   1.401 +/**
   1.402 + * \fn const char *SDL_GetVideoDriver(int index)
   1.403 + *
   1.404 + * \brief Get the name of a built in video driver.
   1.405 + *
   1.406 + * \note The video drivers are presented in the order in which they are
   1.407 + * normally checked during initialization.
   1.408 + *
   1.409 + * \sa SDL_GetNumVideoDrivers()
   1.410   */
   1.411 -extern DECLSPEC int SDLCALL SDL_GetNumVideoDrivers(void);
   1.412 -extern DECLSPEC const char * SDLCALL SDL_GetVideoDriver(int index);
   1.413 +extern DECLSPEC const char *SDLCALL SDL_GetVideoDriver (int index);
   1.414  
   1.415 -/* These functions are used internally, and should not be used unless you
   1.416 - * have a specific need to specify the video driver you want to use.
   1.417 - * You should normally use SDL_Init() or SDL_InitSubSystem().
   1.418 +/**
   1.419 + * \fn int SDL_VideoInit(const char *driver_name, Uint32 flags)
   1.420 + *
   1.421 + * \brief Initialize the video subsystem, optionally specifying a video driver.
   1.422 + *
   1.423 + * \param driver_name Initialize a specific driver by name, or NULL for the default video driver.
   1.424 + * \param flags FIXME: Still needed?
   1.425 + *
   1.426 + * \return 0 on success, -1 on error
   1.427 + *
   1.428 + * This function initializes the video subsystem; setting up a connection
   1.429 + * to the window manager, etc, and determines the available display modes
   1.430 + * and pixel formats, but does not initialize a window or graphics mode.
   1.431 + *
   1.432 + * \sa SDL_VideoQuit()
   1.433 + */
   1.434 +extern DECLSPEC int SDLCALL SDL_VideoInit (const char *driver_name,
   1.435 +                                           Uint32 flags);
   1.436 +
   1.437 +/**
   1.438 + * \fn void SDL_VideoQuit(void)
   1.439 + *
   1.440 + * \brief Shuts down the video subsystem.
   1.441 + *
   1.442 + * This function closes all windows, and restores the original video mode.
   1.443   *
   1.444 - * SDL_VideoInit() initializes the video subsystem -- sets up a connection
   1.445 - * to the window manager, etc, and determines the current video mode and
   1.446 - * pixel format, but does not initialize a window or graphics mode.
   1.447 - * Note that event handling is activated by this routine.
   1.448 + * \sa SDL_VideoInit()
   1.449 + */
   1.450 +extern DECLSPEC void SDLCALL SDL_VideoQuit (void);
   1.451 +
   1.452 +/**
   1.453 + * \fn const char *SDL_GetCurrentVideoDriver(void)
   1.454 + *
   1.455 + * \brief Returns the name of the currently initialized video driver.
   1.456 + *
   1.457 + * \return The name of the current video driver or NULL if no driver
   1.458 + *         has been initialized
   1.459 + *
   1.460 + * \sa SDL_GetNumVideoDrivers()
   1.461 + * \sa SDL_GetVideoDriver()
   1.462 + */
   1.463 +extern DECLSPEC const char *SDLCALL SDL_GetCurrentVideoDriver (void);
   1.464 +
   1.465 +/**
   1.466 + * \fn const SDL_VideoInfo *SDL_GetVideoInfo(void)
   1.467 + *
   1.468 + * \brief Returns information about the currently initialized video driver.
   1.469   *
   1.470 - * If you use both sound and video in your application, you need to call
   1.471 - * SDL_Init() before opening the sound device, otherwise under Win32 DirectX,
   1.472 - * you won't be able to set full-screen display modes.
   1.473 + * \return A read-only pointer to information about the video hardware,
   1.474 + *         or NULL if no video driver has been initialized.
   1.475 + */
   1.476 +extern DECLSPEC const SDL_VideoInfo *SDLCALL SDL_GetVideoInfo (void);
   1.477 +
   1.478 +/**
   1.479 + * \fn int SDL_GetNumVideoDisplays(void)
   1.480 + *
   1.481 + * \brief Returns the number of available video displays.
   1.482 + *
   1.483 + * \sa SDL_SelectVideoDisplay()
   1.484   */
   1.485 -extern DECLSPEC int SDLCALL SDL_VideoInit(const char *driver_name, Uint32 flags);
   1.486 -extern DECLSPEC void SDLCALL SDL_VideoQuit(void);
   1.487 +extern DECLSPEC int SDLCALL SDL_GetNumVideoDisplays (void);
   1.488  
   1.489 -/* This function returns the name of the current video driver, or NULL
   1.490 - * if no driver has been initialized.
   1.491 +/**
   1.492 + * \fn int SDL_SelectVideoDisplay(int index)
   1.493 + *
   1.494 + * \brief Set the index of the currently selected display.
   1.495 + *
   1.496 + * \note You can query the currently selected display by passing an index of -1.
   1.497 + *
   1.498 + * \sa SDL_GetNumVideoDisplays()
   1.499   */
   1.500 -extern DECLSPEC const char * SDLCALL SDL_GetCurrentVideoDriver(void);
   1.501 +extern DECLSPEC int SDLCALL SDL_SelectVideoDisplay (int index);
   1.502  
   1.503 -/*
   1.504 - * This function returns a pointer to the current display surface.
   1.505 - * If SDL is doing format conversion on the display surface, this
   1.506 - * function returns the publicly visible surface, not the real video
   1.507 - * surface.
   1.508 +/**
   1.509 + * \fn int SDL_GetNumDisplayModes(void)
   1.510 + *
   1.511 + * \brief Returns the number of available display modes for the current display.
   1.512 + *
   1.513 + * \sa SDL_GetDisplayMode()
   1.514   */
   1.515 -extern DECLSPEC SDL_Surface * SDLCALL SDL_GetVideoSurface(void);
   1.516 +extern DECLSPEC int SDLCALL SDL_GetNumDisplayModes (void);
   1.517  
   1.518 -/*
   1.519 - * This function returns a read-only pointer to information about the
   1.520 - * video hardware.  If this is called before SDL_SetVideoMode(), the 'vfmt'
   1.521 - * member of the returned structure will contain the pixel format of the
   1.522 - * "best" video mode.
   1.523 +/**
   1.524 + * \fn const SDL_DisplayMode *SDL_GetDisplayMode(int index)
   1.525 + *
   1.526 + * \brief Retrieve information about a specific display mode.
   1.527 + *
   1.528 + * \note The display modes are sorted in this priority:
   1.529 + *       \li bits per pixel -> more colors to fewer colors
   1.530 + *       \li width -> largest to smallest
   1.531 + *       \li height -> largest to smallest
   1.532 + *       \li refresh rate -> highest to lowest
   1.533 + *
   1.534 + * \sa SDL_GetNumDisplayModes()
   1.535   */
   1.536 -extern DECLSPEC const SDL_VideoInfo * SDLCALL SDL_GetVideoInfo(void);
   1.537 +extern DECLSPEC const SDL_DisplayMode *SDLCALL SDL_GetDisplayMode (int index);
   1.538 +
   1.539 +/**
   1.540 + * \fn const SDL_DisplayMode *SDL_GetDesktopDisplayMode(void)
   1.541 + *
   1.542 + * \brief Retrieve information about the desktop display mode for the current display.
   1.543 + */
   1.544 +extern DECLSPEC const SDL_DisplayMode *SDLCALL
   1.545 +SDL_GetDesktopDisplayMode (void);
   1.546 +
   1.547 +/**
   1.548 + * \fn const SDL_DisplayMode *SDL_GetCurrentDisplayMode(void)
   1.549 + *
   1.550 + * \brief Retrieve information about the current display mode.
   1.551 + */
   1.552 +extern DECLSPEC const SDL_DisplayMode *SDLCALL
   1.553 +SDL_GetCurrentDisplayMode (void);
   1.554  
   1.555 -/* 
   1.556 - * Check to see if a particular video mode is supported.
   1.557 - * It returns 0 if the requested mode is not supported under any bit depth,
   1.558 - * or returns the bits-per-pixel of the closest available mode with the
   1.559 - * given width and height.  If this bits-per-pixel is different from the
   1.560 - * one used when setting the video mode, SDL_SetVideoMode() will succeed,
   1.561 - * but will emulate the requested bits-per-pixel with a shadow surface.
   1.562 +/**
   1.563 + * \fn SDL_DisplayMode *SDL_GetClosestDisplayMode(const SDL_DisplayMode *mode, SDL_DisplayMode *closest)
   1.564 + *
   1.565 + * \brief Get the closest match to the requested display mode.
   1.566 + *
   1.567 + * \param mode The desired display mode
   1.568 + * \param closest A pointer to a display mode to be filled in with the closest match of the available display modes.
   1.569 + *
   1.570 + * \return The passed in value 'closest', or NULL if no matching video mode was available.
   1.571 + *
   1.572 + * 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.
   1.573 + *
   1.574 + * \sa SDL_GetNumDisplayModes()
   1.575 + * \sa SDL_GetDisplayMode()
   1.576 + */
   1.577 +extern DECLSPEC SDL_DisplayMode *SDLCALL SDL_GetClosestDisplayMode (const
   1.578 +                                                                    SDL_DisplayMode
   1.579 +                                                                    * mode,
   1.580 +                                                                    SDL_DisplayMode
   1.581 +                                                                    *
   1.582 +                                                                    closest);
   1.583 +
   1.584 +/**
   1.585 + * \fn int SDL_SetDisplayMode(const SDL_DisplayMode *mode)
   1.586 + *
   1.587 + * \brief Set up the closest available mode on the current display.
   1.588 + *
   1.589 + * \param mode The desired display mode
   1.590   *
   1.591 - * The arguments to SDL_VideoModeOK() are the same ones you would pass to
   1.592 - * SDL_SetVideoMode()
   1.593 + * \return 0 on success, or -1 if setting the display mode failed.
   1.594   */
   1.595 -extern DECLSPEC int SDLCALL SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags);
   1.596 +extern DECLSPEC int SDLCALL SDL_SetDisplayMode (const SDL_DisplayMode * mode);
   1.597  
   1.598 -/*
   1.599 - * Return a pointer to an array of available screen dimensions for the
   1.600 - * given format and video flags, sorted largest to smallest.  Returns 
   1.601 - * NULL if there are no dimensions available for a particular format, 
   1.602 - * or (SDL_Rect **)-1 if any dimension is okay for the given format.
   1.603 +/**
   1.604 + * \fn SDL_WindowID SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)
   1.605 + *
   1.606 + * \brief Create a window with the specified position, dimensions, and flags.
   1.607 + *
   1.608 + * \param title The title of the window
   1.609 + * \param x The x position of the window
   1.610 + * \param y The y position of the window
   1.611 + * \param w The width of the window
   1.612 + * \param h The height of the window
   1.613 + * \param flags The flags for the window
   1.614 + *
   1.615 + * \return The id of the window created, or zero if window creation failed.
   1.616 + *
   1.617 + * \note Setting the position to -1, -1, indicates any position is fine.
   1.618 + *
   1.619 + * \sa SDL_DestroyWindow()
   1.620 + */
   1.621 +extern DECLSPEC SDL_WindowID SDLCALL SDL_CreateWindow (const char *title,
   1.622 +                                                       int x, int y, int w,
   1.623 +                                                       int h, Uint32 flags);
   1.624 +
   1.625 +/**
   1.626 + * \fn SDL_WindowID SDL_CreateWindowFrom(void *data)
   1.627 + *
   1.628 + * \brief Create an SDL window struct from an existing native window.
   1.629 + *
   1.630 + * \param data A pointer to driver-dependent window creation data
   1.631 + *
   1.632 + * \return The id of the window created, or zero if window creation failed.
   1.633   *
   1.634 - * If 'format' is NULL, the mode list will be for the format given 
   1.635 - * by SDL_GetVideoInfo()->vfmt
   1.636 + * \warning This function is NOT SUPPORTED, use at your own risk!
   1.637 + *
   1.638 + * \sa SDL_DestroyWindow()
   1.639 + */
   1.640 +extern DECLSPEC SDL_WindowID SDLCALL SDL_CreateWindowFrom (void *data);
   1.641 +
   1.642 +/**
   1.643 + * \fn Uint32 SDL_GetWindowFlags(SDL_WindowID windowID)
   1.644 + *
   1.645 + * \brief Get the window flags.
   1.646   */
   1.647 -extern DECLSPEC SDL_Rect ** SDLCALL SDL_ListModes(SDL_PixelFormat *format, Uint32 flags);
   1.648 +extern DECLSPEC Uint32 SDLCALL SDL_GetWindowFlags (SDL_WindowID windowID);
   1.649 +
   1.650 +/**
   1.651 + * \fn void SDL_SetWindowTitle(SDL_WindowID windowID, const char *title)
   1.652 + *
   1.653 + * \brief Set the title of the window, in UTF-8 format.
   1.654 + *
   1.655 + * \sa SDL_GetWindowTitle()
   1.656 + */
   1.657 +extern DECLSPEC void SDLCALL SDL_SetWindowTitle (SDL_WindowID windowID,
   1.658 +                                                 const char *title);
   1.659  
   1.660 -/*
   1.661 - * Set up a video mode with the specified width, height and bits-per-pixel.
   1.662 +/**
   1.663 + * \fn const char *SDL_GetWindowTitle(SDL_WindowID windowID)
   1.664 + *
   1.665 + * \brief Get the title of the window, in UTF-8 format.
   1.666   *
   1.667 - * If 'bpp' is 0, it is treated as the current display bits per pixel.
   1.668 + * \sa SDL_SetWindowTitle()
   1.669 + */
   1.670 +extern DECLSPEC const char *SDLCALL SDL_GetWindowTitle (SDL_WindowID
   1.671 +                                                        windowID);
   1.672 +
   1.673 +/**
   1.674 + * \fn void SDL_SetWindowIcon(SDL_Surface *icon)
   1.675   *
   1.676 - * If SDL_ANYFORMAT is set in 'flags', the SDL library will try to set the
   1.677 - * requested bits-per-pixel, but will return whatever video pixel format is
   1.678 - * available.  The default is to emulate the requested pixel format if it
   1.679 - * is not natively available.
   1.680 + * \brief Set the icon of the window.
   1.681 + *
   1.682 + * \param icon The icon for the window
   1.683 + *
   1.684 + * FIXME: The icon needs to be set before the window is first shown.  Should some icon representation be part of the window creation data?
   1.685 + */
   1.686 +extern DECLSPEC void SDLCALL SDL_SetWindowIcon (SDL_Surface * icon);
   1.687 +
   1.688 +/**
   1.689 + * \fn void SDL_SetWindowData(SDL_WindowID windowID, void *userdata)
   1.690 + *
   1.691 + * \brief Associate an arbitrary pointer with the window.
   1.692   *
   1.693 - * If SDL_HWSURFACE is set in 'flags', the video surface will be placed in
   1.694 - * video memory, if possible, and you may have to call SDL_LockSurface()
   1.695 - * in order to access the raw framebuffer.  Otherwise, the video surface
   1.696 - * will be created in system memory.
   1.697 + * \sa SDL_GetWindowData()
   1.698 + */
   1.699 +extern DECLSPEC void SDLCALL SDL_SetWindowData (SDL_WindowID windowID,
   1.700 +                                                void *userdata);
   1.701 +
   1.702 +/**
   1.703 + * \fn void *SDL_GetWindowData(SDL_WindowID windowID)
   1.704   *
   1.705 - * If SDL_ASYNCBLIT is set in 'flags', SDL will try to perform rectangle
   1.706 - * updates asynchronously, but you must always lock before accessing pixels.
   1.707 - * SDL will wait for updates to complete before returning from the lock.
   1.708 + * \brief Retrieve the data pointer associated with the window.
   1.709 + *
   1.710 + * \sa SDL_SetWindowData()
   1.711 + */
   1.712 +extern DECLSPEC void *SDLCALL SDL_GetWindowData (SDL_WindowID windowID);
   1.713 +
   1.714 +/**
   1.715 + * \fn void SDL_SetWindowPosition(SDL_WindowID windowID, int x, int y)
   1.716 + *
   1.717 + * \brief Set the position of the window.
   1.718   *
   1.719 - * If SDL_HWPALETTE is set in 'flags', the SDL library will guarantee
   1.720 - * that the colors set by SDL_SetColors() will be the colors you get.
   1.721 - * Otherwise, in 8-bit mode, SDL_SetColors() may not be able to set all
   1.722 - * of the colors exactly the way they are requested, and you should look
   1.723 - * at the video surface structure to determine the actual palette.
   1.724 - * If SDL cannot guarantee that the colors you request can be set, 
   1.725 - * i.e. if the colormap is shared, then the video surface may be created
   1.726 - * under emulation in system memory, overriding the SDL_HWSURFACE flag.
   1.727 + * \sa SDL_GetWindowPosition()
   1.728 + */
   1.729 +extern DECLSPEC void SDLCALL SDL_SetWindowPosition (SDL_WindowID windowID,
   1.730 +                                                    int x, int y);
   1.731 +
   1.732 +/**
   1.733 + * \fn void SDL_GetWindowPosition(SDL_WindowID windowID, int *x, int *y)
   1.734 + *
   1.735 + * \brief Get the position of the window.
   1.736 + *
   1.737 + * \sa SDL_SetWindowPosition()
   1.738 + */
   1.739 +extern DECLSPEC void SDLCALL SDL_GetWindowPosition (SDL_WindowID windowID,
   1.740 +                                                    int *x, int *y);
   1.741 +
   1.742 +/**
   1.743 + * \fn void SDL_SetWindowSize(SDL_WindowID windowID, int w, int w)
   1.744 + *
   1.745 + * \brief Set the size of the window's client area.
   1.746 + *
   1.747 + * \note You can't change the size of a fullscreen window, it automatically
   1.748 + * matches the size of the display mode.
   1.749 + *
   1.750 + * \sa SDL_GetWindowSize()
   1.751 + */
   1.752 +extern DECLSPEC void SDLCALL SDL_SetWindowSize (SDL_WindowID windowID, int w,
   1.753 +                                                int h);
   1.754 +
   1.755 +/**
   1.756 + * \fn void SDL_GetWindowSize(SDL_WindowID windowID, int *w, int *w)
   1.757   *
   1.758 - * If SDL_FULLSCREEN is set in 'flags', the SDL library will try to set
   1.759 - * a fullscreen video mode.  The default is to create a windowed mode
   1.760 - * if the current graphics system has a window manager.
   1.761 - * If the SDL library is able to set a fullscreen video mode, this flag 
   1.762 - * will be set in the surface that is returned.
   1.763 + * \brief Get the size of the window's client area.
   1.764 + *
   1.765 + * \sa SDL_SetWindowSize()
   1.766 + */
   1.767 +extern DECLSPEC void SDLCALL SDL_GetWindowSize (SDL_WindowID windowID, int *w,
   1.768 +                                                int *h);
   1.769 +
   1.770 +/**
   1.771 + * \fn void SDL_ShowWindow(SDL_WindowID windowID)
   1.772 + *
   1.773 + * \brief Show the window
   1.774 + *
   1.775 + * \sa SDL_HideWindow()
   1.776 + */
   1.777 +extern DECLSPEC void SDLCALL SDL_ShowWindow (SDL_WindowID windowID);
   1.778 +
   1.779 +/**
   1.780 + * \fn void SDL_HideWindow(SDL_WindowID windowID)
   1.781 + *
   1.782 + * \brief Hide the window
   1.783   *
   1.784 - * If SDL_DOUBLEBUF is set in 'flags', the SDL library will try to set up
   1.785 - * two surfaces in video memory and swap between them when you call 
   1.786 - * SDL_Flip().  This is usually slower than the normal single-buffering
   1.787 - * scheme, but prevents "tearing" artifacts caused by modifying video 
   1.788 - * memory while the monitor is refreshing.  It should only be used by 
   1.789 - * applications that redraw the entire screen on every update.
   1.790 + * \sa SDL_ShowWindow()
   1.791 + */
   1.792 +extern DECLSPEC void SDLCALL SDL_HideWindow (SDL_WindowID windowID);
   1.793 +
   1.794 +/**
   1.795 + * \fn void SDL_RaiseWindow(SDL_WindowID windowID)
   1.796 + *
   1.797 + * \brief Raise the window so it's above other windows.
   1.798 + */
   1.799 +extern DECLSPEC void SDLCALL SDL_RaiseWindow (SDL_WindowID windowID);
   1.800 +
   1.801 +/**
   1.802 + * \fn void SDL_MaximizeWindow(SDL_WindowID windowID)
   1.803 + *
   1.804 + * \brief Make the window as large as possible.
   1.805 + *
   1.806 + * \sa SDL_RestoreWindow()
   1.807 + */
   1.808 +extern DECLSPEC void SDLCALL SDL_MaximizeWindow (SDL_WindowID windowID);
   1.809 +
   1.810 +/**
   1.811 + * \fn void SDL_MinimizeWindow(SDL_WindowID windowID)
   1.812 + *
   1.813 + * \brief Minimize the window to an iconic representation.
   1.814   *
   1.815 - * If SDL_RESIZABLE is set in 'flags', the SDL library will allow the
   1.816 - * window manager, if any, to resize the window at runtime.  When this
   1.817 - * occurs, SDL will send a SDL_VIDEORESIZE event to you application,
   1.818 - * and you must respond to the event by re-calling SDL_SetVideoMode()
   1.819 - * with the requested size (or another size that suits the application).
   1.820 + * \sa SDL_RestoreWindow()
   1.821 + */
   1.822 +extern DECLSPEC void SDLCALL SDL_MinimizeWindow (SDL_WindowID windowID);
   1.823 +
   1.824 +/**
   1.825 + * \fn void SDL_RestoreWindow(SDL_WindowID windowID)
   1.826 + *
   1.827 + * \brief Restore the size and position of a minimized or maximized window.
   1.828   *
   1.829 - * If SDL_NOFRAME is set in 'flags', the SDL library will create a window
   1.830 - * without any title bar or frame decoration.  Fullscreen video modes have
   1.831 - * this flag set automatically.
   1.832 + * \sa SDL_MaximizeWindow()
   1.833 + * \sa SDL_MinimizeWindow()
   1.834 + */
   1.835 +extern DECLSPEC void SDLCALL SDL_RestoreWindow (SDL_WindowID windowID);
   1.836 +
   1.837 +/**
   1.838 + * \fn void SDL_SetWindowGrab(SDL_WindowID windowID, int mode)
   1.839 + *
   1.840 + * \brief Set the window's input grab mode.
   1.841 + *
   1.842 + * \param mode This is 1 to grab input, and 0 to release input.
   1.843   *
   1.844 - * This function returns the video framebuffer surface, or NULL if it fails.
   1.845 + * \sa SDL_GrabMode
   1.846 + * \sa SDL_GetWindowGrab()
   1.847 + */
   1.848 +extern DECLSPEC void SDLCALL SDL_SetWindowGrab (SDL_WindowID windowID,
   1.849 +                                                int mode);
   1.850 +
   1.851 +/**
   1.852 + * \fn int SDL_GetWindowGrab(SDL_WindowID windowID)
   1.853 + *
   1.854 + * \brief Get the window's input grab mode.
   1.855 + *
   1.856 + * \return This returns 1 if input is grabbed, and 0 otherwise.
   1.857   *
   1.858 - * If you rely on functionality provided by certain video flags, check the
   1.859 - * flags of the returned surface to make sure that functionality is available.
   1.860 - * SDL will fall back to reduced functionality if the exact flags you wanted
   1.861 - * are not available.
   1.862 + * \sa SDL_GrabMode
   1.863 + * \sa SDL_SetWindowGrab()
   1.864 + */
   1.865 +extern DECLSPEC int SDLCALL SDL_GetWindowGrab (SDL_WindowID windowID);
   1.866 +
   1.867 +/**
   1.868 + * \fn void SDL_DestroyWindow(SDL_WindowID windowID)
   1.869 + *
   1.870 + * \brief Destroy a window.
   1.871   */
   1.872 -extern DECLSPEC SDL_Surface * SDLCALL SDL_SetVideoMode
   1.873 -			(int width, int height, int bpp, Uint32 flags);
   1.874 +extern DECLSPEC void SDLCALL SDL_DestroyWindow (SDL_WindowID windowID);
   1.875 +
   1.876 +/**
   1.877 + * \fn SDL_Surface *SDL_CreateWindowSurface (SDL_WindowID windowID, Uint32 format, Uint32 flags)
   1.878 + *
   1.879 + * \brief Create an SDL_Surface representing the drawing area of the window.
   1.880 + */
   1.881 +extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateWindowSurface (SDL_WindowID
   1.882 +                                                              windowID,
   1.883 +                                                              Uint32 format,
   1.884 +                                                              Uint32 flags);
   1.885  
   1.886  /*
   1.887   * Makes sure the given list of rectangles is updated on the given screen.
   1.888 @@ -359,9 +684,9 @@
   1.889   * These functions should not be called while 'screen' is locked.
   1.890   */
   1.891  extern DECLSPEC void SDLCALL SDL_UpdateRects
   1.892 -		(SDL_Surface *screen, int numrects, SDL_Rect *rects);
   1.893 +    (SDL_Surface * screen, int numrects, SDL_Rect * rects);
   1.894  extern DECLSPEC void SDLCALL SDL_UpdateRect
   1.895 -		(SDL_Surface *screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h);
   1.896 +    (SDL_Surface * screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h);
   1.897  
   1.898  /*
   1.899   * On hardware that supports double-buffering, this function sets up a flip
   1.900 @@ -373,7 +698,7 @@
   1.901   * setting the video mode for this function to perform hardware flipping.
   1.902   * This function returns 0 if successful, or -1 if there was an error.
   1.903   */
   1.904 -extern DECLSPEC int SDLCALL SDL_Flip(SDL_Surface *screen);
   1.905 +extern DECLSPEC int SDLCALL SDL_Flip (SDL_Surface * screen);
   1.906  
   1.907  /*
   1.908   * Set the gamma correction for each of the color channels.
   1.909 @@ -383,7 +708,7 @@
   1.910   * be emulated using gamma ramps, if available.  If successful, this
   1.911   * function returns 0, otherwise it returns -1.
   1.912   */
   1.913 -extern DECLSPEC int SDLCALL SDL_SetGamma(float red, float green, float blue);
   1.914 +extern DECLSPEC int SDLCALL SDL_SetGamma (float red, float green, float blue);
   1.915  
   1.916  /*
   1.917   * Set the gamma translation table for the red, green, and blue channels
   1.918 @@ -397,7 +722,9 @@
   1.919   * hardware does not support gamma translation, or otherwise fails,
   1.920   * this function will return -1.
   1.921   */
   1.922 -extern DECLSPEC int SDLCALL SDL_SetGammaRamp(const Uint16 *red, const Uint16 *green, const Uint16 *blue);
   1.923 +extern DECLSPEC int SDLCALL SDL_SetGammaRamp (const Uint16 * red,
   1.924 +                                              const Uint16 * green,
   1.925 +                                              const Uint16 * blue);
   1.926  
   1.927  /*
   1.928   * Retrieve the current values of the gamma translation tables.
   1.929 @@ -408,7 +735,8 @@
   1.930   * hardware does not support gamma translation, or otherwise fails,
   1.931   * this function will return -1.
   1.932   */
   1.933 -extern DECLSPEC int SDLCALL SDL_GetGammaRamp(Uint16 *red, Uint16 *green, Uint16 *blue);
   1.934 +extern DECLSPEC int SDLCALL SDL_GetGammaRamp (Uint16 * red, Uint16 * green,
   1.935 +                                              Uint16 * blue);
   1.936  
   1.937  /*
   1.938   * Sets a portion of the colormap for the given 8-bit surface.  If 'surface'
   1.939 @@ -425,52 +753,35 @@
   1.940   * you desire, even if the window colormap has to be warped or run under
   1.941   * emulation.
   1.942   */
   1.943 -extern DECLSPEC int SDLCALL SDL_SetColors(SDL_Surface *surface, 
   1.944 -			SDL_Color *colors, int firstcolor, int ncolors);
   1.945 -
   1.946 -/*
   1.947 - * Sets a portion of the colormap for a given 8-bit surface.
   1.948 - * 'flags' is one or both of:
   1.949 - * SDL_LOGPAL  -- set logical palette, which controls how blits are mapped
   1.950 - *                to/from the surface,
   1.951 - * SDL_PHYSPAL -- set physical palette, which controls how pixels look on
   1.952 - *                the screen
   1.953 - * Only screens have physical palettes. Separate change of physical/logical
   1.954 - * palettes is only possible if the screen has SDL_HWPALETTE set.
   1.955 - *
   1.956 - * The return value is 1 if all colours could be set as requested, and 0
   1.957 - * otherwise.
   1.958 - *
   1.959 - * SDL_SetColors() is equivalent to calling this function with
   1.960 - *     flags = (SDL_LOGPAL|SDL_PHYSPAL).
   1.961 - */
   1.962 -extern DECLSPEC int SDLCALL SDL_SetPalette(SDL_Surface *surface, int flags,
   1.963 -				   SDL_Color *colors, int firstcolor,
   1.964 -				   int ncolors);
   1.965 +extern DECLSPEC int SDLCALL SDL_SetColors (SDL_Surface * surface,
   1.966 +                                           SDL_Color * colors, int firstcolor,
   1.967 +                                           int ncolors);
   1.968  
   1.969  /*
   1.970   * Maps an RGB triple to an opaque pixel value for a given pixel format
   1.971   */
   1.972  extern DECLSPEC Uint32 SDLCALL SDL_MapRGB
   1.973 -			(SDL_PixelFormat *format, Uint8 r, Uint8 g, Uint8 b);
   1.974 +    (SDL_PixelFormat * format, Uint8 r, Uint8 g, Uint8 b);
   1.975  
   1.976  /*
   1.977   * Maps an RGBA quadruple to a pixel value for a given pixel format
   1.978   */
   1.979 -extern DECLSPEC Uint32 SDLCALL SDL_MapRGBA(SDL_PixelFormat *format,
   1.980 -				   Uint8 r, Uint8 g, Uint8 b, Uint8 a);
   1.981 +extern DECLSPEC Uint32 SDLCALL SDL_MapRGBA (SDL_PixelFormat * format,
   1.982 +                                            Uint8 r, Uint8 g, Uint8 b,
   1.983 +                                            Uint8 a);
   1.984  
   1.985  /*
   1.986   * Maps a pixel value into the RGB components for a given pixel format
   1.987   */
   1.988 -extern DECLSPEC void SDLCALL SDL_GetRGB(Uint32 pixel, SDL_PixelFormat *fmt,
   1.989 -				Uint8 *r, Uint8 *g, Uint8 *b);
   1.990 +extern DECLSPEC void SDLCALL SDL_GetRGB (Uint32 pixel, SDL_PixelFormat * fmt,
   1.991 +                                         Uint8 * r, Uint8 * g, Uint8 * b);
   1.992  
   1.993  /*
   1.994   * Maps a pixel value into the RGBA components for a given pixel format
   1.995   */
   1.996 -extern DECLSPEC void SDLCALL SDL_GetRGBA(Uint32 pixel, SDL_PixelFormat *fmt,
   1.997 -				 Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a);
   1.998 +extern DECLSPEC void SDLCALL SDL_GetRGBA (Uint32 pixel, SDL_PixelFormat * fmt,
   1.999 +                                          Uint8 * r, Uint8 * g, Uint8 * b,
  1.1000 +                                          Uint8 * a);
  1.1001  
  1.1002  /*
  1.1003   * Allocate and free an RGB surface (must be called after SDL_SetVideoMode)
  1.1004 @@ -507,13 +818,19 @@
  1.1005   * the SDL_HWSURFACE flag set, and will be created in system memory instead.
  1.1006   */
  1.1007  #define SDL_AllocSurface    SDL_CreateRGBSurface
  1.1008 -extern DECLSPEC SDL_Surface * SDLCALL SDL_CreateRGBSurface
  1.1009 -			(Uint32 flags, int width, int height, int depth, 
  1.1010 -			Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
  1.1011 -extern DECLSPEC SDL_Surface * SDLCALL SDL_CreateRGBSurfaceFrom(void *pixels,
  1.1012 -			int width, int height, int depth, int pitch,
  1.1013 -			Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
  1.1014 -extern DECLSPEC void SDLCALL SDL_FreeSurface(SDL_Surface *surface);
  1.1015 +extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurface
  1.1016 +    (Uint32 flags, int width, int height, int depth,
  1.1017 +     Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
  1.1018 +extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceFrom (void *pixels,
  1.1019 +                                                               int width,
  1.1020 +                                                               int height,
  1.1021 +                                                               int depth,
  1.1022 +                                                               int pitch,
  1.1023 +                                                               Uint32 Rmask,
  1.1024 +                                                               Uint32 Gmask,
  1.1025 +                                                               Uint32 Bmask,
  1.1026 +                                                               Uint32 Amask);
  1.1027 +extern DECLSPEC void SDLCALL SDL_FreeSurface (SDL_Surface * surface);
  1.1028  
  1.1029  /*
  1.1030   * SDL_LockSurface() sets up a surface for directly accessing the pixels.
  1.1031 @@ -533,8 +850,8 @@
  1.1032   *
  1.1033   * SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.
  1.1034   */
  1.1035 -extern DECLSPEC int SDLCALL SDL_LockSurface(SDL_Surface *surface);
  1.1036 -extern DECLSPEC void SDLCALL SDL_UnlockSurface(SDL_Surface *surface);
  1.1037 +extern DECLSPEC int SDLCALL SDL_LockSurface (SDL_Surface * surface);
  1.1038 +extern DECLSPEC void SDLCALL SDL_UnlockSurface (SDL_Surface * surface);
  1.1039  
  1.1040  /*
  1.1041   * Load a surface from a seekable SDL data source (memory or file.)
  1.1042 @@ -542,7 +859,8 @@
  1.1043   * Returns the new surface, or NULL if there was an error.
  1.1044   * The new surface should be freed with SDL_FreeSurface().
  1.1045   */
  1.1046 -extern DECLSPEC SDL_Surface * SDLCALL SDL_LoadBMP_RW(SDL_RWops *src, int freesrc);
  1.1047 +extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP_RW (SDL_RWops * src,
  1.1048 +                                                     int freesrc);
  1.1049  
  1.1050  /* Convenience macro -- load a surface from a file */
  1.1051  #define SDL_LoadBMP(file)	SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)
  1.1052 @@ -553,7 +871,7 @@
  1.1053   * Returns 0 if successful or -1 if there was an error.
  1.1054   */
  1.1055  extern DECLSPEC int SDLCALL SDL_SaveBMP_RW
  1.1056 -		(SDL_Surface *surface, SDL_RWops *dst, int freedst);
  1.1057 +    (SDL_Surface * surface, SDL_RWops * dst, int freedst);
  1.1058  
  1.1059  /* Convenience macro -- save a surface to a file */
  1.1060  #define SDL_SaveBMP(surface, file) \
  1.1061 @@ -569,7 +887,7 @@
  1.1062   * This function returns 0, or -1 if there was an error.
  1.1063   */
  1.1064  extern DECLSPEC int SDLCALL SDL_SetColorKey
  1.1065 -			(SDL_Surface *surface, Uint32 flag, Uint32 key);
  1.1066 +    (SDL_Surface * surface, Uint32 flag, Uint32 key);
  1.1067  
  1.1068  /*
  1.1069   * This function sets the alpha value for the entire surface, as opposed to
  1.1070 @@ -586,7 +904,8 @@
  1.1071   *
  1.1072   * The 'alpha' parameter is ignored for surfaces that have an alpha channel.
  1.1073   */
  1.1074 -extern DECLSPEC int SDLCALL SDL_SetAlpha(SDL_Surface *surface, Uint32 flag, Uint8 alpha);
  1.1075 +extern DECLSPEC int SDLCALL SDL_SetAlpha (SDL_Surface * surface, Uint32 flag,
  1.1076 +                                          Uint8 alpha);
  1.1077  
  1.1078  /*
  1.1079   * Sets the clipping rectangle for the destination surface in a blit.
  1.1080 @@ -600,14 +919,16 @@
  1.1081   * Note that blits are automatically clipped to the edges of the source
  1.1082   * and destination surfaces.
  1.1083   */
  1.1084 -extern DECLSPEC SDL_bool SDLCALL SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect);
  1.1085 +extern DECLSPEC SDL_bool SDLCALL SDL_SetClipRect (SDL_Surface * surface,
  1.1086 +                                                  const SDL_Rect * rect);
  1.1087  
  1.1088  /*
  1.1089   * Gets the clipping rectangle for the destination surface in a blit.
  1.1090   * 'rect' must be a pointer to a valid rectangle which will be filled
  1.1091   * with the correct values.
  1.1092   */
  1.1093 -extern DECLSPEC void SDLCALL SDL_GetClipRect(SDL_Surface *surface, SDL_Rect *rect);
  1.1094 +extern DECLSPEC void SDLCALL SDL_GetClipRect (SDL_Surface * surface,
  1.1095 +                                              SDL_Rect * rect);
  1.1096  
  1.1097  /*
  1.1098   * Creates a new surface of the specified format, and then copies and maps 
  1.1099 @@ -621,8 +942,8 @@
  1.1100   *
  1.1101   * This function is used internally by SDL_DisplayFormat().
  1.1102   */
  1.1103 -extern DECLSPEC SDL_Surface * SDLCALL SDL_ConvertSurface
  1.1104 -			(SDL_Surface *src, SDL_PixelFormat *fmt, Uint32 flags);
  1.1105 +extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurface
  1.1106 +    (SDL_Surface * src, SDL_PixelFormat * fmt, Uint32 flags);
  1.1107  
  1.1108  /*
  1.1109   * This performs a fast blit from the source surface to the destination
  1.1110 @@ -699,14 +1020,14 @@
  1.1111     rectangle validation and clipping before passing it to SDL_LowerBlit()
  1.1112  */
  1.1113  extern DECLSPEC int SDLCALL SDL_UpperBlit
  1.1114 -			(SDL_Surface *src, SDL_Rect *srcrect,
  1.1115 -			 SDL_Surface *dst, SDL_Rect *dstrect);
  1.1116 +    (SDL_Surface * src, SDL_Rect * srcrect,
  1.1117 +     SDL_Surface * dst, SDL_Rect * dstrect);
  1.1118  /* This is a semi-private blit function and it performs low-level surface
  1.1119     blitting only.
  1.1120  */
  1.1121  extern DECLSPEC int SDLCALL SDL_LowerBlit
  1.1122 -			(SDL_Surface *src, SDL_Rect *srcrect,
  1.1123 -			 SDL_Surface *dst, SDL_Rect *dstrect);
  1.1124 +    (SDL_Surface * src, SDL_Rect * srcrect,
  1.1125 +     SDL_Surface * dst, SDL_Rect * dstrect);
  1.1126  
  1.1127  /*
  1.1128   * This function performs a fast fill of the given rectangle with 'color'
  1.1129 @@ -718,7 +1039,7 @@
  1.1130   * This function returns 0 on success, or -1 on error.
  1.1131   */
  1.1132  extern DECLSPEC int SDLCALL SDL_FillRect
  1.1133 -		(SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color);
  1.1134 +    (SDL_Surface * dst, SDL_Rect * dstrect, Uint32 color);
  1.1135  
  1.1136  /* 
  1.1137   * This function takes a surface and copies it to a new surface of the
  1.1138 @@ -731,7 +1052,8 @@
  1.1139   *
  1.1140   * If the conversion fails or runs out of memory, it returns NULL
  1.1141   */
  1.1142 -extern DECLSPEC SDL_Surface * SDLCALL SDL_DisplayFormat(SDL_Surface *surface);
  1.1143 +extern DECLSPEC SDL_Surface *SDLCALL SDL_DisplayFormat (SDL_Surface *
  1.1144 +                                                        surface);
  1.1145  
  1.1146  /* 
  1.1147   * This function takes a surface and copies it to a new surface of the
  1.1148 @@ -745,7 +1067,8 @@
  1.1149   *
  1.1150   * If the conversion fails or runs out of memory, it returns NULL
  1.1151   */
  1.1152 -extern DECLSPEC SDL_Surface * SDLCALL SDL_DisplayFormatAlpha(SDL_Surface *surface);
  1.1153 +extern DECLSPEC SDL_Surface *SDLCALL SDL_DisplayFormatAlpha (SDL_Surface *
  1.1154 +                                                             surface);
  1.1155  
  1.1156  
  1.1157  /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  1.1158 @@ -757,12 +1080,15 @@
  1.1159     the contents of the display surface underneath the area where the overlay
  1.1160     is shown is undefined - it may be overwritten with the converted YUV data.
  1.1161  */
  1.1162 -extern DECLSPEC SDL_Overlay * SDLCALL SDL_CreateYUVOverlay(int width, int height,
  1.1163 -				Uint32 format, SDL_Surface *display);
  1.1164 +extern DECLSPEC SDL_Overlay *SDLCALL SDL_CreateYUVOverlay (int width,
  1.1165 +                                                           int height,
  1.1166 +                                                           Uint32 format,
  1.1167 +                                                           SDL_Surface *
  1.1168 +                                                           display);
  1.1169  
  1.1170  /* Lock an overlay for direct access, and unlock it when you are done */
  1.1171 -extern DECLSPEC int SDLCALL SDL_LockYUVOverlay(SDL_Overlay *overlay);
  1.1172 -extern DECLSPEC void SDLCALL SDL_UnlockYUVOverlay(SDL_Overlay *overlay);
  1.1173 +extern DECLSPEC int SDLCALL SDL_LockYUVOverlay (SDL_Overlay * overlay);
  1.1174 +extern DECLSPEC void SDLCALL SDL_UnlockYUVOverlay (SDL_Overlay * overlay);
  1.1175  
  1.1176  /* Blit a video overlay to the display surface.
  1.1177     The contents of the video surface underneath the blit destination are
  1.1178 @@ -770,10 +1096,11 @@
  1.1179     The width and height of the destination rectangle may be different from
  1.1180     that of the overlay, but currently only 2x scaling is supported.
  1.1181  */
  1.1182 -extern DECLSPEC int SDLCALL SDL_DisplayYUVOverlay(SDL_Overlay *overlay, SDL_Rect *dstrect);
  1.1183 +extern DECLSPEC int SDLCALL SDL_DisplayYUVOverlay (SDL_Overlay * overlay,
  1.1184 +                                                   SDL_Rect * dstrect);
  1.1185  
  1.1186  /* Free a video overlay */
  1.1187 -extern DECLSPEC void SDLCALL SDL_FreeYUVOverlay(SDL_Overlay *overlay);
  1.1188 +extern DECLSPEC void SDLCALL SDL_FreeYUVOverlay (SDL_Overlay * overlay);
  1.1189  
  1.1190  
  1.1191  /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  1.1192 @@ -786,17 +1113,17 @@
  1.1193   * If you do this, you need to retrieve all of the GL functions used in
  1.1194   * your program from the dynamic library using SDL_GL_GetProcAddress().
  1.1195   */
  1.1196 -extern DECLSPEC int SDLCALL SDL_GL_LoadLibrary(const char *path);
  1.1197 +extern DECLSPEC int SDLCALL SDL_GL_LoadLibrary (const char *path);
  1.1198  
  1.1199  /*
  1.1200   * Get the address of a GL function
  1.1201   */
  1.1202 -extern DECLSPEC void * SDLCALL SDL_GL_GetProcAddress(const char* proc);
  1.1203 +extern DECLSPEC void *SDLCALL SDL_GL_GetProcAddress (const char *proc);
  1.1204  
  1.1205  /*
  1.1206 - * Set an attribute of the OpenGL subsystem before intialization.
  1.1207 + * Set an attribute of the OpenGL subsystem before window creation.
  1.1208   */
  1.1209 -extern DECLSPEC int SDLCALL SDL_GL_SetAttribute(SDL_GLattr attr, int value);
  1.1210 +extern DECLSPEC int SDLCALL SDL_GL_SetAttribute (SDL_GLattr attr, int value);
  1.1211  
  1.1212  /*
  1.1213   * Get an attribute of the OpenGL subsystem from the windowing
  1.1214 @@ -807,80 +1134,27 @@
  1.1215   * Developers should track the values they pass into SDL_GL_SetAttribute
  1.1216   * themselves if they want to retrieve these values.
  1.1217   */
  1.1218 -extern DECLSPEC int SDLCALL SDL_GL_GetAttribute(SDL_GLattr attr, int* value);
  1.1219 +extern DECLSPEC int SDLCALL SDL_GL_GetAttribute (SDL_GLattr attr, int *value);
  1.1220  
  1.1221  /*
  1.1222   * Swap the OpenGL buffers, if double-buffering is supported.
  1.1223   */
  1.1224 -extern DECLSPEC void SDLCALL SDL_GL_SwapBuffers(void);
  1.1225 -
  1.1226 -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  1.1227 -/* These functions allow interaction with the window manager, if any.        */
  1.1228 -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  1.1229 -
  1.1230 -/*
  1.1231 - * Sets/Gets the title and icon text of the display window (UTF-8 encoded)
  1.1232 - */
  1.1233 -extern DECLSPEC void SDLCALL SDL_WM_SetCaption(const char *title, const char *icon);
  1.1234 -extern DECLSPEC void SDLCALL SDL_WM_GetCaption(char **title, char **icon);
  1.1235 -
  1.1236 -/*
  1.1237 - * Sets the icon for the display window.
  1.1238 - * This function must be called before the first call to SDL_SetVideoMode().
  1.1239 - * It takes an icon surface, and a mask in MSB format.
  1.1240 - * If 'mask' is NULL, the entire icon surface will be used as the icon.
  1.1241 - */
  1.1242 -extern DECLSPEC void SDLCALL SDL_WM_SetIcon(SDL_Surface *icon, Uint8 *mask);
  1.1243 -
  1.1244 -/*
  1.1245 - * This function iconifies the window, and returns 1 if it succeeded.
  1.1246 - * If the function succeeds, it generates an SDL_APPACTIVE loss event.
  1.1247 - * This function is a noop and returns 0 in non-windowed environments.
  1.1248 - */
  1.1249 -extern DECLSPEC int SDLCALL SDL_WM_IconifyWindow(void);
  1.1250 -
  1.1251 -/*
  1.1252 - * Toggle fullscreen mode without changing the contents of the screen.
  1.1253 - * If the display surface does not require locking before accessing
  1.1254 - * the pixel information, then the memory pointers will not change.
  1.1255 - *
  1.1256 - * If this function was able to toggle fullscreen mode (change from 
  1.1257 - * running in a window to fullscreen, or vice-versa), it will return 1.
  1.1258 - * If it is not implemented, or fails, it returns 0.
  1.1259 - *
  1.1260 - * The next call to SDL_SetVideoMode() will set the mode fullscreen
  1.1261 - * attribute based on the flags parameter - if SDL_FULLSCREEN is not
  1.1262 - * set, then the display will be windowed by default where supported.
  1.1263 - *
  1.1264 - * This is currently only implemented in the X11 video driver.
  1.1265 - */
  1.1266 -extern DECLSPEC int SDLCALL SDL_WM_ToggleFullScreen(SDL_Surface *surface);
  1.1267 -
  1.1268 -/*
  1.1269 - * This function allows you to set and query the input grab state of
  1.1270 - * the application.  It returns the new input grab state.
  1.1271 - */
  1.1272 -typedef enum {
  1.1273 -	SDL_GRAB_QUERY = -1,
  1.1274 -	SDL_GRAB_OFF = 0,
  1.1275 -	SDL_GRAB_ON = 1,
  1.1276 -	SDL_GRAB_FULLSCREEN	/* Used internally */
  1.1277 -} SDL_GrabMode;
  1.1278 -/*
  1.1279 - * Grabbing means that the mouse is confined to the application window,
  1.1280 - * and nearly all keyboard input is passed directly to the application,
  1.1281 - * and not interpreted by a window manager, if any.
  1.1282 - */
  1.1283 -extern DECLSPEC SDL_GrabMode SDLCALL SDL_WM_GrabInput(SDL_GrabMode mode);
  1.1284 +extern DECLSPEC void SDLCALL SDL_GL_SwapBuffers (void);
  1.1285  
  1.1286  /* Not in public API at the moment - do not use! */
  1.1287 -extern DECLSPEC int SDLCALL SDL_SoftStretch(SDL_Surface *src, SDL_Rect *srcrect,
  1.1288 -                                    SDL_Surface *dst, SDL_Rect *dstrect);
  1.1289 -                    
  1.1290 +extern DECLSPEC int SDLCALL SDL_SoftStretch (SDL_Surface * src,
  1.1291 +                                             SDL_Rect * srcrect,
  1.1292 +                                             SDL_Surface * dst,
  1.1293 +                                             SDL_Rect * dstrect);
  1.1294 +
  1.1295  /* Ends C function definitions when using C++ */
  1.1296  #ifdef __cplusplus
  1.1297 +/* *INDENT-OFF* */
  1.1298  }
  1.1299 +/* *INDENT-ON* */
  1.1300  #endif
  1.1301  #include "close_code.h"
  1.1302  
  1.1303  #endif /* _SDL_video_h */
  1.1304 +
  1.1305 +/* vi: set ts=4 sw=4 expandtab: */