Mercurial > sdl-ios-xcode

comparison src/video/SDL_sysvideo.h @ 1895:c121d94672cb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
SDL 1.2 is moving to a branch, and SDL 1.3 is becoming the head.
author Sam Lantinga <slouken@libsdl.org>
date Mon, 10 Jul 2006 21:04:37 +0000
parents eacc5bc01d1c
children 06c27a737b7a
comparison
equal deleted inserted replaced
1894:c69cee13dd76 1895:c121d94672cb
23 23
24 #ifndef _SDL_sysvideo_h 24 #ifndef _SDL_sysvideo_h
25 #define _SDL_sysvideo_h 25 #define _SDL_sysvideo_h
26 26
27 #include "SDL_mouse.h" 27 #include "SDL_mouse.h"
28 #define SDL_PROTOTYPES_ONLY 28
29 #include "SDL_syswm.h" 29 /* The SDL video driver */
30 #undef SDL_PROTOTYPES_ONLY 30
31 31 typedef struct SDL_Window SDL_Window;
32 /* This file prototypes the video driver implementation. 32 typedef struct SDL_Texture SDL_Texture;
33 This is designed to be easily converted to C++ in the future. 33 typedef struct SDL_Renderer SDL_Renderer;
34 typedef struct SDL_RenderDriver SDL_RenderDriver;
35 typedef struct SDL_VideoDisplay SDL_VideoDisplay;
36 typedef struct SDL_VideoDevice SDL_VideoDevice;
37
38 /* Define the SDL texture structure */
39 struct SDL_Texture
40 {
41 Uint32 id;
42
43 Uint32 format; /**< The pixel format of the texture */
44 int access; /**< SDL_TextureAccess */
45 int w; /**< The width of the texture */
46 int h; /**< The height of the texture */
47
48 SDL_Renderer *renderer;
49
50 void *driverdata; /**< Driver specific texture representation */
51
52 SDL_Texture *next;
53 };
54
55 /* Define the SDL renderer structure */
56 struct SDL_Renderer
57 {
58 int (*CreateTexture) (SDL_Renderer * renderer, SDL_Texture * texture);
59 int (*QueryTexturePixels) (SDL_Renderer * renderer, SDL_Texture * texture,
60 void **pixels, int *pitch);
61 int (*SetTexturePalette) (SDL_Renderer * renderer, SDL_Texture * texture,
62 const SDL_Color * colors, int firstcolor,
63 int ncolors);
64 int (*GetTexturePalette) (SDL_Renderer * renderer, SDL_Texture * texture,
65 SDL_Color * colors, int firstcolor,
66 int ncolors);
67 int (*UpdateTexture) (SDL_Renderer * renderer, SDL_Texture * texture,
68 const SDL_Rect * rect, const void *pixels,
69 int pitch);
70 int (*LockTexture) (SDL_Renderer * renderer, SDL_Texture * texture,
71 const SDL_Rect * rect, int markDirty, void **pixels,
72 int *pitch);
73 void (*UnlockTexture) (SDL_Renderer * renderer, SDL_Texture * texture);
74 void (*DirtyTexture) (SDL_Renderer * renderer, SDL_Texture * texture,
75 int numrects, const SDL_Rect * rects);
76 void (*SelectRenderTexture) (SDL_Renderer * renderer,
77 SDL_Texture * texture);
78 int (*RenderFill) (SDL_Renderer * renderer, const SDL_Rect * rect,
79 Uint32 color);
80 int (*RenderCopy) (SDL_Renderer * renderer, SDL_Texture * texture,
81 const SDL_Rect * srcrect, const SDL_Rect * dstrect,
82 int blendMode, int scaleMode);
83 int (*RenderReadPixels) (SDL_Renderer * renderer, const SDL_Rect * rect,
84 void *pixels, int pitch);
85 int (*RenderWritePixels) (SDL_Renderer * renderer, const SDL_Rect * rect,
86 const void *pixels, int pitch);
87 void (*RenderPresent) (SDL_Renderer * renderer);
88 void (*DestroyTexture) (SDL_Renderer * renderer, SDL_Texture * texture);
89
90 void (*DestroyRenderer) (SDL_Renderer * renderer);
91
92 /* The current renderer info */
93 SDL_RendererInfo info;
94
95 /* The window associated with the renderer */
96 SDL_WindowID window;
97
98 void *driverdata;
99 };
100
101 /* Define the SDL render driver structure */
102 struct SDL_RenderDriver
103 {
104 SDL_Renderer *(*CreateRenderer) (SDL_Window * window, Uint32 flags);
105
106 /* Info about the renderer capabilities */
107 SDL_RendererInfo info;
108 };
109
110 /* Define the SDL window structure, corresponding to toplevel windows */
111 struct SDL_Window
112 {
113 Uint32 id;
114
115 char *title;
116 int x, y;
117 int w, h;
118 Uint32 flags;
119
120 int display;
121 SDL_Renderer *renderer;
122
123 void *userdata;
124 void *driverdata;
125 };
126 #define FULLSCREEN_VISIBLE(W) \
127 (((W)->flags & SDL_WINDOW_FULLSCREEN) && \
128 ((W)->flags & SDL_WINDOW_SHOWN) && \
129 !((W)->flags & SDL_WINDOW_MINIMIZED))
130
131 /* Define the SDL display structure
132 This corresponds to physical monitors attached to the system.
34 */ 133 */
35 134 struct SDL_VideoDisplay
36 #if SDL_VIDEO_OPENGL 135 {
37 #include "SDL_opengl.h" 136 int max_display_modes;
38 #endif /* SDL_VIDEO_OPENGL */ 137 int num_display_modes;
39 138 SDL_DisplayMode *display_modes;
40 /* The SDL video driver */ 139 SDL_DisplayMode desktop_mode;
41 typedef struct SDL_VideoDevice SDL_VideoDevice; 140 SDL_DisplayMode current_mode;
141 SDL_DisplayMode desired_mode;
142 SDL_DisplayMode *fullscreen_mode;
143 SDL_Palette *palette;
144
145 Uint16 *gamma;
146 Uint16 *saved_gamma; /* (just offset into gamma) */
147
148 int num_render_drivers;
149 SDL_RenderDriver *render_drivers;
150
151 int num_windows;
152 SDL_Window *windows;
153
154 SDL_Renderer *current_renderer;
155
156 /* The hash list of textures */
157 SDL_Texture *textures[64];
158
159 SDL_VideoDevice *device;
160
161 void *driverdata;
162 };
42 163
43 /* Define the SDL video driver structure */ 164 /* Define the SDL video driver structure */
44 #define _THIS SDL_VideoDevice *_this 165 #define _THIS SDL_VideoDevice *_this
45 #ifndef _STATUS 166
46 #define _STATUS SDL_status *status 167 struct SDL_VideoDevice
47 #endif 168 {
48 struct SDL_VideoDevice { 169 /* * * */
49 /* * * */ 170 /* The name of this video driver */
50 /* The name of this video driver */ 171 const char *name;
51 const char *name; 172
52 173 /* * * */
53 /* * * */ 174 /* Initialization/Query functions */
54 /* Initialization/Query functions */ 175
55 176 /* Initialize the native video subsystem, filling in the list
56 /* Initialize the native video subsystem, filling 'vformat' with the 177 of displays for this driver, returning 0 or -1 if there's an error.
57 "best" display pixel format, returning 0 or -1 if there's an error. 178 */
58 */ 179 int (*VideoInit) (_THIS);
59 int (*VideoInit)(_THIS, SDL_PixelFormat *vformat); 180
60 181 /* * * */
61 /* List the available video modes for the given pixel format, sorted 182 /* Display functions
62 from largest to smallest. 183 */
63 */ 184
64 SDL_Rect **(*ListModes)(_THIS, SDL_PixelFormat *format, Uint32 flags); 185 /* Get a list of the available display modes.
65 186 * e.g. SDL_AddDisplayMode(_this->current_display, mode)
66 /* Set the requested video mode, returning a surface which will be 187 */
67 set to the SDL_VideoSurface. The width and height will already 188 void (*GetDisplayModes) (_THIS);
68 be verified by ListModes(), and the video subsystem is free to 189
69 set the mode to a supported bit depth different from the one 190 /* Setting the display mode is independent of creating windows,
70 specified -- the desired bpp will be emulated with a shadow 191 * so when the display mode is changed, all existing windows
71 surface if necessary. If a new mode is returned, this function 192 * should have their data updated accordingly, including the
72 should take care of cleaning up the current mode. 193 * display surfaces associated with them.
73 */ 194 */
74 SDL_Surface *(*SetVideoMode)(_THIS, SDL_Surface *current, 195 int (*SetDisplayMode) (_THIS, SDL_DisplayMode * mode);
75 int width, int height, int bpp, Uint32 flags); 196
76 197 /* Set the color entries of the display palette */
77 /* Toggle the fullscreen mode */ 198 int (*SetDisplayPalette) (_THIS, SDL_Palette * palette);
78 int (*ToggleFullScreen)(_THIS, int on); 199
79 200 /* Get the color entries of the display palette */
80 /* This is called after the video mode has been set, to get the 201 int (*GetDisplayPalette) (_THIS, SDL_Palette * palette);
81 initial mouse state. It should queue events as necessary to 202
82 properly represent the current mouse focus and position. 203 /* Set the gamma ramp */
83 */ 204 int (*SetDisplayGammaRamp) (_THIS, Uint16 * ramp);
84 void (*UpdateMouse)(_THIS); 205
85 206 /* Get the gamma ramp */
86 /* Create a YUV video surface (possibly overlay) of the given 207 int (*GetDisplayGammaRamp) (_THIS, Uint16 * ramp);
87 format. The hardware should be able to perform at least 2x 208
88 scaling on display. 209 /* * * */
89 */ 210 /* Window functions
90 SDL_Overlay *(*CreateYUVOverlay)(_THIS, int width, int height, 211 */
91 Uint32 format, SDL_Surface *display); 212 int (*CreateWindow) (_THIS, SDL_Window * window);
92 213 int (*CreateWindowFrom) (_THIS, SDL_Window * window, const void *data);
93 /* Sets the color entries { firstcolor .. (firstcolor+ncolors-1) } 214 void (*SetWindowTitle) (_THIS, SDL_Window * window);
94 of the physical palette to those in 'colors'. If the device is 215 void (*SetWindowPosition) (_THIS, SDL_Window * window);
95 using a software palette (SDL_HWPALETTE not set), then the 216 void (*SetWindowSize) (_THIS, SDL_Window * window);
96 changes are reflected in the logical palette of the screen 217 void (*ShowWindow) (_THIS, SDL_Window * window);
97 as well. 218 void (*HideWindow) (_THIS, SDL_Window * window);
98 The return value is 1 if all entries could be set properly 219 void (*RaiseWindow) (_THIS, SDL_Window * window);
99 or 0 otherwise. 220 void (*MaximizeWindow) (_THIS, SDL_Window * window);
100 */ 221 void (*MinimizeWindow) (_THIS, SDL_Window * window);
101 int (*SetColors)(_THIS, int firstcolor, int ncolors, 222 void (*RestoreWindow) (_THIS, SDL_Window * window);
102 SDL_Color *colors); 223 void (*SetWindowGrab) (_THIS, SDL_Window * window);
103 224 void (*DestroyWindow) (_THIS, SDL_Window * window);
104 /* This pointer should exist in the native video subsystem and should 225
105 point to an appropriate update function for the current video mode 226 /* Get some platform dependent window information */
106 */ 227 SDL_bool(*GetWindowWMInfo) (_THIS, SDL_Window * window,
107 void (*UpdateRects)(_THIS, int numrects, SDL_Rect *rects); 228 struct SDL_SysWMinfo * info);
108 229
109 /* Reverse the effects VideoInit() -- called if VideoInit() fails 230 /* Reverse the effects VideoInit() -- called if VideoInit() fails
110 or if the application is shutting down the video subsystem. 231 or if the application is shutting down the video subsystem.
111 */ 232 */
112 void (*VideoQuit)(_THIS); 233 void (*VideoQuit) (_THIS);
113 234
114 /* * * */ 235 /* * * */
115 /* Hardware acceleration functions */ 236 /* OpenGL support */
116 237
117 /* Information about the video hardware */ 238 /* Sets the dll to use for OpenGL and loads it */
118 SDL_VideoInfo info; 239 int (*GL_LoadLibrary) (_THIS, const char *path);
119 240
120 /* The pixel format used when SDL_CreateRGBSurface creates SDL_HWSURFACEs with alpha */ 241 /* Retrieves the address of a function in the gl library */
121 SDL_PixelFormat* displayformatalphapixel; 242 void *(*GL_GetProcAddress) (_THIS, const char *proc);
122 243
123 /* Allocates a surface in video memory */ 244 /* Get attribute information from the windowing system. */
124 int (*AllocHWSurface)(_THIS, SDL_Surface *surface); 245 int (*GL_GetAttribute) (_THIS, SDL_GLattr attrib, int *value);
125 246
126 /* Sets the hardware accelerated blit function, if any, based 247 /* Make the context associated with this driver current */
127 on the current flags of the surface (colorkey, alpha, etc.) 248 int (*GL_MakeCurrent) (_THIS);
128 */ 249
129 int (*CheckHWBlit)(_THIS, SDL_Surface *src, SDL_Surface *dst); 250 /* Swap the current buffers in double buffer mode. */
130 251 void (*GL_SwapBuffers) (_THIS);
131 /* Fills a surface rectangle with the given color */ 252
132 int (*FillHWRect)(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color); 253 /* Determine whether the mouse should be in relative mode or not.
133 254 This function is called when the input grab state or cursor
134 /* Sets video mem colorkey and accelerated blit function */ 255 visibility state changes.
135 int (*SetHWColorKey)(_THIS, SDL_Surface *surface, Uint32 key); 256 If the cursor is not visible, and the input is grabbed, the
136 257 driver can place the mouse in relative mode, which may result
137 /* Sets per surface hardware alpha value */ 258 in higher accuracy sampling of the pointer motion.
138 int (*SetHWAlpha)(_THIS, SDL_Surface *surface, Uint8 value); 259 */
139 260 void (*CheckMouseMode) (_THIS);
140 /* Returns a readable/writable surface */ 261
141 int (*LockHWSurface)(_THIS, SDL_Surface *surface); 262 /* * * */
142 void (*UnlockHWSurface)(_THIS, SDL_Surface *surface); 263 /* Event manager functions */
143 264
144 /* Performs hardware flipping */ 265 /* Handle any queued OS events */
145 int (*FlipHWSurface)(_THIS, SDL_Surface *surface); 266 void (*PumpEvents) (_THIS);
146 267
147 /* Frees a previously allocated video surface */ 268 /* * * */
148 void (*FreeHWSurface)(_THIS, SDL_Surface *surface); 269 /* Data common to all drivers */
149 270 int num_displays;
150 /* * * */ 271 SDL_VideoDisplay *displays;
151 /* Gamma support */ 272 int current_display;
152 273 Uint32 next_object_id;
153 Uint16 *gamma; 274
154 275 /* Driver information flags */
155 /* Set the gamma correction directly (emulated with gamma ramps) */ 276
156 int (*SetGamma)(_THIS, float red, float green, float blue); 277 /* * * */
157 278 /* Data used by the GL drivers */
158 /* Get the gamma correction directly (emulated with gamma ramps) */ 279 struct
159 int (*GetGamma)(_THIS, float *red, float *green, float *blue); 280 {
160 281 int red_size;
161 /* Set the gamma ramp */ 282 int green_size;
162 int (*SetGammaRamp)(_THIS, Uint16 *ramp); 283 int blue_size;
163 284 int alpha_size;
164 /* Get the gamma ramp */ 285 int depth_size;
165 int (*GetGammaRamp)(_THIS, Uint16 *ramp); 286 int buffer_size;
166 287 int stencil_size;
167 /* * * */ 288 int double_buffer;
168 /* OpenGL support */ 289 int accum_red_size;
169 290 int accum_green_size;
170 /* Sets the dll to use for OpenGL and loads it */ 291 int accum_blue_size;
171 int (*GL_LoadLibrary)(_THIS, const char *path); 292 int accum_alpha_size;
172 293 int stereo;
173 /* Retrieves the address of a function in the gl library */ 294 int multisamplebuffers;
174 void* (*GL_GetProcAddress)(_THIS, const char *proc); 295 int multisamplesamples;
175 296 int accelerated;
176 /* Get attribute information from the windowing system. */ 297 int driver_loaded;
177 int (*GL_GetAttribute)(_THIS, SDL_GLattr attrib, int* value); 298 char driver_path[256];
178 299 void *dll_handle;
179 /* Make the context associated with this driver current */ 300 } gl_config;
180 int (*GL_MakeCurrent)(_THIS); 301
181 302 /* * * */
182 /* Swap the current buffers in double buffer mode. */ 303 /* Data private to this driver */
183 void (*GL_SwapBuffers)(_THIS); 304 void *driverdata;
184 305 struct SDL_PrivateGLData *gl_data;
185 /* OpenGL functions for SDL_OPENGLBLIT */ 306
186 #if SDL_VIDEO_OPENGL 307 /* * * */
187 #if !defined(__WIN32__) 308 /* The function used to dispose of this structure */
188 #define WINAPI 309 void (*free) (_THIS);
189 #endif 310 };
190 #define SDL_PROC(ret,func,params) ret (WINAPI *func) params; 311
191 #include "SDL_glfuncs.h" 312 typedef struct VideoBootStrap
192 #undef SDL_PROC 313 {
193 314 const char *name;
194 /* Texture id */ 315 const char *desc;
195 GLuint texture; 316 int (*available) (void);
196 #endif 317 SDL_VideoDevice *(*create) (int devindex);
197 int is_32bit;
198
199 /* * * */
200 /* Window manager functions */
201
202 /* Set the title and icon text */
203 void (*SetCaption)(_THIS, const char *title, const char *icon);
204
205 /* Set the window icon image */
206 void (*SetIcon)(_THIS, SDL_Surface *icon, Uint8 *mask);
207
208 /* Iconify the window.
209 This function returns 1 if there is a window manager and the
210 window was actually iconified, it returns 0 otherwise.
211 */
212 int (*IconifyWindow)(_THIS);
213
214 /* Grab or ungrab keyboard and mouse input */
215 SDL_GrabMode (*GrabInput)(_THIS, SDL_GrabMode mode);
216
217 /* Get some platform dependent window information */
218 int (*GetWMInfo)(_THIS, SDL_SysWMinfo *info);
219
220 /* * * */
221 /* Cursor manager functions */
222
223 /* Free a window manager cursor
224 This function can be NULL if CreateWMCursor is also NULL.
225 */
226 void (*FreeWMCursor)(_THIS, WMcursor *cursor);
227
228 /* If not NULL, create a black/white window manager cursor */
229 WMcursor *(*CreateWMCursor)(_THIS,
230 Uint8 *data, Uint8 *mask, int w, int h, int hot_x, int hot_y);
231
232 /* Show the specified cursor, or hide if cursor is NULL */
233 int (*ShowWMCursor)(_THIS, WMcursor *cursor);
234
235 /* Warp the window manager cursor to (x,y)
236 If NULL, a mouse motion event is posted internally.
237 */
238 void (*WarpWMCursor)(_THIS, Uint16 x, Uint16 y);
239
240 /* If not NULL, this is called when a mouse motion event occurs */
241 void (*MoveWMCursor)(_THIS, int x, int y);
242
243 /* Determine whether the mouse should be in relative mode or not.
244 This function is called when the input grab state or cursor
245 visibility state changes.
246 If the cursor is not visible, and the input is grabbed, the
247 driver can place the mouse in relative mode, which may result
248 in higher accuracy sampling of the pointer motion.
249 */
250 void (*CheckMouseMode)(_THIS);
251
252 /* * * */
253 /* Event manager functions */
254
255 /* Initialize keyboard mapping for this driver */
256 void (*InitOSKeymap)(_THIS);
257
258 /* Handle any queued OS events */
259 void (*PumpEvents)(_THIS);
260
261 /* * * */
262 /* Data common to all drivers */
263 SDL_Surface *screen;
264 SDL_Surface *shadow;
265 SDL_Surface *visible;
266 SDL_Palette *physpal; /* physical palette, if != logical palette */
267 SDL_Color *gammacols; /* gamma-corrected colours, or NULL */
268 char *wm_title;
269 char *wm_icon;
270 int offset_x;
271 int offset_y;
272 SDL_GrabMode input_grab;
273
274 /* Driver information flags */
275 int handles_any_size; /* Driver handles any size video mode */
276
277 /* * * */
278 /* Data used by the GL drivers */
279 struct {
280 int red_size;
281 int green_size;
282 int blue_size;
283 int alpha_size;
284 int depth_size;
285 int buffer_size;
286 int stencil_size;
287 int double_buffer;
288 int accum_red_size;
289 int accum_green_size;
290 int accum_blue_size;
291 int accum_alpha_size;
292 int stereo;
293 int multisamplebuffers;
294 int multisamplesamples;
295 int accelerated;
296 int swap_control;
297 int driver_loaded;
298 char driver_path[256];
299 void* dll_handle;
300 } gl_config;
301
302 /* * * */
303 /* Data private to this driver */
304 struct SDL_PrivateVideoData *hidden;
305 struct SDL_PrivateGLData *gl_data;
306
307 /* * * */
308 /* The function used to dispose of this structure */
309 void (*free)(_THIS);
310 };
311 #undef _THIS
312
313 typedef struct VideoBootStrap {
314 const char *name;
315 const char *desc;
316 int (*available)(void);
317 SDL_VideoDevice *(*create)(int devindex);
318 } VideoBootStrap; 318 } VideoBootStrap;
319 319
320 #if SDL_VIDEO_DRIVER_QUARTZ 320 #if SDL_VIDEO_DRIVER_QUARTZ
321 extern VideoBootStrap QZ_bootstrap; 321 extern VideoBootStrap QZ_bootstrap;
322 #endif 322 #endif
357 extern VideoBootStrap SVGALIB_bootstrap; 357 extern VideoBootStrap SVGALIB_bootstrap;
358 #endif 358 #endif
359 #if SDL_VIDEO_DRIVER_GAPI 359 #if SDL_VIDEO_DRIVER_GAPI
360 extern VideoBootStrap GAPI_bootstrap; 360 extern VideoBootStrap GAPI_bootstrap;
361 #endif 361 #endif
362 #if SDL_VIDEO_DRIVER_WINDIB 362 #if SDL_VIDEO_DRIVER_WIN32
363 extern VideoBootStrap WINDIB_bootstrap; 363 extern VideoBootStrap WIN32_bootstrap;
364 #endif
365 #if SDL_VIDEO_DRIVER_DDRAW
366 extern VideoBootStrap DIRECTX_bootstrap;
367 #endif 364 #endif
368 #if SDL_VIDEO_DRIVER_BWINDOW 365 #if SDL_VIDEO_DRIVER_BWINDOW
369 extern VideoBootStrap BWINDOW_bootstrap; 366 extern VideoBootStrap BWINDOW_bootstrap;
370 #endif 367 #endif
371 #if SDL_VIDEO_DRIVER_TOOLBOX 368 #if SDL_VIDEO_DRIVER_TOOLBOX
405 extern VideoBootStrap AALIB_bootstrap; 402 extern VideoBootStrap AALIB_bootstrap;
406 #endif 403 #endif
407 #if SDL_VIDEO_DRIVER_DUMMY 404 #if SDL_VIDEO_DRIVER_DUMMY
408 extern VideoBootStrap DUMMY_bootstrap; 405 extern VideoBootStrap DUMMY_bootstrap;
409 #endif 406 #endif
410 407 #if SDL_VIDEO_DRIVER_GLSDL
411 /* This is the current video device */ 408 extern VideoBootStrap glSDL_bootstrap;
412 extern SDL_VideoDevice *current_video; 409 #endif
413 410
414 #define SDL_VideoSurface (current_video->screen) 411 #define SDL_CurrentDisplay (_this->displays[_this->current_display])
415 #define SDL_ShadowSurface (current_video->shadow) 412
416 #define SDL_PublicSurface (current_video->visible) 413 extern SDL_VideoDevice *SDL_GetVideoDevice();
414 extern int SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode);
415 extern int SDL_AddVideoDisplay(const SDL_VideoDisplay * display);
416 extern SDL_bool SDL_AddDisplayMode(int displayIndex,
417 const SDL_DisplayMode * mode);
418 extern void SDL_AddRenderDriver(int displayIndex,
419 const SDL_RenderDriver * driver);
420
421 extern SDL_Window *SDL_GetWindowFromID(SDL_WindowID windowID);
422 extern SDL_VideoDisplay *SDL_GetDisplayFromWindow(SDL_Window * window);
423
424 extern void SDL_OnWindowShown(SDL_Window * window);
425 extern void SDL_OnWindowHidden(SDL_Window * window);
426 extern void SDL_OnWindowFocusGained(SDL_Window * window);
427 extern void SDL_OnWindowFocusLost(SDL_Window * window);
428 extern SDL_WindowID SDL_GetFocusWindow(void);
417 429
418 #endif /* _SDL_sysvideo_h */ 430 #endif /* _SDL_sysvideo_h */
431
432 /* vi: set ts=4 sw=4 expandtab: */