--- a/include/SDL_video.h	Sun May 21 17:27:13 2006 +0000
+++ b/include/SDL_video.h	Sun May 28 13:04:16 2006 +0000
@@ -20,19 +20,26 @@
     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 */
@@ -40,131 +47,43 @@
 #define SDL_ALPHA_TRANSPARENT 0
 
 /* Useful data types */
-typedef struct SDL_Rect {
-	Sint16 x, y;
-	Uint16 w, h;
+typedef struct SDL_Rect
+{
+    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 {
-	Uint32 flags;				/* Read-only */
-	SDL_PixelFormat *format;		/* Read-only */
-	int w, h;				/* Read-only */
-	Uint16 pitch;				/* Read-only */
-	void *pixels;				/* Read-write */
-	int offset;				/* Private */
-
-	/* Hardware-specific surface info */
-	struct private_hwdata *hwdata;
+typedef struct SDL_Surface
+{
+    Uint32 flags;               /* Read-only */
+    SDL_PixelFormat *format;    /* Read-only */
+    int w, h;                   /* Read-only */
+    Uint16 pitch;               /* Read-only */
+    void *pixels;               /* Read-write */
+    int offset;                 /* Private */
 
-	/* clipping information */
-	SDL_Rect clip_rect;			/* Read-only */
-	Uint32 unused1;				/* for binary compatibility */
-
-	/* Allow recursive locks */
-	Uint32 locked;				/* 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 */
-
-	/* Reference count -- used when freeing surface */
-	int refcount;				/* Read-mostly */
-} SDL_Surface;
+    /* Hardware-specific surface info */
+    struct private_hwdata *hwdata;
 
-/* These are the currently supported flags for the SDL_surface */
-/* Available for SDL_CreateRGBSurface() or SDL_SetVideoMode() */
-#define SDL_SWSURFACE	0x00000000	/* Surface is in system memory */
-#define SDL_HWSURFACE	0x00000001	/* Surface is in video memory */
-#define SDL_ASYNCBLIT	0x00000004	/* Use asynchronous blits if possible */
-/* Available for SDL_SetVideoMode() */
-#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 video mode */
-#define SDL_FULLSCREEN	0x80000000	/* Surface is a full screen display */
-#define SDL_OPENGL      0x00000002      /* Create an OpenGL rendering context */
-#define SDL_INTERNALOPENGL 0x00000008   /* SDL uses OpenGL internally for this window */
-#define SDL_RESIZABLE	0x00000010	/* This video mode may be resized */
-#define SDL_NOFRAME	0x00000020	/* No window caption or edge frame */
-/* 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	0x01000000	/* Surface uses preallocated memory */
+    /* clipping information */
+    SDL_Rect clip_rect;         /* Read-only */
+    Uint32 unused1;             /* for binary compatibility */
+
+    /* Allow recursive locks */
+    Uint32 locked;              /* Private */
 
-/* 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))
-
-/* typedef for private surface blitting functions */
-typedef int (*SDL_blit)(struct SDL_Surface *src, SDL_Rect *srcrect,
-			struct SDL_Surface *dst, SDL_Rect *dstrect);
-
+    /* info for fast blit mapping to other surfaces */
+    struct SDL_BlitMap *map;    /* Private */
 
-/* Useful for determining the video hardware capabilities */
-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 UnusedBits1  :6;
-	Uint32 UnusedBits2  :1;
-	Uint32 blit_hw      :1;	/* Flag: Accelerated blits HW --> HW */
-	Uint32 blit_hw_CC   :1;	/* Flag: Accelerated blits with Colorkey */
-	Uint32 blit_hw_A    :1;	/* Flag: Accelerated blits with Alpha */
-	Uint32 blit_sw      :1;	/* Flag: Accelerated blits SW --> HW */
-	Uint32 blit_sw_CC   :1;	/* Flag: Accelerated blits with Colorkey */
-	Uint32 blit_sw_A    :1;	/* Flag: Accelerated blits with Alpha */
-	Uint32 blit_fill    :1;	/* Flag: Accelerated color fill */
-	Uint32 UnusedBits3  :16;
-	Uint32 video_mem;	/* The total amount of video memory (in K) */
-	SDL_PixelFormat *vfmt;	/* Value: The format of the video surface */
-	int    current_w;	/* Value: The current video mode width */
-	int    current_h;	/* Value: The current video mode height */
-} SDL_VideoInfo;
+    /* 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 */
+} SDL_Surface;
 
 /* The most common video overlay formats.
    For an explanation of these pixel formats, see:
@@ -173,32 +92,154 @@
    For information on the relationship between color spaces, see:
    http://www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html
  */
-#define SDL_YV12_OVERLAY  0x32315659	/* Planar mode: Y + V + U  (3 planes) */
-#define SDL_IYUV_OVERLAY  0x56555949	/* Planar mode: Y + U + V  (3 planes) */
-#define SDL_YUY2_OVERLAY  0x32595559	/* Packed mode: Y0+U0+Y1+V0 (1 plane) */
-#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) */
+#define SDL_YV12_OVERLAY  0x32315659    /* Planar mode: Y + V + U  (3 planes) */
+#define SDL_IYUV_OVERLAY  0x56555949    /* Planar mode: Y + U + V  (3 planes) */
+#define SDL_YUY2_OVERLAY  0x32595559    /* Packed mode: Y0+U0+Y1+V0 (1 plane) */
+#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) */
 
 /* The YUV hardware video overlay */
-typedef struct SDL_Overlay {
-	Uint32 format;				/* Read-only */
-	int w, h;				/* Read-only */
-	int planes;				/* Read-only */
-	Uint16 *pitches;			/* Read-only */
-	Uint8 **pixels;				/* Read-write */
+typedef struct SDL_Overlay
+{
+    Uint32 format;              /* Read-only */
+    int w, h;                   /* Read-only */
+    int planes;                 /* Read-only */
+    Uint16 *pitches;            /* Read-only */
+    Uint8 **pixels;             /* Read-write */
 
-	/* Hardware-specific surface info */
-	struct private_yuvhwfuncs *hwfuncs;
-	struct private_yuvhwdata *hwdata;
+    /* 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;
+    /* 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_RLEACCEL)) != 0))
 
-/* Public enumeration for setting the OpenGL window attributes. */
-typedef enum {
+/* typedef for private surface blitting functions */
+typedef int (*SDL_blit) (struct SDL_Surface * src, SDL_Rect * srcrect,
+                         struct SDL_Surface * dst, SDL_Rect * dstrect);
+
+
+/* Useful for determining the video hardware capabilities */
+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 UnusedBits1:6;
+    Uint32 UnusedBits2:1;
+    Uint32 blit_hw:1;           /* Flag: Accelerated blits HW --> HW */
+    Uint32 blit_hw_CC:1;        /* Flag: Accelerated blits with Colorkey */
+    Uint32 blit_hw_A:1;         /* Flag: Accelerated blits with Alpha */
+    Uint32 blit_sw:1;           /* Flag: Accelerated blits SW --> HW */
+    Uint32 blit_sw_CC:1;        /* Flag: Accelerated blits with Colorkey */
+    Uint32 blit_sw_A:1;         /* Flag: Accelerated blits with Alpha */
+    Uint32 blit_fill:1;         /* Flag: Accelerated color fill */
+    Uint32 UnusedBits3:16;
+    Uint32 video_mem;           /* The total amount of video memory (in K) */
+} SDL_VideoInfo;
+
+/**
+ * \struct SDL_DisplayMode
+ *
+ * \brief  The structure that defines a display mode
+ *
+ * \sa SDL_GetNumDisplayModes()
+ * \sa SDL_GetDisplayMode()
+ * \sa SDL_GetDesktopDisplayMode()
+ * \sa SDL_GetCurrentDisplayMode()
+ * \sa SDL_GetClosestDisplayMode()
+ * \sa SDL_SetDisplayMode()
+ */
+typedef struct
+{
+    Uint32 format;              /**< pixel format */
+    int w;                      /**< width */
+    int h;                      /**< height */
+    int refresh_rate;           /**< refresh rate (or zero for unspecified) */
+} SDL_DisplayMode;
+
+/**
+ * \typedef SDL_WindowID
+ *
+ * \brief The type used to identify a window
+ *
+ * \sa SDL_CreateWindow()
+ * \sa SDL_CreateWindowFrom()
+ * \sa SDL_DestroyWindow()
+ * \sa SDL_GetWindowData()
+ * \sa SDL_GetWindowFlags()
+ * \sa SDL_GetWindowGrab()
+ * \sa SDL_GetWindowPosition()
+ * \sa SDL_GetWindowSize()
+ * \sa SDL_GetWindowTitle()
+ * \sa SDL_HideWindow()
+ * \sa SDL_MaximizeWindow()
+ * \sa SDL_MinimizeWindow()
+ * \sa SDL_RaiseWindow()
+ * \sa SDL_RestoreWindow()
+ * \sa SDL_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,
@@ -218,139 +259,423 @@
     SDL_GL_SWAP_CONTROL
 } SDL_GLattr;
 
-/* flags for SDL_SetPalette() */
-#define SDL_LOGPAL 0x01
-#define SDL_PHYSPAL 0x02
+/* These are the currently supported flags for the SDL_surface */
+#define SDL_SWSURFACE	0x00000000      /* Surface is in system memory */
+#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)
+ *
+ * \brief Get the number of video drivers compiled into SDL
+ *
+ * \sa SDL_GetVideoDriver()
+ */
+extern DECLSPEC int SDLCALL SDL_GetNumVideoDrivers (void);
+
+/**
+ * \fn const char *SDL_GetVideoDriver(int index)
+ *
+ * \brief Get the name of a built in video driver.
+ *
+ * \note The video drivers are presented in the order in which they are
+ * normally checked during initialization.
+ *
+ * \sa SDL_GetNumVideoDrivers()
  */
-extern DECLSPEC int SDLCALL SDL_GetNumVideoDrivers(void);
-extern DECLSPEC const char * SDLCALL SDL_GetVideoDriver(int index);
+extern DECLSPEC const char *SDLCALL SDL_GetVideoDriver (int index);
 
-/* 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.
- * You should normally use SDL_Init() or SDL_InitSubSystem().
+/**
+ * \fn int SDL_VideoInit(const char *driver_name, Uint32 flags)
+ *
+ * \brief Initialize the video subsystem, optionally specifying a video driver.
+ *
+ * \param driver_name Initialize a specific driver by name, or NULL for the default video driver.
+ * \param flags FIXME: Still needed?
+ *
+ * \return 0 on success, -1 on error
+ *
+ * This function initializes the video subsystem; setting up a connection
+ * to the window manager, etc, and determines the available display modes
+ * and pixel formats, but does not initialize a window or graphics mode.
+ *
+ * \sa SDL_VideoQuit()
+ */
+extern DECLSPEC int SDLCALL SDL_VideoInit (const char *driver_name,
+                                           Uint32 flags);
+
+/**
+ * \fn void SDL_VideoQuit(void)
+ *
+ * \brief Shuts down the video subsystem.
+ *
+ * This function closes all windows, and restores the original video mode.
  *
- * SDL_VideoInit() initializes the video subsystem -- sets up a connection
- * to the window manager, etc, and determines the current video mode and
- * pixel format, but does not initialize a window or graphics mode.
- * Note that event handling is activated by this routine.
+ * \sa SDL_VideoInit()
+ */
+extern DECLSPEC void SDLCALL SDL_VideoQuit (void);
+
+/**
+ * \fn const char *SDL_GetCurrentVideoDriver(void)
+ *
+ * \brief Returns the name of the currently initialized video driver.
+ *
+ * \return The name of the current video driver or NULL if no driver
+ *         has been initialized
+ *
+ * \sa SDL_GetNumVideoDrivers()
+ * \sa SDL_GetVideoDriver()
+ */
+extern DECLSPEC const char *SDLCALL SDL_GetCurrentVideoDriver (void);
+
+/**
+ * \fn const SDL_VideoInfo *SDL_GetVideoInfo(void)
+ *
+ * \brief Returns information about the currently initialized video driver.
  *
- * If you use both sound and video in your application, you need to call
- * SDL_Init() before opening the sound device, otherwise under Win32 DirectX,
- * you won't be able to set full-screen display modes.
+ * \return A read-only pointer to information about the video hardware,
+ *         or NULL if no video driver has been initialized.
+ */
+extern DECLSPEC const SDL_VideoInfo *SDLCALL SDL_GetVideoInfo (void);
+
+/**
+ * \fn int SDL_GetNumVideoDisplays(void)
+ *
+ * \brief Returns the number of available video displays.
+ *
+ * \sa SDL_SelectVideoDisplay()
  */
-extern DECLSPEC int SDLCALL SDL_VideoInit(const char *driver_name, Uint32 flags);
-extern DECLSPEC void SDLCALL SDL_VideoQuit(void);
+extern DECLSPEC int SDLCALL SDL_GetNumVideoDisplays (void);
 
-/* This function returns the name of the current video driver, or NULL
- * if no driver has been initialized.
+/**
+ * \fn int SDL_SelectVideoDisplay(int index)
+ *
+ * \brief Set the index of the currently selected display.
+ *
+ * \note You can query the currently selected display by passing an index of -1.
+ *
+ * \sa SDL_GetNumVideoDisplays()
  */
-extern DECLSPEC const char * SDLCALL SDL_GetCurrentVideoDriver(void);
+extern DECLSPEC int SDLCALL SDL_SelectVideoDisplay (int index);
 
-/*
- * This function returns a pointer to the current display surface.
- * If SDL is doing format conversion on the display surface, this
- * function returns the publicly visible surface, not the real video
- * surface.
+/**
+ * \fn int SDL_GetNumDisplayModes(void)
+ *
+ * \brief Returns the number of available display modes for the current display.
+ *
+ * \sa SDL_GetDisplayMode()
  */
-extern DECLSPEC SDL_Surface * SDLCALL SDL_GetVideoSurface(void);
+extern DECLSPEC int SDLCALL SDL_GetNumDisplayModes (void);
 
-/*
- * This function returns a read-only pointer to information about the
- * video hardware.  If this is called before SDL_SetVideoMode(), the 'vfmt'
- * member of the returned structure will contain the pixel format of the
- * "best" video mode.
+/**
+ * \fn const SDL_DisplayMode *SDL_GetDisplayMode(int index)
+ *
+ * \brief Retrieve information about a specific display mode.
+ *
+ * \note The display modes are sorted in this priority:
+ *       \li bits per pixel -> more colors to fewer colors
+ *       \li width -> largest to smallest
+ *       \li height -> largest to smallest
+ *       \li refresh rate -> highest to lowest
+ *
+ * \sa SDL_GetNumDisplayModes()
  */
-extern DECLSPEC const SDL_VideoInfo * SDLCALL SDL_GetVideoInfo(void);
+extern DECLSPEC const SDL_DisplayMode *SDLCALL SDL_GetDisplayMode (int index);
+
+/**
+ * \fn const SDL_DisplayMode *SDL_GetDesktopDisplayMode(void)
+ *
+ * \brief Retrieve information about the desktop display mode for the current display.
+ */
+extern DECLSPEC const SDL_DisplayMode *SDLCALL
+SDL_GetDesktopDisplayMode (void);
+
+/**
+ * \fn const SDL_DisplayMode *SDL_GetCurrentDisplayMode(void)
+ *
+ * \brief Retrieve information about the current display mode.
+ */
+extern DECLSPEC const SDL_DisplayMode *SDLCALL
+SDL_GetCurrentDisplayMode (void);
 
-/* 
- * Check to see if a particular video mode is supported.
- * It returns 0 if the requested mode is not supported under any bit depth,
- * 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
- * one used when setting the video mode, SDL_SetVideoMode() will succeed,
- * but will emulate the requested bits-per-pixel with a shadow surface.
+/**
+ * \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
  *
- * The arguments to SDL_VideoModeOK() are the same ones you would pass to
- * SDL_SetVideoMode()
+ * \return 0 on success, or -1 if setting the display mode failed.
  */
-extern DECLSPEC int SDLCALL SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags);
+extern DECLSPEC int SDLCALL SDL_SetDisplayMode (const SDL_DisplayMode * mode);
 
-/*
- * Return a pointer to an array of available screen dimensions for the
- * given format and video flags, sorted largest to smallest.  Returns 
- * NULL if there are no dimensions available for a particular format, 
- * or (SDL_Rect **)-1 if any dimension is okay for the given format.
+/**
+ * \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.
  *
- * If 'format' is NULL, the mode list will be for the format given 
- * by SDL_GetVideoInfo()->vfmt
+ * \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 SDL_Rect ** SDLCALL SDL_ListModes(SDL_PixelFormat *format, Uint32 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);
 
-/*
- * Set up a video mode with the specified width, height and bits-per-pixel.
+/**
+ * \fn const char *SDL_GetWindowTitle(SDL_WindowID windowID)
+ *
+ * \brief Get the title of the window, in UTF-8 format.
  *
- * If 'bpp' is 0, it is treated as the current display bits per pixel.
+ * \sa SDL_SetWindowTitle()
+ */
+extern DECLSPEC const char *SDLCALL SDL_GetWindowTitle (SDL_WindowID
+                                                        windowID);
+
+/**
+ * \fn void SDL_SetWindowIcon(SDL_Surface *icon)
  *
- * If SDL_ANYFORMAT is set in 'flags', the SDL library will try to set the
- * 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.
+ * \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.
  *
- * If SDL_HWSURFACE is set in 'flags', the video surface will be placed in
- * video memory, if possible, and you may have to call SDL_LockSurface()
- * in order to access the raw framebuffer.  Otherwise, the video surface
- * will be created in system memory.
+ * \sa SDL_GetWindowData()
+ */
+extern DECLSPEC void SDLCALL SDL_SetWindowData (SDL_WindowID windowID,
+                                                void *userdata);
+
+/**
+ * \fn void *SDL_GetWindowData(SDL_WindowID windowID)
  *
- * 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.
+ * \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.
  *
- * If SDL_HWPALETTE is set in 'flags', the SDL library will guarantee
- * 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
- * of the colors exactly the way they are requested, and you should look
- * at the video surface structure to determine the actual palette.
- * 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
- * under emulation in system memory, overriding the SDL_HWSURFACE flag.
+ * \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)
  *
- * If SDL_FULLSCREEN is set in 'flags', the SDL library will try to set
- * a fullscreen video mode.  The default is to create a windowed mode
- * if the current graphics system has a window manager.
- * If the SDL library is able to set a fullscreen video mode, this flag 
- * will be set in the surface that is returned.
+ * \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
  *
- * If SDL_DOUBLEBUF is set in 'flags', the SDL library will try to set up
- * 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 
- * memory while the monitor is refreshing.  It should only be used by 
- * applications that redraw the entire screen on every update.
+ * \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.
  *
- * If SDL_RESIZABLE is set in 'flags', the SDL library will allow the
- * window manager, if any, to resize the window at runtime.  When this
- * occurs, SDL will send a SDL_VIDEORESIZE event to you application,
- * and you must respond to the event by re-calling SDL_SetVideoMode()
- * with the requested size (or another size that suits the application).
+ * \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.
  *
- * If SDL_NOFRAME is set in 'flags', the SDL library will create a window
- * without any title bar or frame decoration.  Fullscreen video modes have
- * this flag set automatically.
+ * \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.
  *
- * This function returns the video framebuffer surface, or NULL if it fails.
+ * \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.
  *
- * If you rely on functionality provided by certain video flags, check the
- * flags of the returned surface to make sure that functionality is available.
- * SDL will fall back to reduced functionality if the exact flags you wanted
- * are not available.
+ * \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 SDL_Surface * SDLCALL SDL_SetVideoMode
-			(int width, int height, int bpp, Uint32 flags);
+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.
@@ -359,9 +684,9 @@
  * 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
@@ -373,7 +698,7 @@
  * 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.
@@ -383,7 +708,7 @@
  * 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
@@ -397,7 +722,9 @@
  * 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.
@@ -408,7 +735,8 @@
  * 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'
@@ -425,52 +753,35 @@
  * you desire, even if the window colormap has to be warped or run under
  * emulation.
  */
-extern DECLSPEC int SDLCALL SDL_SetColors(SDL_Surface *surface, 
-			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);
+extern DECLSPEC int SDLCALL SDL_SetColors (SDL_Surface * surface,
+                                           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,
-				   Uint8 r, Uint8 g, Uint8 b, Uint8 a);
+extern DECLSPEC Uint32 SDLCALL SDL_MapRGBA (SDL_PixelFormat * format,
+                                            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,
-				Uint8 *r, Uint8 *g, Uint8 *b);
+extern DECLSPEC void SDLCALL SDL_GetRGB (Uint32 pixel, SDL_PixelFormat * fmt,
+                                         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,
-				 Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a);
+extern DECLSPEC void SDLCALL SDL_GetRGBA (Uint32 pixel, SDL_PixelFormat * fmt,
+                                          Uint8 * r, Uint8 * g, Uint8 * b,
+                                          Uint8 * a);
 
 /*
  * Allocate and free an RGB surface (must be called after SDL_SetVideoMode)
@@ -507,13 +818,19 @@
  * 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
-			(Uint32 flags, int width, int height, int depth, 
-			Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
-extern DECLSPEC SDL_Surface * SDLCALL SDL_CreateRGBSurfaceFrom(void *pixels,
-			int width, int height, int depth, int pitch,
-			Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
-extern DECLSPEC void SDLCALL SDL_FreeSurface(SDL_Surface *surface);
+extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurface
+    (Uint32 flags, int width, int height, int depth,
+     Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
+extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceFrom (void *pixels,
+                                                               int width,
+                                                               int height,
+                                                               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.
@@ -533,8 +850,8 @@
  *
  * SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.
  */
-extern DECLSPEC int SDLCALL SDL_LockSurface(SDL_Surface *surface);
-extern DECLSPEC void SDLCALL SDL_UnlockSurface(SDL_Surface *surface);
+extern DECLSPEC int SDLCALL SDL_LockSurface (SDL_Surface * surface);
+extern DECLSPEC void SDLCALL SDL_UnlockSurface (SDL_Surface * surface);
 
 /*
  * Load a surface from a seekable SDL data source (memory or file.)
@@ -542,7 +859,8 @@
  * 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)
@@ -553,7 +871,7 @@
  * 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) \
@@ -569,7 +887,7 @@
  * 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
@@ -586,7 +904,8 @@
  *
  * 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.
@@ -600,14 +919,16 @@
  * 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 
@@ -621,8 +942,8 @@
  *
  * This function is used internally by SDL_DisplayFormat().
  */
-extern DECLSPEC SDL_Surface * SDLCALL SDL_ConvertSurface
-			(SDL_Surface *src, SDL_PixelFormat *fmt, Uint32 flags);
+extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurface
+    (SDL_Surface * src, SDL_PixelFormat * fmt, Uint32 flags);
 
 /*
  * This performs a fast blit from the source surface to the destination
@@ -699,14 +1020,14 @@
    rectangle validation and clipping before passing it to SDL_LowerBlit()
 */
 extern DECLSPEC int SDLCALL SDL_UpperBlit
-			(SDL_Surface *src, SDL_Rect *srcrect,
-			 SDL_Surface *dst, SDL_Rect *dstrect);
+    (SDL_Surface * src, SDL_Rect * srcrect,
+     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 *dst, SDL_Rect *dstrect);
+    (SDL_Surface * src, SDL_Rect * srcrect,
+     SDL_Surface * dst, SDL_Rect * dstrect);
 
 /*
  * This function performs a fast fill of the given rectangle with 'color'
@@ -718,7 +1039,7 @@
  * 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
@@ -731,7 +1052,8 @@
  *
  * 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
@@ -745,7 +1067,8 @@
  *
  * 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);
 
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -757,12 +1080,15 @@
    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,
-				Uint32 format, SDL_Surface *display);
+extern DECLSPEC SDL_Overlay *SDLCALL SDL_CreateYUVOverlay (int width,
+                                                           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 void SDLCALL SDL_UnlockYUVOverlay(SDL_Overlay *overlay);
+extern DECLSPEC int SDLCALL SDL_LockYUVOverlay (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
@@ -770,10 +1096,11 @@
    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);
 
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -786,17 +1113,17 @@
  * 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
@@ -807,80 +1134,27 @@
  * 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);
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-/* 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);
+extern DECLSPEC void SDLCALL SDL_GL_SwapBuffers (void);
 
 /* Not in public API at the moment - do not use! */
-extern DECLSPEC int SDLCALL SDL_SoftStretch(SDL_Surface *src, SDL_Rect *srcrect,
-                                    SDL_Surface *dst, SDL_Rect *dstrect);
-                    
+extern DECLSPEC int SDLCALL SDL_SoftStretch (SDL_Surface * src,
+                                             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: */