--- a/src/video/SDL_sysvideo.h	Sun May 21 17:27:13 2006 +0000
+++ b/src/video/SDL_sysvideo.h	Sun May 28 13:04:16 2006 +0000
@@ -38,151 +38,190 @@
 #endif /* SDL_VIDEO_OPENGL */
 
 /* The SDL video driver */
+
+/* Define the SDL window structure, corresponding to toplevel windows */
+typedef struct SDL_Window SDL_Window;
+
+struct SDL_Window
+{
+    Uint32 id;
+
+    char *title;
+    int x, y;
+    int w, h;
+    Uint32 flags;
+
+    SDL_Surface *surface;
+    SDL_Surface *shadow;
+    Uint16 *gamma;
+
+    void *userdata;
+    void *driverdata;
+};
+
+/* Define the SDL display structure
+   This corresponds to physical monitors attached to the system.
+ */
+typedef struct SDL_VideoDisplay
+{
+    int num_display_modes;
+    SDL_DisplayMode *display_modes;
+    SDL_DisplayMode desktop_mode;
+    SDL_DisplayMode current_mode;
+
+    int max_windows;
+    int num_windows;
+    SDL_Window *windows;
+
+    void *driverdata;
+} SDL_VideoDisplay;
+
 typedef struct SDL_VideoDevice SDL_VideoDevice;
 
 /* Define the SDL video driver structure */
 #define _THIS	SDL_VideoDevice *_this
