hedgewars: comparison misc/winutils/include/SDL

equal deleted inserted replaced

-:4feced261c68
+:de822cd3df3a
 /*@}*/
 /** @name Useful data types */
 /*@{*/
 typedef struct SDL_Rect {
-	Sint16 x, y;
+Sint16 x, y;
-	Uint16 w, h;
+Uint16 w, h;
 } SDL_Rect;
 typedef struct SDL_Color {
-	Uint8 r;
+Uint8 r;
-	Uint8 g;
+Uint8 g;
-	Uint8 b;
+Uint8 b;
-	Uint8 unused;
+Uint8 unused;
 } SDL_Color;
 #define SDL_Colour SDL_Color
 typedef struct SDL_Palette {
-	int       ncolors;
+int       ncolors;
-	SDL_Color *colors;
+SDL_Color *colors;
 } SDL_Palette;
 /*@}*/
 /** Everything in the pixel format structure is read-only */
 typedef struct SDL_PixelFormat {
-	SDL_Palette *palette;
+SDL_Palette *palette;
-	Uint8  BitsPerPixel;
+Uint8  BitsPerPixel;
-	Uint8  BytesPerPixel;
+Uint8  BytesPerPixel;
-	Uint8  Rloss;
+Uint8  Rloss;
-	Uint8  Gloss;
+Uint8  Gloss;
-	Uint8  Bloss;
+Uint8  Bloss;
-	Uint8  Aloss;
+Uint8  Aloss;
-	Uint8  Rshift;
+Uint8  Rshift;
-	Uint8  Gshift;
+Uint8  Gshift;
-	Uint8  Bshift;
+Uint8  Bshift;
-	Uint8  Ashift;
+Uint8  Ashift;
-	Uint32 Rmask;
+Uint32 Rmask;
-	Uint32 Gmask;
+Uint32 Gmask;
-	Uint32 Bmask;
+Uint32 Bmask;
-	Uint32 Amask;
+Uint32 Amask;
-	/** RGB color key information */
+/** RGB color key information */
-	Uint32 colorkey;
+Uint32 colorkey;
-	/** Alpha value information (per-surface alpha) */
+/** Alpha value information (per-surface alpha) */
-	Uint8  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 */
+Uint32 flags;               /**< Read-only */
-	SDL_PixelFormat *format;		/**< Read-only */
+SDL_PixelFormat *format;        /**< Read-only */
-	int w, h;				/**< Read-only */
+int w, h;               /**< Read-only */
-	Uint16 pitch;				/**< Read-only */
+Uint16 pitch;               /**< Read-only */
-	void *pixels;				/**< Read-write */
+void *pixels;               /**< Read-write */
-	int offset;				/**< Private */
+int offset;             /**< Private */
-	/** Hardware-specific surface info */
+/** Hardware-specific surface info */
-	struct private_hwdata *hwdata;
+struct private_hwdata *hwdata;
-	/** clipping information */
+/** clipping information */
-	SDL_Rect clip_rect;			/**< Read-only */
+SDL_Rect clip_rect;         /**< Read-only */
-	Uint32 unused1;				/**< for binary compatibility */
+Uint32 unused1;             /**< for binary compatibility */
-	/** Allow recursive locks */
+/** Allow recursive locks */
-	Uint32 locked;				/**< Private */
+Uint32 locked;              /**< Private */
-	/** info for fast blit mapping to other surfaces */
+/** info for fast blit mapping to other surfaces */
-	struct SDL_BlitMap *map;		/**< Private */
+struct SDL_BlitMap *map;        /**< Private */
-	/** format version, bumped at every change to invalidate blit maps */
+/** format version, bumped at every change to invalidate blit maps */
-	unsigned int format_version;		/**< Private */
+unsigned int format_version;        /**< Private */
-	/** Reference count -- used when freeing surface */
+/** Reference count -- used when freeing surface */
-	int refcount;				/**< Read-mostly */
+int refcount;               /**< Read-mostly */
 } SDL_Surface;
 /** @name SDL_Surface Flags
 *  These are the currently supported flags for the SDL_surface
 */
 /*@{*/
 /** Available for SDL_CreateRGBSurface() or SDL_SetVideoMode() */
 /*@{*/
