--- a/misc/winutils/include/SDL_video.h Tue Jan 21 22:38:13 2014 +0100
+++ b/misc/winutils/include/SDL_video.h Tue Jan 21 22:43:06 2014 +0100
@@ -48,77 +48,77 @@
/** @name Useful data types */
/*@{*/
typedef struct SDL_Rect {
- Sint16 x, y;
- Uint16 w, h;
+ Sint16 x, y;
+ Uint16 w, h;
} SDL_Rect;
typedef struct SDL_Color {
- Uint8 r;
- Uint8 g;
- Uint8 b;
- Uint8 unused;
+ Uint8 r;
+ Uint8 g;
+ Uint8 b;
+ Uint8 unused;
} SDL_Color;
#define SDL_Colour SDL_Color
typedef struct SDL_Palette {
- int ncolors;
- SDL_Color *colors;
+ 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;
+ 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;
+ /** 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 */
+ 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;
+ /** Hardware-specific surface info */
+ struct private_hwdata *hwdata;
- /** clipping information */
- SDL_Rect clip_rect; /**< Read-only */
- Uint32 unused1; /**< for binary compatibility */
+ /** clipping information */
+ SDL_Rect clip_rect; /**< Read-only */
+ Uint32 unused1; /**< for binary compatibility */
- /** Allow recursive locks */
- Uint32 locked; /**< Private */
+ /** Allow recursive locks */
+ Uint32 locked; /**< Private */
- /** info for fast blit mapping to other surfaces */
- struct SDL_BlitMap *map; /**< 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 */
+ /** 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 */
+ /** Reference count -- used when freeing surface */
+ int refcount; /**< Read-mostly */
} SDL_Surface;
/** @name SDL_Surface Flags
@@ -128,100 +128,100 @@
/** 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 */
+#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_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_OPENGLBLIT 0x0000000A /**< Create an OpenGL rendering context and use it for blitting */
-#define SDL_RESIZABLE 0x00000010 /**< This video mode may be resized */
-#define SDL_NOFRAME 0x00000020 /**< No window caption or edge frame */
+#define SDL_OPENGLBLIT 0x0000000A /**< Create an OpenGL rendering context and use it for blitting */
+#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 */
+#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 */
/*@}*/
/*@}*/
/** Evaluates to true if the surface needs to be locked before access */
-#define SDL_MUSTLOCK(surface) \
- (surface->offset || \
+#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);
+ 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_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 */
+ 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;
/** @name Overlay Formats
* The most common video overlay formats.
* For an explanation of these pixel formats, see:
- * http://www.webartz.com/fourcc/indexyuv.htm
+ * http://www.webartz.com/fourcc/indexyuv.htm
*
* 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 */
+ Uint32 format; /**< Read-only */
+ int w, h; /**< Read-only */
+ int planes; /**< Read-only */
+ Uint16 *pitches; /**< Read-only */
+ Uint8 **pixels; /**< Read-write */
- /** @name Hardware-specific surface info */
+ /** @name Hardware-specific surface info */
/*@{*/
- struct private_yuvhwfuncs *hwfuncs;
- struct private_yuvhwdata *hwdata;
+ struct private_yuvhwfuncs *hwfuncs;
+ struct private_yuvhwdata *hwdata;
/*@{*/
- /** @name Special flags */
+ /** @name Special flags */
/*@{*/
- Uint32 hw_overlay :1; /**< Flag: This overlay hardware accelerated? */
- Uint32 UnusedBits :31;
+ Uint32 hw_overlay :1; /**< Flag: This overlay hardware accelerated? */
+ Uint32 UnusedBits :31;
/*@}*/
} SDL_Overlay;
@@ -314,11 +314,11 @@
/**
* 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,
+ * 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.
*
- * If 'format' is NULL, the mode list will be for the format given
+ * If 'format' is NULL, the mode list will be for the format given
* by SDL_GetVideoInfo()->vfmt
*/
extern DECLSPEC SDL_Rect ** SDLCALL SDL_ListModes(SDL_PixelFormat *format, Uint32 flags);
@@ -347,21 +347,21 @@
* 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,
+ * 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.
*
* 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
+ * If the SDL library is able to set a fullscreen video mode, this flag
* will be set in the surface that is returned.
*
* 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
+ * 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
+ * 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.
*
* If SDL_RESIZABLE is set in 'flags', the SDL library will allow the
@@ -382,7 +382,7 @@
* are not available.
*/
extern DECLSPEC SDL_Surface * SDLCALL SDL_SetVideoMode
- (int width, int height, int bpp, Uint32 flags);
+ (int width, int height, int bpp, Uint32 flags);
/** @name SDL_Update Functions
* These functions should not be called while 'screen' is locked.
@@ -392,13 +392,13 @@
* Makes sure the given list of rectangles is updated on the given screen.
*/
extern DECLSPEC void SDLCALL SDL_UpdateRects
- (SDL_Surface *screen, int numrects, SDL_Rect *rects);
+ (SDL_Surface *screen, int numrects, SDL_Rect *rects);
/**
* If 'x', 'y', 'w' and 'h' are all 0, SDL_UpdateRect will update the entire
* screen.
*/
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);
/*@}*/
/**
@@ -416,7 +416,7 @@
/**
* Set the gamma correction for each of the color channels.
* The gamma values range (approximately) between 0.1 and 10.0
- *
+ *
* If this function isn't supported directly by the hardware, it will
* be emulated using gamma ramps, if available. If successful, this
* function returns 0, otherwise it returns -1.
@@ -429,7 +429,7 @@
* representing a mapping between the input and output for that channel.
* The input is the index into the array, and the output is the 16-bit
* gamma value at that index, scaled to the output color precision.
- *
+ *
* You may pass NULL for any of the channels to leave it unchanged.
* If the call succeeds, it will return 0. If the display driver or
* hardware does not support gamma translation, or otherwise fails,
@@ -439,7 +439,7 @@
/**
* Retrieve the current values of the gamma translation tables.
- *
+ *
* You must pass in valid pointers to arrays of 256 16-bit quantities.
* Any of the pointers may be NULL to ignore that channel.
* If the call succeeds, it will return 0. If the display driver or
@@ -457,14 +457,14 @@
* determine the actual color palette.
*
* When 'surface' is the surface associated with the current display, the
- * display colormap will be updated with the requested colors. If
+ * display colormap will be updated with the requested colors. If
* SDL_HWPALETTE was set in SDL_SetVideoMode() flags, SDL_SetColors()
* will always return 1, and the palette is guaranteed to be set the way
* 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);
+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.
@@ -483,8 +483,8 @@
* flags = (SDL_LOGPAL|SDL_PHYSPAL).
*/
extern DECLSPEC int SDLCALL SDL_SetPalette(SDL_Surface *surface, int flags,
- SDL_Color *colors, int firstcolor,
- int ncolors);
+ SDL_Color *colors, int firstcolor,
+ int ncolors);
/**
* Maps an RGB triple to an opaque pixel value for a given pixel format
@@ -504,15 +504,15 @@
* Maps a pixel value into the RGB components for a given pixel format
*/
extern DECLSPEC void SDLCALL SDL_GetRGB(Uint32 pixel,
- const SDL_PixelFormat * const fmt,
- Uint8 *r, Uint8 *g, Uint8 *b);
+ const SDL_PixelFormat * const 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,
- const SDL_PixelFormat * const fmt,
- Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a);
+ const SDL_PixelFormat * const fmt,
+ Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a);
/** @sa SDL_CreateRGBSurface */
#define SDL_AllocSurface SDL_CreateRGBSurface
@@ -537,7 +537,7 @@
* two surfaces in video memory, SDL will try to place the surface in
* video memory. If this isn't possible or if there is no hardware
* acceleration available, the surface will be placed in system memory.
- * SDL_SRCALPHA means that the surface will be used for alpha blits and
+ * SDL_SRCALPHA means that the surface will be used for alpha blits and
* if the hardware supports hardware acceleration of alpha blits between
* two surfaces in video memory, to place the surface in video memory
* if possible, otherwise it will be placed in system memory.
@@ -551,19 +551,19 @@
* the SDL_HWSURFACE flag set, and will be created in system memory instead.
*/
extern DECLSPEC SDL_Surface * SDLCALL SDL_CreateRGBSurface
- (Uint32 flags, int width, int height, int depth,
- Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
+ (Uint32 flags, int width, int height, int depth,
+ Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
/** @sa SDL_CreateRGBSurface */
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);
+ 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.
* Between calls to SDL_LockSurface()/SDL_UnlockSurface(), you can write
- * to and read from 'surface->pixels', using the pixel format stored in
- * 'surface->format'. Once you are done accessing the surface, you should
+ * to and read from 'surface->pixels', using the pixel format stored in
+ * 'surface->format'. Once you are done accessing the surface, you should
* use SDL_UnlockSurface() to release it.
*
* Not all surfaces require locking. If SDL_MUSTLOCK(surface) evaluates
@@ -571,7 +571,7 @@
* pixel format of the surface will not change. In particular, if the
* SDL_HWSURFACE flag is not given when calling SDL_SetVideoMode(), you
* will not need to lock the display surface before accessing it.
- *
+ *
* No operating system or library calls should be made between lock/unlock
* pairs, as critical system locks may be held during this time.
*
@@ -589,7 +589,7 @@
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)
+#define SDL_LoadBMP(file) SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)
/**
* Save a surface to a seekable SDL data source (memory or file.)
@@ -597,15 +597,15 @@
* 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) \
- SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)
+ SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)
/**
* Sets the color key (transparent pixel) in a blittable surface.
- * If 'flag' is SDL_SRCCOLORKEY (optionally OR'd with SDL_RLEACCEL),
+ * If 'flag' is SDL_SRCCOLORKEY (optionally OR'd with SDL_RLEACCEL),
* 'key' will be the transparent pixel in the source image of a blit.
* SDL_RLEACCEL requests RLE acceleration for the surface if present,
* and removes RLE acceleration if absent.
@@ -613,7 +613,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
@@ -654,11 +654,11 @@
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
- * the given surface to it so the blit of the converted surface will be as
+ * Creates a new surface of the specified format, and then copies and maps
+ * the given surface to it so the blit of the converted surface will be as
* fast as possible. If this function fails, it returns NULL.
*
- * The 'flags' parameter is passed to SDL_CreateRGBSurface() and has those
+ * The 'flags' parameter is passed to SDL_CreateRGBSurface() and has those
* semantics. You can also pass SDL_RLEACCEL in the flags parameter and
* SDL will try to RLE accelerate colorkey and alpha blits in the resulting
* surface.
@@ -666,7 +666,7 @@
* This function is used internally by SDL_DisplayFormat().
*/
extern DECLSPEC SDL_Surface * SDLCALL SDL_ConvertSurface
- (SDL_Surface *src, SDL_PixelFormat *fmt, Uint32 flags);
+ (SDL_Surface *src, SDL_PixelFormat *fmt, Uint32 flags);
/**
* This performs a fast blit from the source surface to the destination
@@ -683,54 +683,54 @@
*
* RGBA->RGB:
* SDL_SRCALPHA set:
- * alpha-blend (using alpha-channel).
- * SDL_SRCCOLORKEY ignored.
+ * alpha-blend (using alpha-channel).
+ * SDL_SRCCOLORKEY ignored.
* SDL_SRCALPHA not set:
- * copy RGB.
- * if SDL_SRCCOLORKEY set, only copy the pixels matching the
- * RGB values of the source colour key, ignoring alpha in the
- * comparison.
- *
+ * copy RGB.
+ * if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ * RGB values of the source colour key, ignoring alpha in the
+ * comparison.
+ *
* RGB->RGBA:
* SDL_SRCALPHA set:
- * alpha-blend (using the source per-surface alpha value);
- * set destination alpha to opaque.
+ * alpha-blend (using the source per-surface alpha value);
+ * set destination alpha to opaque.
* SDL_SRCALPHA not set:
- * copy RGB, set destination alpha to source per-surface alpha value.
+ * copy RGB, set destination alpha to source per-surface alpha value.
* both:
- * if SDL_SRCCOLORKEY set, only copy the pixels matching the
- * source colour key.
- *
+ * if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ * source colour key.
+ *
* RGBA->RGBA:
* SDL_SRCALPHA set:
- * alpha-blend (using the source alpha channel) the RGB values;
- * leave destination alpha untouched. [Note: is this correct?]
- * SDL_SRCCOLORKEY ignored.
+ * alpha-blend (using the source alpha channel) the RGB values;
+ * leave destination alpha untouched. [Note: is this correct?]
+ * SDL_SRCCOLORKEY ignored.
* SDL_SRCALPHA not set:
- * copy all of RGBA to the destination.
- * if SDL_SRCCOLORKEY set, only copy the pixels matching the
- * RGB values of the source colour key, ignoring alpha in the
- * comparison.
- *
- * RGB->RGB:
+ * copy all of RGBA to the destination.
+ * if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ * RGB values of the source colour key, ignoring alpha in the
+ * comparison.
+ *
+ * RGB->RGB:
* SDL_SRCALPHA set:
- * alpha-blend (using the source per-surface alpha value).
+ * alpha-blend (using the source per-surface alpha value).
* SDL_SRCALPHA not set:
- * copy RGB.
+ * copy RGB.
* both:
- * if SDL_SRCCOLORKEY set, only copy the pixels matching the
- * source colour key.
+ * if SDL_SRCCOLORKEY set, only copy the pixels matching the
+ * source colour key.
*
* If either of the surfaces were in video memory, and the blit returns -2,
- * the video memory was lost, so it should be reloaded with artwork and
+ * the video memory was lost, so it should be reloaded with artwork and
* re-blitted:
* @code
- * while ( SDL_BlitSurface(image, imgrect, screen, dstrect) == -2 ) {
- * while ( SDL_LockSurface(image) < 0 )
- * Sleep(10);
- * -- Write image pixels to image->pixels --
- * SDL_UnlockSurface(image);
- * }
+ * while ( SDL_BlitSurface(image, imgrect, screen, dstrect) == -2 ) {
+ * while ( SDL_LockSurface(image) < 0 )
+ * Sleep(10);
+ * -- Write image pixels to image->pixels --
+ * SDL_UnlockSurface(image);
+ * }
* @endcode
*
* This happens under DirectX 5.0 when the system switches away from your
@@ -746,26 +746,26 @@
* 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'
* The given rectangle is clipped to the destination surface clip area
* and the final fill rectangle is saved in the passed in pointer.
* If 'dstrect' is NULL, the whole surface will be filled with 'color'
- * The color should be a pixel of the format used by the surface, and
+ * The color should be a pixel of the format used by the surface, and
* can be generated by the SDL_MapRGB() function.
* 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
@@ -805,7 +805,7 @@
* 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);
+ 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);
@@ -813,7 +813,7 @@
/** Blit a video overlay to the display surface.
* The contents of the video surface underneath the blit destination are
- * not defined.
+ * not defined.
* The width and height of the destination rectangle may be different from
* that of the overlay, but currently only 2x scaling is supported.
*/
@@ -908,7 +908,7 @@
* 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
+ * 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.
*
@@ -921,10 +921,10 @@
extern DECLSPEC int SDLCALL SDL_WM_ToggleFullScreen(SDL_Surface *surface);
typedef enum {
- SDL_GRAB_QUERY = -1,
- SDL_GRAB_OFF = 0,
- SDL_GRAB_ON = 1,
- SDL_GRAB_FULLSCREEN /**< Used internally */
+ SDL_GRAB_QUERY = -1,
+ SDL_GRAB_OFF = 0,
+ SDL_GRAB_ON = 1,
+ SDL_GRAB_FULLSCREEN /**< Used internally */
} SDL_GrabMode;
/**
* This function allows you to set and query the input grab state of
@@ -941,7 +941,7 @@
/** @internal 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);
-
+
/* Ends C function definitions when using C++ */
#ifdef __cplusplus
}