--- a/src/video/SDL_sysvideo.h	Thu Jul 06 18:01:37 2006 +0000
+++ b/src/video/SDL_sysvideo.h	Mon Jul 10 21:04:37 2006 +0000
@@ -25,296 +25,296 @@
 #define _SDL_sysvideo_h
 
 #include "SDL_mouse.h"
-#define SDL_PROTOTYPES_ONLY
-#include "SDL_syswm.h"
-#undef SDL_PROTOTYPES_ONLY
-
-/* This file prototypes the video driver implementation.
-   This is designed to be easily converted to C++ in the future.
- */
-
-#if SDL_VIDEO_OPENGL
-#include "SDL_opengl.h"
-#endif /* SDL_VIDEO_OPENGL */
 
 /* The SDL video driver */
+
+typedef struct SDL_Window SDL_Window;
+typedef struct SDL_Texture SDL_Texture;
+typedef struct SDL_Renderer SDL_Renderer;
+typedef struct SDL_RenderDriver SDL_RenderDriver;
+typedef struct SDL_VideoDisplay SDL_VideoDisplay;
 typedef struct SDL_VideoDevice SDL_VideoDevice;
 
+/* Define the SDL texture structure */
+struct SDL_Texture
+{
+    Uint32 id;
+
+    Uint32 format;      /**< The pixel format of the texture */
+    int access;         /**< SDL_TextureAccess */
+    int w;              /**< The width of the texture */
+    int h;              /**< The height of the texture */
+
+    SDL_Renderer *renderer;
+
+    void *driverdata;   /**< Driver specific texture representation */
+
+    SDL_Texture *next;
+};
+
+/* Define the SDL renderer structure */
+struct SDL_Renderer
+{
+    int (*CreateTexture) (SDL_Renderer * renderer, SDL_Texture * texture);
+    int (*QueryTexturePixels) (SDL_Renderer * renderer, SDL_Texture * texture,
+                               void **pixels, int *pitch);
+    int (*SetTexturePalette) (SDL_Renderer * renderer, SDL_Texture * texture,
+                              const SDL_Color * colors, int firstcolor,
+                              int ncolors);
+    int (*GetTexturePalette) (SDL_Renderer * renderer, SDL_Texture * texture,
+                              SDL_Color * colors, int firstcolor,
+                              int ncolors);
+    int (*UpdateTexture) (SDL_Renderer * renderer, SDL_Texture * texture,
+                          const SDL_Rect * rect, const void *pixels,
+                          int pitch);
+    int (*LockTexture) (SDL_Renderer * renderer, SDL_Texture * texture,
+                        const SDL_Rect * rect, int markDirty, void **pixels,
+                        int *pitch);
+    void (*UnlockTexture) (SDL_Renderer * renderer, SDL_Texture * texture);
+    void (*DirtyTexture) (SDL_Renderer * renderer, SDL_Texture * texture,
+                          int numrects, const SDL_Rect * rects);
+    void (*SelectRenderTexture) (SDL_Renderer * renderer,
+                                 SDL_Texture * texture);
+    int (*RenderFill) (SDL_Renderer * renderer, const SDL_Rect * rect,
+                       Uint32 color);
+    int (*RenderCopy) (SDL_Renderer * renderer, SDL_Texture * texture,
+                       const SDL_Rect * srcrect, const SDL_Rect * dstrect,
+                       int blendMode, int scaleMode);
+    int (*RenderReadPixels) (SDL_Renderer * renderer, const SDL_Rect * rect,
+                             void *pixels, int pitch);
+    int (*RenderWritePixels) (SDL_Renderer * renderer, const SDL_Rect * rect,
+                              const void *pixels, int pitch);
+    void (*RenderPresent) (SDL_Renderer * renderer);
+    void (*DestroyTexture) (SDL_Renderer * renderer, SDL_Texture * texture);
+
+    void (*DestroyRenderer) (SDL_Renderer * renderer);
+
+    /* The current renderer info */
+    SDL_RendererInfo info;
+
+    /* The window associated with the renderer */
+    SDL_WindowID window;
+
+    void *driverdata;
+};
+
+/* Define the SDL render driver structure */
+struct SDL_RenderDriver
+{
+    SDL_Renderer *(*CreateRenderer) (SDL_Window * window, Uint32 flags);
+
+    /* Info about the renderer capabilities */
+    SDL_RendererInfo info;
+};
+
+/* Define the SDL window structure, corresponding to toplevel windows */
+struct SDL_Window
+{
+    Uint32 id;
+
+    char *title;
+    int x, y;
+    int w, h;
+    Uint32 flags;
+
+    int display;
+    SDL_Renderer *renderer;
+
+    void *userdata;
+    void *driverdata;
+};
+#define FULLSCREEN_VISIBLE(W) \
+    (((W)->flags & SDL_WINDOW_FULLSCREEN) && \
+     ((W)->flags & SDL_WINDOW_SHOWN) && \
+     !((W)->flags & SDL_WINDOW_MINIMIZED))
+
+/* Define the SDL display structure
+   This corresponds to physical monitors attached to the system.
+ */
+struct SDL_VideoDisplay
+{
+    int max_display_modes;
+    int num_display_modes;
+    SDL_DisplayMode *display_modes;
+    SDL_DisplayMode desktop_mode;
+    SDL_DisplayMode current_mode;
+    SDL_DisplayMode desired_mode;
+    SDL_DisplayMode *fullscreen_mode;
+    SDL_Palette *palette;
+
+    Uint16 *gamma;
+    Uint16 *saved_gamma;        /* (just offset into gamma) */
+
+    int num_render_drivers;
+    SDL_RenderDriver *render_drivers;
+
+    int num_windows;
+    SDL_Window *windows;
+
+    SDL_Renderer *current_renderer;
+
+    /* The hash list of textures */
+    SDL_Texture *textures[64];
+
+    SDL_VideoDevice *device;
+
+    void *driverdata;
+};
+
 /* 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 */
