--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/SDL_sysvideo.h	Thu Apr 26 16:45:43 2001 +0000
@@ -0,0 +1,382 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+*/
+
+#ifdef SAVE_RCSID
+static char rcsid =
+ "@(#) $Id$";
+#endif
+
+#ifndef _SDL_sysvideo_h
+#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.
+ */
+
+/* OpenGL is pretty much available on all Windows systems */
+#ifdef WIN32
+#ifndef _WIN32_WCE
+#define HAVE_OPENGL
+#endif
+#include <windows.h>
+#endif
+
+#ifdef HAVE_OPENGL
+#ifdef MACOSX
+#include <OpenGL/gl.h>  /* OpenGL.framework */
+#else
+#include <GL/gl.h>
+#endif /* MACOSX */
+#endif /* HAVE_OPENGL */
+
+/* The SDL video driver */
+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 audio 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);
+
+	/* List the available video modes for the given pixel format, sorted
+	   from largest to smallest.
+	 */
+	SDL_Rect **(*ListModes)(_THIS, SDL_PixelFormat *format, Uint32 flags);
+
+	/* 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);
+
+	/* Toggle the fullscreen mode */
+	int (*ToggleFullScreen)(_THIS, int on);
+
+	/* 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);
+
+        /* 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);
+
+	/* 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);
+
+	/* 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;
+
+	/* Allocates a surface in video memory */
+	int (*AllocHWSurface)(_THIS, SDL_Surface *surface);
+
+	/* 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);
+
+	/* 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);
+
+	/* Set the gamma ramp */
+	int (*SetGammaRamp)(_THIS, Uint16 *ramp);
+
+	/* Get the gamma ramp */
+	int (*GetGammaRamp)(_THIS, Uint16 *ramp);
+
+	/* * * */
+	/* OpenGL support */
+
+	/* 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);
+
+        /* 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);
+
+	/* Swap the current buffers in double buffer mode. */
+	void (*GL_SwapBuffers)(_THIS);
+
+  	/* OpenGL functions for SDL_OPENGLBLIT */
+#ifdef HAVE_OPENGL
+#ifndef WIN32
+#define WINAPI
+#endif
+#define SDL_PROC(ret,func,params) ret (WINAPI *func) params;
+#include "SDL_glfuncs.h"
+#undef SDL_PROC
+
+	/* Texture id */
+	GLuint texture;
+#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);
+
+	/* 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);
+
+	/* 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 */
+
+	/* 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);
+
+	/* Show the specified cursor, or hide if cursor is NULL */
+	int (*ShowWMCursor)(_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, 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);
+
+	/* * * */
+	/* 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 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;
+
+	/* * * */
+	/* 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);
+} VideoBootStrap;
+
+#ifdef ENABLE_X11
+extern VideoBootStrap X11_bootstrap;
+#endif
+#ifdef ENABLE_DGA
+extern VideoBootStrap DGA_bootstrap;
+#endif
+#ifdef ENABLE_FBCON
+extern VideoBootStrap FBCON_bootstrap;
+#endif
+#ifdef ENABLE_PS2GS
+extern VideoBootStrap PS2GS_bootstrap;
+#endif
+#ifdef ENABLE_GGI
+extern VideoBootStrap GGI_bootstrap;
+#endif
+#ifdef ENABLE_SVGALIB
+extern VideoBootStrap SVGALIB_bootstrap;
+#endif
+#ifdef ENABLE_AALIB
+extern VideoBootStrap AALIB_bootstrap;
+#endif
+#ifdef ENABLE_WINDIB
+extern VideoBootStrap WINDIB_bootstrap;
+#endif
+#ifdef ENABLE_DIRECTX
+extern VideoBootStrap DIRECTX_bootstrap;
+#endif
+#ifdef ENABLE_BWINDOW
+extern VideoBootStrap BWINDOW_bootstrap;
+#endif
+/* MacOS X gets the proper defines from configure */
+#if defined(macintosh) && !defined(MACOSX)
+#define ENABLE_TOOLBOX
+#if !TARGET_API_MAC_CARBON
+#define ENABLE_DRAWSPROCKET
+#endif
+#endif
+#ifdef ENABLE_TOOLBOX
+extern VideoBootStrap TOOLBOX_bootstrap;
+#endif
+#ifdef ENABLE_DRAWSPROCKET
+extern VideoBootStrap DSp_bootstrap;
+#endif
+#ifdef ENABLE_CYBERGRAPHICS
+extern VideoBootStrap CGX_bootstrap;
+#endif
+
+/* This is the current video device */
+extern SDL_VideoDevice *current_video;
+
+#define SDL_VideoSurface	(current_video->screen)
+#define SDL_ShadowSurface	(current_video->shadow)
+#define SDL_PublicSurface	(current_video->visible)
+
+#endif /* _SDL_sysvideo_h */