-#ifndef _STATUS
-#define _STATUS	SDL_status *status
-#endif
-struct SDL_VideoDevice {
-	/* * * */
-	/* The name of this video driver */
-	const char *name;
 
-	/* * * */
-	/* Initialization/Query functions */
+struct SDL_VideoDevice
+{
+    /* * * */
+    /* The name of this video driver */
+    const char *name;
 
-	/* Initialize the native video subsystem, filling 'vformat' with the 
-	   "best" display pixel format, returning 0 or -1 if there's an error.
-	 */
-	int (*VideoInit)(_THIS, SDL_PixelFormat *vformat);
+    /* * * */
+    /* Initialization/Query functions */
 
-	/* List the available video modes for the given pixel format, sorted
-	   from largest to smallest.
-	 */
-	SDL_Rect **(*ListModes)(_THIS, SDL_PixelFormat *format, Uint32 flags);
+    /* Initialize the native video subsystem, filling in the list
+       of displays for this driver, returning 0 or -1 if there's an error.
+     */
+    int (*VideoInit) (_THIS);
 
-	/* Set the requested video mode, returning a surface which will be
-	   set to the SDL_VideoSurface.  The width and height will already
-	   be verified by ListModes(), and the video subsystem is free to
-	   set the mode to a supported bit depth different from the one
-	   specified -- the desired bpp will be emulated with a shadow
-	   surface if necessary.  If a new mode is returned, this function
-	   should take care of cleaning up the current mode.
-	 */
-	SDL_Surface *(*SetVideoMode)(_THIS, SDL_Surface *current,
-				int width, int height, int bpp, Uint32 flags);
+    /* * * */
+    /* Display functions
+     */
+    /* Setting the display mode is independent of creating windows,
+     * so when the display mode is changed, all existing windows
+     * should have their data updated accordingly, including the
+     * display surfaces associated with them.
+     */
+    int (*SetDisplayMode) (_THIS, const SDL_DisplayMode * mode);
 
-	/* Toggle the fullscreen mode */
-	int (*ToggleFullScreen)(_THIS, int on);
+    /* * * */
+    /* Window functions
+     */
+    int (*CreateWindow) (_THIS, SDL_Window * window);
+    int (*CreateWindowFrom) (_THIS, SDL_Window * window, void *data);
+    void (*SetWindowTitle) (_THIS, SDL_Window * window);
+    void (*SetWindowPosition) (_THIS, SDL_Window * window);
+    void (*SetWindowSize) (_THIS, SDL_Window * window);
+    void (*ShowWindow) (_THIS, SDL_Window * window);
+    void (*HideWindow) (_THIS, SDL_Window * window);
+    void (*RaiseWindow) (_THIS, SDL_Window * window);
+    void (*MaximizeWindow) (_THIS, SDL_Window * window);
+    void (*MinimizeWindow) (_THIS, SDL_Window * window);
+    void (*RestoreWindow) (_THIS, SDL_Window * window);
+    void (*SetWindowGrab) (_THIS, SDL_Window * window);
+    void (*DestroyWindow) (_THIS, SDL_Window * window);
 
-	/* This is called after the video mode has been set, to get the
-	   initial mouse state.  It should queue events as necessary to
-	   properly represent the current mouse focus and position.
-	 */
-	void (*UpdateMouse)(_THIS);
-
-	/* Create a YUV video surface (possibly overlay) of the given
-	   format.  The hardware should be able to perform at least 2x
-	   scaling on display.
-	 */
-	SDL_Overlay *(*CreateYUVOverlay)(_THIS, int width, int height,
-	                                 Uint32 format, SDL_Surface *display);
+    SDL_Surface *(*CreateWindowSurface) (_THIS, SDL_Window * window);
+    void (*UpdateWindowSurface) (_THIS, SDL_Window * window, int numrects,
+                                 SDL_Rect * rects);
+    void (*FlipWindowSurface) (_THIS, SDL_Window * window);
 
-        /* Sets the color entries { firstcolor .. (firstcolor+ncolors-1) }
-	   of the physical palette to those in 'colors'. If the device is
-	   using a software palette (SDL_HWPALETTE not set), then the
-	   changes are reflected in the logical palette of the screen
-	   as well.
-	   The return value is 1 if all entries could be set properly
-	   or 0 otherwise.
-	*/
-	int (*SetColors)(_THIS, int firstcolor, int ncolors,
-			 SDL_Color *colors);
+    /* Sets the color entries { firstcolor .. (firstcolor+ncolors-1) }
+       of the physical palette to those in 'colors'. If the device is
+       using a software palette (SDL_HWPALETTE not set), then the
+       changes are reflected in the logical palette of the screen
+       as well.
+       The return value is 1 if all entries could be set properly
+       or 0 otherwise.
+     */
+    int (*SetWindowColors) (_THIS, SDL_Window * window,
+                            int firstcolor, int ncolors, SDL_Color * colors);
 
-	/* This pointer should exist in the native video subsystem and should
-	   point to an appropriate update function for the current video mode
-	 */
-	void (*UpdateRects)(_THIS, int numrects, SDL_Rect *rects);
+    /* Get some platform dependent window information */
+      SDL_bool (*GetWindowWMInfo) (_THIS, SDL_Window * window,
+                                   SDL_SysWMinfo * info);
 
-	/* Reverse the effects VideoInit() -- called if VideoInit() fails
-	   or if the application is shutting down the video subsystem.
-	*/
-	void (*VideoQuit)(_THIS);
+    /* Create a YUV video surface (possibly overlay) of the given
+       format.  The hardware should be able to perform at least 2x
+       scaling on display.
+     */
+    SDL_Overlay *(*CreateYUVOverlay) (_THIS, int width, int height,
+                                      Uint32 format, SDL_Surface * display);
 
-	/* * * */
-	/* Hardware acceleration functions */
+    /* Reverse the effects VideoInit() -- called if VideoInit() fails
+       or if the application is shutting down the video subsystem.
+     */
+    void (*VideoQuit) (_THIS);
 
-	/* Information about the video hardware */
-	SDL_VideoInfo info;
+    /* * * */
+    /* Hardware acceleration functions */
 
-	/* The pixel format used when SDL_CreateRGBSurface creates SDL_HWSURFACEs with alpha */
-	SDL_PixelFormat* displayformatalphapixel;
+    /* Information about the video hardware */
+    SDL_VideoInfo info;
 
-	/* Allocates a surface in video memory */
-	int (*AllocHWSurface)(_THIS, SDL_Surface *surface);
+    /* The pixel format used when SDL_CreateRGBSurface creates SDL_HWSURFACEs with alpha */
+    SDL_PixelFormat *displayformatalphapixel;
 
-	/* Sets the hardware accelerated blit function, if any, based
-	   on the current flags of the surface (colorkey, alpha, etc.)
-	 */
-	int (*CheckHWBlit)(_THIS, SDL_Surface *src, SDL_Surface *dst);
+    /* Allocates a surface in video memory */
+    int (*AllocHWSurface) (_THIS, SDL_Surface * surface);
 
-	/* Fills a surface rectangle with the given color */
-	int (*FillHWRect)(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color);
+    /* Sets the hardware accelerated blit function, if any, based
+       on the current flags of the surface (colorkey, alpha, etc.)
+     */
+    int (*CheckHWBlit) (_THIS, SDL_Surface * src, SDL_Surface * dst);
 
-	/* Sets video mem colorkey and accelerated blit function */
-	int (*SetHWColorKey)(_THIS, SDL_Surface *surface, Uint32 key);
-
-	/* Sets per surface hardware alpha value */
-	int (*SetHWAlpha)(_THIS, SDL_Surface *surface, Uint8 value);
+    /* Fills a surface rectangle with the given color */
+    int (*FillHWRect) (_THIS, SDL_Surface * dst, SDL_Rect * rect,
+                       Uint32 color);
 
-	/* Returns a readable/writable surface */
-	int (*LockHWSurface)(_THIS, SDL_Surface *surface);
-	void (*UnlockHWSurface)(_THIS, SDL_Surface *surface);
+    /* Sets video mem colorkey and accelerated blit function */
+    int (*SetHWColorKey) (_THIS, SDL_Surface * surface, Uint32 key);
 
-	/* Performs hardware flipping */
-	int (*FlipHWSurface)(_THIS, SDL_Surface *surface);
+    /* Sets per surface hardware alpha value */
+    int (*SetHWAlpha) (_THIS, SDL_Surface * surface, Uint8 value);
 
-	/* Frees a previously allocated video surface */
-	void (*FreeHWSurface)(_THIS, SDL_Surface *surface);
+    /* Returns a readable/writable surface */
+    int (*LockHWSurface) (_THIS, SDL_Surface * surface);
+    void (*UnlockHWSurface) (_THIS, SDL_Surface * surface);
 
-	/* * * */
-	/* Gamma support */
+    /* Frees a previously allocated video surface */
+    void (*FreeHWSurface) (_THIS, SDL_Surface * surface);
 
-	Uint16 *gamma;
+    /* * * */
+    /* Gamma support */
 
-	/* Set the gamma correction directly (emulated with gamma ramps) */
-	int (*SetGamma)(_THIS, float red, float green, float blue);
+    /* Set the gamma correction directly (emulated with gamma ramps) */
+    int (*SetGamma) (_THIS, float red, float green, float blue);
 
-	/* Get the gamma correction directly (emulated with gamma ramps) */
-	int (*GetGamma)(_THIS, float *red, float *green, float *blue);
+    /* Get the gamma correction directly (emulated with gamma ramps) */
+    int (*GetGamma) (_THIS, float *red, float *green, float *blue);
 
-	/* Set the gamma ramp */
-	int (*SetGammaRamp)(_THIS, Uint16 *ramp);
+    /* Set the gamma ramp */
+    int (*SetGammaRamp) (_THIS, Uint16 * ramp);
 
-	/* Get the gamma ramp */
-	int (*GetGammaRamp)(_THIS, Uint16 *ramp);
+    /* Get the gamma ramp */
+    int (*GetGammaRamp) (_THIS, Uint16 * ramp);
 
-	/* * * */
-	/* OpenGL support */
+    /* * * */
+    /* OpenGL support */
 
-	/* Sets the dll to use for OpenGL and loads it */
-	int (*GL_LoadLibrary)(_THIS, const char *path);
+    /* Sets the dll to use for OpenGL and loads it */
+    int (*GL_LoadLibrary) (_THIS, const char *path);
 
-	/* Retrieves the address of a function in the gl library */
-	void* (*GL_GetProcAddress)(_THIS, const char *proc);
+    /* Retrieves the address of a function in the gl library */
+    void *(*GL_GetProcAddress) (_THIS, const char *proc);
 
-	/* Get attribute information from the windowing system. */
-	int (*GL_GetAttribute)(_THIS, SDL_GLattr attrib, int* value);
+    /* Get attribute information from the windowing system. */
+    int (*GL_GetAttribute) (_THIS, SDL_GLattr attrib, int *value);
 
-	/* Make the context associated with this driver current */
-	int (*GL_MakeCurrent)(_THIS);
+    /* Make the context associated with this driver current */
+    int (*GL_MakeCurrent) (_THIS);
 
-	/* Swap the current buffers in double buffer mode. */
-	void (*GL_SwapBuffers)(_THIS);
+    /* Swap the current buffers in double buffer mode. */
+    void (*GL_SwapBuffers) (_THIS);
 
-  	/* OpenGL functions for SDL_OPENGLBLIT */
+    /* OpenGL functions for glSDL */
 #if SDL_VIDEO_OPENGL
 #if !defined(__WIN32__)
 #define WINAPI
@@ -191,130 +230,106 @@
 #include "SDL_glfuncs.h"
 #undef SDL_PROC
 
-	/* Texture id */
-	GLuint texture;
+    /* Texture id */
+    GLuint texture;
+
+    int is_32bit;
 #endif
-	int is_32bit;
- 
-	/* * * */
-	/* Window manager functions */
 
-	/* Set the title and icon text */
-	void (*SetCaption)(_THIS, const char *title, const char *icon);
-
-	/* Set the window icon image */
-	void (*SetIcon)(_THIS, SDL_Surface *icon, Uint8 *mask);
+    /* * * */
+    /* Cursor manager functions */
 
-	/* Iconify the window.
-	   This function returns 1 if there is a window manager and the
-	   window was actually iconified, it returns 0 otherwise.
-	*/
-	int (*IconifyWindow)(_THIS);
+    /* Free a window manager cursor
+       This function can be NULL if CreateWMCursor is also NULL.
+     */
+    void (*FreeWMCursor) (_THIS, WMcursor * cursor);
 
-	/* Grab or ungrab keyboard and mouse input */
-	SDL_GrabMode (*GrabInput)(_THIS, SDL_GrabMode mode);
+    /* If not NULL, create a black/white window manager cursor */
+    WMcursor *(*CreateWMCursor) (_THIS,
+                                 Uint8 * data, Uint8 * mask, int w, int h,
+                                 int hot_x, int hot_y);
 
-	/* Get some platform dependent window information */
-	int (*GetWMInfo)(_THIS, SDL_SysWMinfo *info);
-
-	/* * * */
-	/* Cursor manager functions */
+    /* Show the specified cursor, or hide if cursor is NULL */
+    int (*ShowWMCursor) (_THIS, WMcursor * cursor);
 
-	/* Free a window manager cursor
-	   This function can be NULL if CreateWMCursor is also NULL.
-	 */
-	void (*FreeWMCursor)(_THIS, WMcursor *cursor);
+    /* Warp the window manager cursor to (x,y)
+       If NULL, a mouse motion event is posted internally.
+     */
+    void (*WarpWMCursor) (_THIS, Uint16 x, Uint16 y);
 
-	/* If not NULL, create a black/white window manager cursor */
-	WMcursor *(*CreateWMCursor)(_THIS,
-		Uint8 *data, Uint8 *mask, int w, int h, int hot_x, int hot_y);
-
-	/* Show the specified cursor, or hide if cursor is NULL */
-	int (*ShowWMCursor)(_THIS, WMcursor *cursor);
+    /* If not NULL, this is called when a mouse motion event occurs */
+    void (*MoveWMCursor) (_THIS, int x, int y);
 
-	/* Warp the window manager cursor to (x,y)
-	   If NULL, a mouse motion event is posted internally.
-	 */
-	void (*WarpWMCursor)(_THIS, Uint16 x, Uint16 y);
-
-	/* If not NULL, this is called when a mouse motion event occurs */
-	void (*MoveWMCursor)(_THIS, int x, int y);
+    /* Determine whether the mouse should be in relative mode or not.
+       This function is called when the input grab state or cursor
+       visibility state changes.
+       If the cursor is not visible, and the input is grabbed, the
+       driver can place the mouse in relative mode, which may result
+       in higher accuracy sampling of the pointer motion.
+     */
+    void (*CheckMouseMode) (_THIS);
 
-	/* Determine whether the mouse should be in relative mode or not.
-	   This function is called when the input grab state or cursor
-	   visibility state changes.
-	   If the cursor is not visible, and the input is grabbed, the
-	   driver can place the mouse in relative mode, which may result
-	   in higher accuracy sampling of the pointer motion.
-	*/
-	void (*CheckMouseMode)(_THIS);
+    /* * * */
+    /* Event manager functions */
+
+    /* Initialize keyboard mapping for this driver */
+    void (*InitOSKeymap) (_THIS);
 
-	/* * * */
-	/* Event manager functions */
-
-	/* Initialize keyboard mapping for this driver */
-	void (*InitOSKeymap)(_THIS);
-
-	/* Handle any queued OS events */
-	void (*PumpEvents)(_THIS);
+    /* Handle any queued OS events */
+    void (*PumpEvents) (_THIS);
 
-	/* * * */
-	/* Data common to all drivers */
-	SDL_Surface *screen;
-	SDL_Surface *shadow;
-	SDL_Surface *visible;
-        SDL_Palette *physpal;	/* physical palette, if != logical palette */
-        SDL_Color *gammacols;	/* gamma-corrected colours, or NULL */
-	char *wm_title;
-	char *wm_icon;
-	int offset_x;
-	int offset_y;
-	SDL_GrabMode input_grab;
+    /* * * */
+    /* Data common to all drivers */
+    int num_displays;
+    SDL_VideoDisplay *displays;
+    int current_display;
+    Uint32 next_window_id;
 
-	/* Driver information flags */
-	int handles_any_size;	/* Driver handles any size video mode */
+    /* Driver information flags */
 
-	/* * * */
-	/* Data used by the GL drivers */
-	struct {
-		int red_size;
-		int green_size;
-		int blue_size;
-		int alpha_size;
-		int depth_size;
-		int buffer_size;
-		int stencil_size;
-		int double_buffer;
-		int accum_red_size;
-		int accum_green_size;
-		int accum_blue_size;
-		int accum_alpha_size;
-		int stereo;
-		int multisamplebuffers;
-		int multisamplesamples;
-		int accelerated;
-		int swap_control;
-		int driver_loaded;
-		char driver_path[256];
-		void* dll_handle;
-	} gl_config;
+    /* * * */
+    /* Data used by the GL drivers */
+    struct
+    {
+        int red_size;
+        int green_size;
+        int blue_size;
+        int alpha_size;
+        int depth_size;
+        int buffer_size;
+        int stencil_size;
+        int double_buffer;
+        int accum_red_size;
+        int accum_green_size;
+        int accum_blue_size;
+        int accum_alpha_size;
+        int stereo;
+        int multisamplebuffers;
+        int multisamplesamples;
+        int accelerated;
+        int swap_control;
+        int driver_loaded;
+        char driver_path[256];
+        void *dll_handle;
+    } gl_config;
 
-	/* * * */
-	/* Data private to this driver */
-	struct SDL_PrivateVideoData *hidden;
-	struct SDL_PrivateGLData *gl_data;
+    /* * * */
+    /* Data private to this driver */
+    struct SDL_PrivateVideoData *hidden;
+    struct SDL_PrivateGLData *gl_data;
 
-	/* * * */
-	/* The function used to dispose of this structure */
-	void (*free)(_THIS);
+    /* * * */
+    /* The function used to dispose of this structure */
+    void (*free) (_THIS);
 };
 #undef _THIS
 
-typedef struct VideoBootStrap {
-	const char *name;
-	const char *desc;
-	int (*available)(void);
-	SDL_VideoDevice *(*create)(int devindex);
+typedef struct VideoBootStrap
+{
+    const char *name;
+    const char *desc;
+    int (*available) (void);
+    SDL_VideoDevice *(*create) (int devindex);
 } VideoBootStrap;
 
 #if SDL_VIDEO_DRIVER_QUARTZ
@@ -411,11 +426,18 @@
 extern VideoBootStrap glSDL_bootstrap;
 #endif
 
-/* This is the current video device */
-extern SDL_VideoDevice *current_video;
+#define SDL_CurrentDisplay	(_this->displays[_this->current_display])
+#define SDL_CurrentWindow	(SDL_CurrentDisplay.windows[0])
+#define SDL_VideoSurface	((_this && SDL_CurrentDisplay.num_windows > 0) ? SDL_CurrentWindow.surface : NULL)
+#define SDL_ShadowSurface	((_this && SDL_CurrentDisplay.num_windows > 0) ? SDL_CurrentWindow.shadow : NULL)
+#define SDL_PublicSurface	(SDL_ShadowSurface ? SDL_ShadowSurface : SDL_VideoSurface)
 
-#define SDL_VideoSurface	(current_video->screen)
-#define SDL_ShadowSurface	(current_video->shadow)
-#define SDL_PublicSurface	(current_video->visible)
+extern SDL_VideoDevice *SDL_GetVideoDevice ();
+extern void SDL_AddBasicVideoDisplay (const SDL_DisplayMode * desktop_mode);
+extern void SDL_AddVideoDisplay (SDL_VideoDisplay * display);
+extern void SDL_AddDisplayMode (int display, const SDL_DisplayMode * mode);
+extern SDL_Window *SDL_GetWindowFromSurface (SDL_Surface * surface);
 
 #endif /* _SDL_sysvideo_h */
+
+/* vi: set ts=4 sw=4 expandtab: */