-
-	/* 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);
+struct SDL_VideoDevice
+{
+    /* * * */
+    /* The name of this video driver */
+    const char *name;
 
-	/* List the available video modes for the given pixel format, sorted
-	   from largest to smallest.
-	 */
-	SDL_Rect **(*ListModes)(_THIS, SDL_PixelFormat *format, Uint32 flags);
+    /* * * */
+    /* Initialization/Query functions */
 
-	/* 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);
+    /* 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);
 
-	/* Toggle the fullscreen mode */
-	int (*ToggleFullScreen)(_THIS, int on);
+    /* * * */
+    /* Display functions
+     */
 
-	/* 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);
+    /* Get a list of the available display modes.
+     * e.g.  SDL_AddDisplayMode(_this->current_display, mode)
+     */
+    void (*GetDisplayModes) (_THIS);
 
-        /* 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);
+    /* 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, SDL_DisplayMode * mode);
 
-	/* 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);
+    /* Set the color entries of the display palette */
+    int (*SetDisplayPalette) (_THIS, SDL_Palette * palette);
+
+    /* Get the color entries of the display palette */
+    int (*GetDisplayPalette) (_THIS, SDL_Palette * palette);
 
-	/* Reverse the effects VideoInit() -- called if VideoInit() fails
-	   or if the application is shutting down the video subsystem.
-	*/
-	void (*VideoQuit)(_THIS);
-
-	/* * * */
-	/* Hardware acceleration functions */
-
-	/* Information about the video hardware */
-	SDL_VideoInfo info;
-
-	/* The pixel format used when SDL_CreateRGBSurface creates SDL_HWSURFACEs with alpha */
-	SDL_PixelFormat* displayformatalphapixel;
-	
-	/* Allocates a surface in video memory */
-	int (*AllocHWSurface)(_THIS, SDL_Surface *surface);
+    /* Set the gamma ramp */
+    int (*SetDisplayGammaRamp) (_THIS, Uint16 * ramp);
 
-	/* 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);
-
-	/* Fills a surface rectangle with the given color */
-	int (*FillHWRect)(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color);
-
-	/* 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);
-
-	/* Returns a readable/writable surface */
-	int (*LockHWSurface)(_THIS, SDL_Surface *surface);
-	void (*UnlockHWSurface)(_THIS, SDL_Surface *surface);
+    /* Get the gamma ramp */
+    int (*GetDisplayGammaRamp) (_THIS, Uint16 * ramp);
 
-	/* Performs hardware flipping */
-	int (*FlipHWSurface)(_THIS, SDL_Surface *surface);
-
-	/* Frees a previously allocated video surface */
-	void (*FreeHWSurface)(_THIS, SDL_Surface *surface);
-
-	/* * * */
-	/* Gamma support */
-
-	Uint16 *gamma;
-
-	/* 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);
+    /* * * */
+    /* Window functions
+     */
+    int (*CreateWindow) (_THIS, SDL_Window * window);
+    int (*CreateWindowFrom) (_THIS, SDL_Window * window, const 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);
 
-	/* Set the gamma ramp */
-	int (*SetGammaRamp)(_THIS, Uint16 *ramp);
-
-	/* Get the gamma ramp */
-	int (*GetGammaRamp)(_THIS, Uint16 *ramp);
-
-	/* * * */
-	/* OpenGL support */
+    /* Get some platform dependent window information */
+      SDL_bool(*GetWindowWMInfo) (_THIS, SDL_Window * window,
+                                  struct SDL_SysWMinfo * info);
 
-	/* 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);
+    /* Reverse the effects VideoInit() -- called if VideoInit() fails
+       or if the application is shutting down the video subsystem.
+     */
+    void (*VideoQuit) (_THIS);
 
-	/* Get attribute information from the windowing system. */
-	int (*GL_GetAttribute)(_THIS, SDL_GLattr attrib, int* value);
+    /* * * */
+    /* OpenGL support */
 