-#define SDL_SWSURFACE	0x00000000	/**< Surface is in system memory */
+#define SDL_SWSURFACE   0x00000000  /**< Surface is in system memory */
-#define SDL_HWSURFACE	0x00000001	/**< Surface is in video memory */
+#define SDL_HWSURFACE   0x00000001  /**< Surface is in video memory */
-#define SDL_ASYNCBLIT	0x00000004	/**< Use asynchronous blits if possible */
+#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_ANYFORMAT   0x10000000  /**< Allow any video depth/pixel-format */
-#define SDL_HWPALETTE	0x20000000	/**< Surface has exclusive palette */
+#define SDL_HWPALETTE   0x20000000  /**< Surface has exclusive palette */
-#define SDL_DOUBLEBUF	0x40000000	/**< Set up double-buffered video mode */
+#define SDL_DOUBLEBUF   0x40000000  /**< Set up double-buffered video mode */
-#define SDL_FULLSCREEN	0x80000000	/**< Surface is a full screen display */
+#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_OPENGLBLIT  0x0000000A  /**< Create an OpenGL rendering context and use it for blitting */
-#define SDL_RESIZABLE	0x00000010	/**< This video mode may be resized */
+#define SDL_RESIZABLE   0x00000010  /**< This video mode may be resized */
-#define SDL_NOFRAME	0x00000020	/**< No window caption or edge frame */
+#define SDL_NOFRAME 0x00000020  /**< No window caption or edge frame */
 /*@}*/
 /** Used internally (read-only) */
 /*@{*/
-#define SDL_HWACCEL	0x00000100	/**< Blit uses hardware acceleration */
+#define SDL_HWACCEL 0x00000100  /**< Blit uses hardware acceleration */
-#define SDL_SRCCOLORKEY	0x00001000	/**< Blit uses a source color key */
+#define SDL_SRCCOLORKEY 0x00001000  /**< Blit uses a source color key */
-#define SDL_RLEACCELOK	0x00002000	/**< Private flag */
+#define SDL_RLEACCELOK  0x00002000  /**< Private flag */
-#define SDL_RLEACCEL	0x00004000	/**< Surface is RLE encoded */
+#define SDL_RLEACCEL    0x00004000  /**< Surface is RLE encoded */
-#define SDL_SRCALPHA	0x00010000	/**< Blit uses source alpha blending */
+#define SDL_SRCALPHA    0x00010000  /**< Blit uses source alpha blending */
-#define SDL_PREALLOC	0x01000000	/**< Surface uses preallocated memory */
+#define SDL_PREALLOC    0x01000000  /**< Surface uses preallocated memory */
 /*@}*/
 /*@}*/
 /** Evaluates to true if the surface needs to be locked before access */