-	/* Make the context associated with this driver current */
-	int (*GL_MakeCurrent)(_THIS);
+    /* Sets the dll to use for OpenGL and loads it */
+    int (*GL_LoadLibrary) (_THIS, const char *path);
 
-	/* Swap the current buffers in double buffer mode. */
-	void (*GL_SwapBuffers)(_THIS);
+    /* Retrieves the address of a function in the gl library */
+    void *(*GL_GetProcAddress) (_THIS, const char *proc);
 
-  	/* OpenGL functions for SDL_OPENGLBLIT */
-#if SDL_VIDEO_OPENGL
-#if !defined(__WIN32__)
-#define WINAPI
-#endif
-#define SDL_PROC(ret,func,params) ret (WINAPI *func) params;
-#include "SDL_glfuncs.h"
-#undef SDL_PROC
+    /* Get attribute information from the windowing system. */
+    int (*GL_GetAttribute) (_THIS, SDL_GLattr attrib, int *value);
 
-	/* Texture id */
-	GLuint texture;
-#endif
-	int is_32bit;
- 
-	/* * * */
-	/* Window manager functions */
+    /* Make the context associated with this driver current */
+    int (*GL_MakeCurrent) (_THIS);
 
-	/* 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);
+    /* Swap the current buffers in double buffer mode. */
+    void (*GL_SwapBuffers) (_THIS);
 
-	/* 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);
+    /* 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);
 
-	/* Grab or ungrab keyboard and mouse input */
-	SDL_GrabMode (*GrabInput)(_THIS, SDL_GrabMode mode);
-
-	/* Get some platform dependent window information */
-	int (*GetWMInfo)(_THIS, SDL_SysWMinfo *info);
-
-	/* * * */
-	/* Cursor manager functions */
+    /* * * */
+    /* Event manager functions */
 
-	/* Free a window manager cursor
-	   This function can be NULL if CreateWMCursor is also NULL.
-	 */
-	void (*FreeWMCursor)(_THIS, WMcursor *cursor);
-
-	/* 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);
+    /* Handle any queued OS events */
+    void (*PumpEvents) (_THIS);
 
-	/* Show the specified cursor, or hide if cursor is NULL */
-	int (*ShowWMCursor)(_THIS, WMcursor *cursor);
+    /* * * */
+    /* Data common to all drivers */
+    int num_displays;
+    SDL_VideoDisplay *displays;
+    int current_display;
+    Uint32 next_object_id;
 
-	/* 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);
+    /* Driver information flags */
 
-	/* 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);
-
-	/* 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;
-
-	/* Driver information flags */
-	int handles_any_size;	/* Driver handles any size video mode */
+    /* * * */
+    /* 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 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 */
+    void *driverdata;
+    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
@@ -359,11 +359,8 @@
 #if SDL_VIDEO_DRIVER_GAPI
 extern VideoBootStrap GAPI_bootstrap;
 #endif
-#if SDL_VIDEO_DRIVER_WINDIB
-extern VideoBootStrap WINDIB_bootstrap;
-#endif
-#if SDL_VIDEO_DRIVER_DDRAW
-extern VideoBootStrap DIRECTX_bootstrap;
+#if SDL_VIDEO_DRIVER_WIN32
+extern VideoBootStrap WIN32_bootstrap;
 #endif
 #if SDL_VIDEO_DRIVER_BWINDOW
 extern VideoBootStrap BWINDOW_bootstrap;
@@ -407,12 +404,29 @@
 #if SDL_VIDEO_DRIVER_DUMMY
 extern VideoBootStrap DUMMY_bootstrap;
 #endif
+#if SDL_VIDEO_DRIVER_GLSDL
+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_VideoSurface	(current_video->screen)
-#define SDL_ShadowSurface	(current_video->shadow)
-#define SDL_PublicSurface	(current_video->visible)
+extern SDL_VideoDevice *SDL_GetVideoDevice();
+extern int SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode);
+extern int SDL_AddVideoDisplay(const SDL_VideoDisplay * display);
+extern SDL_bool SDL_AddDisplayMode(int displayIndex,
+                                   const SDL_DisplayMode * mode);
+extern void SDL_AddRenderDriver(int displayIndex,
+                                const SDL_RenderDriver * driver);
+
+extern SDL_Window *SDL_GetWindowFromID(SDL_WindowID windowID);
+extern SDL_VideoDisplay *SDL_GetDisplayFromWindow(SDL_Window * window);
+
+extern void SDL_OnWindowShown(SDL_Window * window);
+extern void SDL_OnWindowHidden(SDL_Window * window);
+extern void SDL_OnWindowFocusGained(SDL_Window * window);
+extern void SDL_OnWindowFocusLost(SDL_Window * window);
+extern SDL_WindowID SDL_GetFocusWindow(void);
 
 #endif /* _SDL_sysvideo_h */
+
+/* vi: set ts=4 sw=4 expandtab: */