-#define SDL_MUSTLOCK(surface)	\
+#define SDL_MUSTLOCK(surface)   \
-(surface->offset ||		\
+(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 hw_available :1; /**< Flag: Can you create hardware surfaces? */
-	Uint32 wm_available :1;	/**< Flag: Can you talk to a window manager? */
+Uint32 wm_available :1; /**< Flag: Can you talk to a window manager? */
-	Uint32 UnusedBits1  :6;
+Uint32 UnusedBits1  :6;
-	Uint32 UnusedBits2  :1;
+Uint32 UnusedBits2  :1;
-	Uint32 blit_hw      :1;	/**< Flag: Accelerated blits HW --> HW */
+Uint32 blit_hw      :1; /**< Flag: Accelerated blits HW --> HW */
-	Uint32 blit_hw_CC   :1;	/**< Flag: Accelerated blits with Colorkey */
+Uint32 blit_hw_CC   :1; /**< Flag: Accelerated blits with Colorkey */
-	Uint32 blit_hw_A    :1;	/**< Flag: Accelerated blits with Alpha */
+Uint32 blit_hw_A    :1; /**< Flag: Accelerated blits with Alpha */
-	Uint32 blit_sw      :1;	/**< Flag: Accelerated blits SW --> HW */
+Uint32 blit_sw      :1; /**< Flag: Accelerated blits SW --> HW */
-	Uint32 blit_sw_CC   :1;	/**< Flag: Accelerated blits with Colorkey */
+Uint32 blit_sw_CC   :1; /**< Flag: Accelerated blits with Colorkey */
-	Uint32 blit_sw_A    :1;	/**< Flag: Accelerated blits with Alpha */
+Uint32 blit_sw_A    :1; /**< Flag: Accelerated blits with Alpha */
-	Uint32 blit_fill    :1;	/**< Flag: Accelerated color fill */
+Uint32 blit_fill    :1; /**< Flag: Accelerated color fill */
-	Uint32 UnusedBits3  :16;
+Uint32 UnusedBits3  :16;
-	Uint32 video_mem;	/**< The total amount of video memory (in K) */
+Uint32 video_mem;   /**< The total amount of video memory (in K) */
-	SDL_PixelFormat *vfmt;	/**< Value: The format of the video surface */
+SDL_PixelFormat *vfmt;  /**< Value: The format of the video surface */
-	int    current_w;	/**< Value: The current video mode width */
+int    current_w;   /**< Value: The current video mode width */
-	int    current_h;	/**< Value: The current video mode height */
+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_YV12_OVERLAY  0x32315659    /**< Planar mode: Y + V + U  (3 planes) */
-#define SDL_IYUV_OVERLAY  0x56555949	/**< Planar mode: Y + U + V  (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_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_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_YVYU_OVERLAY  0x55595659    /**< Packed mode: Y0+V0+Y1+U0 (1 plane) */
 /*@}*/
 /** The YUV hardware video overlay */
 typedef struct SDL_Overlay {
-	Uint32 format;				/**< Read-only */
+Uint32 format;              /**< Read-only */
-	int w, h;				/**< Read-only */
+int w, h;               /**< Read-only */
-	int planes;				/**< Read-only */
+int planes;             /**< Read-only */
-	Uint16 *pitches;			/**< Read-only */
+Uint16 *pitches;            /**< Read-only */
-	Uint8 **pixels;				/**< Read-write */
+Uint8 **pixels;             /**< Read-write */
-	/** @name Hardware-specific surface info */
+/** @name Hardware-specific surface info */
 /*@{*/
-	struct private_yuvhwfuncs *hwfuncs;
+struct private_yuvhwfuncs *hwfuncs;
-	struct private_yuvhwdata *hwdata;
+struct private_yuvhwdata *hwdata;
 /*@{*/
-	/** @name Special flags */
+/** @name Special flags */
 /*@{*/
-	Uint32 hw_overlay :1;	/**< Flag: This overlay hardware accelerated? */
+Uint32 hw_overlay :1;   /**< Flag: This overlay hardware accelerated? */
-	Uint32 UnusedBits :31;
+Uint32 UnusedBits :31;
 /*@}*/
 } SDL_Overlay;
 /** Public enumeration for setting the OpenGL window attributes. */
 */
 extern DECLSPEC int SDLCALL SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags);
 /**
 * 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,
 * 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
 * by SDL_GetVideoInfo()->vfmt
 */
 extern DECLSPEC SDL_Rect ** SDLCALL SDL_ListModes(SDL_PixelFormat *format, Uint32 flags);
 /**
 * If SDL_HWPALETTE is set in 'flags', the SDL library will guarantee
 * that the colors set by SDL_SetColors() will be the colors you get.
 * 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,
 * 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
 * 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
 * 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
 * applications that redraw the entire screen on every update.
 *
 * If SDL_RESIZABLE is set in 'flags', the SDL library will allow the
 * window manager, if any, to resize the window at runtime.  When this
 * occurs, SDL will send a SDL_VIDEORESIZE event to you application,
 * flags of the returned surface to make sure that functionality is available.
 * SDL will fall back to reduced functionality if the exact flags you wanted
 * 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.
 */
 /*@{*/
 /**
 * 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);
 /*@}*/
 /**
 * On hardware that supports double-buffering, this function sets up a flip
 * and returns.  The hardware will wait for vertical retrace, and then swap
 extern DECLSPEC int SDLCALL SDL_Flip(SDL_Surface *screen);
 /**
 * 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.
 */
 extern DECLSPEC int SDLCALL SDL_SetGamma(float red, float green, float blue);
 * Set the gamma translation table for the red, green, and blue channels
 * of the video hardware.  Each table is an array of 256 16-bit quantities,
 * 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,
 * this function will return -1.
 */
 extern DECLSPEC int SDLCALL SDL_SetGammaRamp(const Uint16 *red, const Uint16 *green, const Uint16 *blue);
 /**
 * 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
 * hardware does not support gamma translation, or otherwise fails,
 * this function will return -1.
 * return 1.  If not all the color entries were set exactly as given,
 * it will return 0, and you should look at the surface palette to
 * 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
 * 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);
+SDL_Color *colors, int firstcolor, int ncolors);
 /**
 * Sets a portion of the colormap for a given 8-bit surface.
 * 'flags' is one or both of:
 * SDL_LOGPAL  -- set logical palette, which controls how blits are mapped
 *
 * SDL_SetColors() is equivalent to calling this function with
 *     flags = (SDL_LOGPAL|SDL_PHYSPAL).
 */
 extern DECLSPEC int SDLCALL SDL_SetPalette(SDL_Surface *surface, int flags,
-				   SDL_Color *colors, int firstcolor,
+SDL_Color *colors, int firstcolor,
-				   int ncolors);
+int ncolors);
 /**
 * Maps an RGB triple to an opaque pixel value for a given pixel format
 */
 extern DECLSPEC Uint32 SDLCALL SDL_MapRGB
 /**
 * 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,
+const SDL_PixelFormat * const fmt,
-				Uint8 *r, Uint8 *g, Uint8 *b);
+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,
+const SDL_PixelFormat * const fmt,
-				Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a);
+Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a);
 /** @sa SDL_CreateRGBSurface */
 #define SDL_AllocSurface    SDL_CreateRGBSurface
 /**
 * Allocate and free an RGB surface (must be called after SDL_SetVideoMode)
 * SDL_SRCCOLORKEY indicates that the surface will be used for colorkey blits.
 * If the hardware supports acceleration of colorkey blits between
 * 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
 * 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.
 * If the surface is created in video memory, blits will be _much_ faster,
 * but the surface format must be identical to the video surface format,
 * will be set in the flags member of the returned surface.  If for some
 * reason the surface could not be placed in video memory, it will not have
 * 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 flags, int width, int height, int depth,
-			Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
+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,
+int width, int height, int depth, int pitch,
-			Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
+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
 * use SDL_UnlockSurface() to release it.
 *
 * Not all surfaces require locking.  If SDL_MUSTLOCK(surface) evaluates
 * to 0, then you can read and write to the surface at any time, and the
 * 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.
 *
 * SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.
 */
 * The new surface should be freed with SDL_FreeSurface().
 */
 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.)
 * If 'freedst' is non-zero, the source will be closed after being written.
 * 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),
 * '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.
 * If 'flag' is 0, this function clears any current color key.
 * 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
 * using the alpha component of each pixel. This value measures the range
 * of transparency of the surface, 0 being completely transparent to 255
 * with the correct values.
 */
 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
 * fast as possible.  If this function fails, it returns NULL.
 *
 * 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.
 *
 * 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
 * surface.  It assumes that the source and destination rectangles are
 * the same size.  If either 'srcrect' or 'dstrect' are NULL, the entire
 * The blit semantics for surfaces with and without alpha and colorkey
 * are defined as follows:
 *
 * RGBA->RGB:
 *     SDL_SRCALPHA set:
-* 	alpha-blend (using alpha-channel).
+*  alpha-blend (using alpha-channel).
-* 	SDL_SRCCOLORKEY ignored.
+*  SDL_SRCCOLORKEY ignored.
 *     SDL_SRCALPHA not set:
-* 	copy RGB.
+*  copy RGB.
-* 	if SDL_SRCCOLORKEY set, only copy the pixels matching the
+*  if SDL_SRCCOLORKEY set, only copy the pixels matching the
-* 	RGB values of the source colour key, ignoring alpha in the
+*  RGB values of the source colour key, ignoring alpha in the
-* 	comparison.
+*  comparison.
 *
 * RGB->RGBA:
 *     SDL_SRCALPHA set:
-* 	alpha-blend (using the source per-surface alpha value);
+*  alpha-blend (using the source per-surface alpha value);
-* 	set destination alpha to opaque.
+*  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
+*  if SDL_SRCCOLORKEY set, only copy the pixels matching the
-* 	source colour key.
+*  source colour key.
 *
 * RGBA->RGBA:
 *     SDL_SRCALPHA set:
-* 	alpha-blend (using the source alpha channel) the RGB values;
+*  alpha-blend (using the source alpha channel) the RGB values;
-* 	leave destination alpha untouched. [Note: is this correct?]
+*  leave destination alpha untouched. [Note: is this correct?]
-* 	SDL_SRCCOLORKEY ignored.
+*  SDL_SRCCOLORKEY ignored.
 *     SDL_SRCALPHA not set:
-* 	copy all of RGBA to the destination.
+*  copy all of RGBA to the destination.
-* 	if SDL_SRCCOLORKEY set, only copy the pixels matching the
+*  if SDL_SRCCOLORKEY set, only copy the pixels matching the
-* 	RGB values of the source colour key, ignoring alpha in the
+*  RGB values of the source colour key, ignoring alpha in the
-* 	comparison.
+*  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
+*  if SDL_SRCCOLORKEY set, only copy the pixels matching the
-* 	source colour key.
+*  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
 * re-blitted:
 * @code
-*	while ( SDL_BlitSurface(image, imgrect, screen, dstrect) == -2 ) {
+*  while ( SDL_BlitSurface(image, imgrect, screen, dstrect) == -2 ) {
-*		while ( SDL_LockSurface(image) < 0 )
+*      while ( SDL_LockSurface(image) < 0 )
-*			Sleep(10);
+*          Sleep(10);
-*		-- Write image pixels to image->pixels --
+*      -- Write image pixels to image->pixels --
-*		SDL_UnlockSurface(image);
+*      SDL_UnlockSurface(image);
-*	}
+*  }
 * @endcode
 *
 * This happens under DirectX 5.0 when the system switches away from your
 * fullscreen application.  The lock will also fail until you have access
 * to the video memory again.
 /** This is the public blit function, SDL_BlitSurface(), and it performs
 *  rectangle validation and clipping before passing it to SDL_LowerBlit()
 */
 extern DECLSPEC int SDLCALL SDL_UpperBlit
-			(SDL_Surface *src, SDL_Rect *srcrect,
+(SDL_Surface *src, SDL_Rect *srcrect,
-			 SDL_Surface *dst, SDL_Rect *dstrect);
+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 *src, SDL_Rect *srcrect,
-			 SDL_Surface *dst, SDL_Rect *dstrect);
+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
 * 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
 * pixel format and colors of the video framebuffer, suitable for fast
 * blitting onto the display surface.  It calls SDL_ConvertSurface()
 *  Calling the returned surface an overlay is something of a misnomer because
 *  the contents of the display surface underneath the area where the overlay
 *  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);
 extern DECLSPEC void SDLCALL SDL_UnlockYUVOverlay(SDL_Overlay *overlay);
 /** Blit a video overlay to the display surface.
 *  The contents of the video surface underneath the blit destination are
 *  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.
 */
 extern DECLSPEC int SDLCALL SDL_DisplayYUVOverlay(SDL_Overlay *overlay, SDL_Rect *dstrect);
 /**
 * Toggle fullscreen mode without changing the contents of the screen.
 * 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
 * running in a window to fullscreen, or vice-versa), it will return 1.
 * If it is not implemented, or fails, it returns 0.
 *
 * The next call to SDL_SetVideoMode() will set the mode fullscreen
 * attribute based on the flags parameter - if SDL_FULLSCREEN is not
 * This is currently only implemented in the X11 video driver.
 */
 extern DECLSPEC int SDLCALL SDL_WM_ToggleFullScreen(SDL_Surface *surface);
 typedef enum {
-	SDL_GRAB_QUERY = -1,
+SDL_GRAB_QUERY = -1,
-	SDL_GRAB_OFF = 0,
+SDL_GRAB_OFF = 0,
-	SDL_GRAB_ON = 1,
+SDL_GRAB_ON = 1,
-	SDL_GRAB_FULLSCREEN	/**< Used internally */
+SDL_GRAB_FULLSCREEN /**< Used internally */
 } SDL_GrabMode;
 /**
 * This function allows you to set and query the input grab state of
 * the application.  It returns the new input grab state.
 *
 /*@}*/
 /** @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
 }
 #endif
 #include "close_code.h"

changeset 10017	de822cd3df3a
parent 7809	7d4fb2f35f4f