--- a/include/SDL_surface.h	Sun Oct 18 23:21:15 2009 +0000
+++ b/include/SDL_surface.h	Mon Oct 19 13:31:58 2009 +0000
@@ -21,9 +21,9 @@
 */
 
 /**
- * \file SDL_surface.h
- *
- * Header file for SDL_surface definition and management functions
+ *  \file SDL_surface.h
+ *  
+ *  Header file for ::SDL_surface definition and management functions.
  */
 
 #ifndef _SDL_surface_h
@@ -42,21 +42,28 @@
 /* *INDENT-ON* */
 #endif
 
-/** These are the currently supported flags for the SDL_surface
- *  \internal Used internally (read-only) 
+/**
+ *  \name Surface flags
+ *  
+ *  These are the currently supported flags for the ::SDL_surface.
+ *  
+ *  \internal
+ *  Used internally (read-only).
  */
 /*@{*/
 #define SDL_PREALLOC        0x00000001  /**< Surface uses preallocated memory */
 #define SDL_RLEACCEL        0x00000002  /**< Surface is RLE encoded */
-/*@}*/
+/*@}*//*Surface flags*/
 
-/** Evaluates to true if the surface needs to be locked before access */
+/**
+ *  Evaluates to true if the surface needs to be locked before access.
+ */
 #define SDL_MUSTLOCK(S)	(((S)->flags & SDL_RLEACCEL) != 0)
 
 /**
- * \brief A collection of pixels used in software blitting
+ * \brief A collection of pixels used in software blitting.
  *
- * \note  This structure should be treated as read-only, except for 'pixels',
+ * \note  This structure should be treated as read-only, except for \c pixels,
  *        which, if not NULL, contains the raw pixel data for the surface.
  */
 typedef struct SDL_Surface
@@ -67,40 +74,42 @@
     int pitch;                  /**< Read-only */
     void *pixels;               /**< Read-write */
 
-    /* Application data associated with the surfade */
+    /** Application data associated with the surfade */
     void *userdata;             /**< Read-write */
 
-    /* information needed for surfaces requiring locks */
+    /** information needed for surfaces requiring locks */
     int locked;                 /**< Read-only */
     void *lock_data;            /**< Read-only */
 
-    /* clipping information */
+    /** clipping information */
     SDL_Rect clip_rect;         /**< Read-only */
 
-    /* info for fast blit mapping to other surfaces */
+    /** info for fast blit mapping to other surfaces */
     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 */
 
-    /* Reference count -- used when freeing surface */
+    /** Reference count -- used when freeing surface */
     int refcount;               /**< Read-mostly */
 } SDL_Surface;
 
 /**
- * \brief The type of function used for surface blitting functions
+ * \brief The type of function used for surface blitting functions.
  */
 typedef int (*SDL_blit) (struct SDL_Surface * src, SDL_Rect * srcrect,
                          struct SDL_Surface * dst, SDL_Rect * dstrect);
 
 /**
- * Allocate and free an RGB surface (must be called after SDL_SetVideoMode)
- * If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
- * If the depth is greater than 8 bits, the pixel format is set using the
- * flags '[RGB]mask'.
- * If the function runs out of memory, it will return NULL.
- *
- * \param flags The 'flags' are obsolete and should be set to 0.
+ *  Allocate and free an RGB surface (must be called after SDL_SetVideoMode).
+ *  
+ *  If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
+ *  If the depth is greater than 8 bits, the pixel format is set using the
+ *  flags '[RGB]mask'.
+ *  
+ *  If the function runs out of memory, it will return NULL.
+ *  
+ *  \param flags The \c flags are obsolete and should be set to 0.
  */
 extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurface
     (Uint32 flags, int width, int height, int depth,
@@ -117,387 +126,426 @@
 extern DECLSPEC void SDLCALL SDL_FreeSurface(SDL_Surface * surface);
 
 /**
- * \brief Set the palette used by a surface.
- *
- * \return 0, or -1 if the surface format doesn't use a palette.
- *
- * \note A single palette can be shared with many surfaces.
+ *  \brief Set the palette used by a surface.
+ *  
+ *  \return 0, or -1 if the surface format doesn't use a palette.
+ *  
+ *  \note A single palette can be shared with many surfaces.
  */
 extern DECLSPEC int SDLCALL SDL_SetSurfacePalette(SDL_Surface * surface,
                                                   SDL_Palette * palette);
 
 /**
- * \brief 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.
- * 
- * 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.
- * 
- * \sa SDL_UnlockSurface()
+ *  \brief Sets up a surface for directly accessing the pixels.
+ *  
+ *  Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write
+ *  to and read from \c surface->pixels, using the pixel format stored in 
+ *  \c 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.
+ *  
+ *  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.
+ *  
+ *  \sa SDL_UnlockSurface()
  */
 extern DECLSPEC int SDLCALL SDL_LockSurface(SDL_Surface * surface);
 /** \sa SDL_LockSurface() */
 extern DECLSPEC void SDLCALL SDL_UnlockSurface(SDL_Surface * surface);
 
 /**
- * Load a surface from a seekable SDL data source (memory or file.)
- * If 'freesrc' is non-zero, the source will be closed after being read.
- * Returns the new surface, or NULL if there was an error.
- * The new surface should be freed with SDL_FreeSurface().
+ *  Load a surface from a seekable SDL data source (memory or file).
+ *  
+ *  If \c freesrc is non-zero, the source will be closed after being read.
+ *  
+ *  The new surface should be freed with SDL_FreeSurface().
+ *  
+ *  \return the new surface, or NULL if there was an error.
  */
 extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP_RW(SDL_RWops * src,
                                                     int freesrc);
 
-/** Convenience macro -- load a surface from a file */
+/**
+ *  Load a surface from a file.
+ *  
+ *  Convenience macro.
+ */
 #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.
+ *  Save a surface to a seekable SDL data source (memory or file).
+ *  
+ *  If \c freedst is non-zero, the source will be closed after being written.
+ *  
+ *  \return 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);
 
-/** Convenience macro -- save a surface to a file */
+/** 
+ *  Save a surface to a file.
+ *  
+ *  Convenience macro.
+ */
 #define SDL_SaveBMP(surface, file) \
 		SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)
 
 /**
- * \brief Sets the RLE acceleration hint for a surface.
- *
- * \return 0 on success, or -1 if the surface is not valid
- *
- * \note If RLE is enabled, colorkey and alpha blending blits are much faster,
- *       but the surface must be locked before directly accessing the pixels.
+ *  \brief Sets the RLE acceleration hint for a surface.
+ *  
+ *  \return 0 on success, or -1 if the surface is not valid
+ *  
+ *  \note If RLE is enabled, colorkey and alpha blending blits are much faster,
+ *        but the surface must be locked before directly accessing the pixels.
  */
 extern DECLSPEC int SDLCALL SDL_SetSurfaceRLE(SDL_Surface * surface,
                                               int flag);
 
 /**
- * \brief Sets the color key (transparent pixel) in a blittable surface.
- *
- * \param surface The surface to update
- * \param flag Non-zero to enable colorkey and 0 to disable colorkey 
- * \param key The transparent pixel in the native surface format
- *
- * \return 0 on success, or -1 if the surface is not valid
+ *  \brief Sets the color key (transparent pixel) in a blittable surface.
+ *  
+ *  \param surface The surface to update
+ *  \param flag Non-zero to enable colorkey and 0 to disable colorkey 
+ *  \param key The transparent pixel in the native surface format
+ *  
+ *  \return 0 on success, or -1 if the surface is not valid
  */
 extern DECLSPEC int SDLCALL SDL_SetColorKey(SDL_Surface * surface,
                                             Uint32 flag, Uint32 key);
 
 /**
- * \brief Sets the color key (transparent pixel) in a blittable surface.
- *
- * \param surface The surface to update
- * \param key A pointer filled in with the transparent pixel in the native surface format
- *
- * \return 0 on success, or -1 if the surface is not valid or colorkey is not enabled.
+ *  \brief Sets the color key (transparent pixel) in a blittable surface.
+ *  
+ *  \param surface The surface to update
+ *  \param key A pointer filled in with the transparent pixel in the native 
+ *             surface format
+ *  
+ *  \return 0 on success, or -1 if the surface is not valid or colorkey is not 
+ *          enabled.
  */
 extern DECLSPEC int SDLCALL SDL_GetColorKey(SDL_Surface * surface,
                                             Uint32 * key);
 
 /**
- * \brief Set an additional color value used in blit operations
- *
- * \param surface The surface to update
- * \param r The red source color value multiplied into blit operations
- * \param g The green source color value multiplied into blit operations
- * \param b The blue source color value multiplied into blit operations
- *
- * \return 0 on success, or -1 if the surface is not valid
- *
- * \sa SDL_GetSurfaceColorMod()
+ *  \brief Set an additional color value used in blit operations.
+ *  
+ *  \param surface The surface to update.
+ *  \param r The red source color value multiplied into blit operations.
+ *  \param g The green source color value multiplied into blit operations.
+ *  \param b The blue source color value multiplied into blit operations.
+ *  
+ *  \return 0 on success, or -1 if the surface is not valid.
+ *  
+ *  \sa SDL_GetSurfaceColorMod()
  */
 extern DECLSPEC int SDLCALL SDL_SetSurfaceColorMod(SDL_Surface * surface,
                                                    Uint8 r, Uint8 g, Uint8 b);
 
 
 /**
- * \brief Get the additional color value used in blit operations
- *
- * \param surface The surface to query
- * \param r A pointer filled in with the source red color value
- * \param g A pointer filled in with the source green color value
- * \param b A pointer filled in with the source blue color value
- *
- * \return 0 on success, or -1 if the surface is not valid
- *
- * \sa SDL_SetSurfaceColorMod()
+ *  \brief Get the additional color value used in blit operations.
+ *  
+ *  \param surface The surface to query.
+ *  \param r A pointer filled in with the source red color value.
+ *  \param g A pointer filled in with the source green color value.
+ *  \param b A pointer filled in with the source blue color value.
+ *  
+ *  \return 0 on success, or -1 if the surface is not valid.
+ *  
+ *  \sa SDL_SetSurfaceColorMod()
  */
 extern DECLSPEC int SDLCALL SDL_GetSurfaceColorMod(SDL_Surface * surface,
                                                    Uint8 * r, Uint8 * g,
                                                    Uint8 * b);
 
 /**
- * \brief Set an additional alpha value used in blit operations
- *
- * \param surface The surface to update
- * \param alpha The source alpha value multiplied into blit operations.
- *
- * \return 0 on success, or -1 if the surface is not valid
- *
- * \sa SDL_GetSurfaceAlphaMod()
+ *  \brief Set an additional alpha value used in blit operations.
+ *  
+ *  \param surface The surface to update.
+ *  \param alpha The source alpha value multiplied into blit operations.
+ *  
+ *  \return 0 on success, or -1 if the surface is not valid.
+ *  
+ *  \sa SDL_GetSurfaceAlphaMod()
  */
 extern DECLSPEC int SDLCALL SDL_SetSurfaceAlphaMod(SDL_Surface * surface,
                                                    Uint8 alpha);
 
 /**
- * \brief Get the additional alpha value used in blit operations
- *
- * \param surface The surface to query
- * \param alpha A pointer filled in with the source alpha value
- *
- * \return 0 on success, or -1 if the surface is not valid
- *
- * \sa SDL_SetSurfaceAlphaMod()
+ *  \brief Get the additional alpha value used in blit operations.
+ *  
+ *  \param surface The surface to query.
+ *  \param alpha A pointer filled in with the source alpha value.
+ *  
+ *  \return 0 on success, or -1 if the surface is not valid.
+ *  
+ *  \sa SDL_SetSurfaceAlphaMod()
  */
 extern DECLSPEC int SDLCALL SDL_GetSurfaceAlphaMod(SDL_Surface * surface,
                                                    Uint8 * alpha);
 
 /**
- * \brief Set the blend mode used for blit operations
- *
- * \param surface The surface to update
- * \param blendMode SDL_TextureBlendMode to use for blit blending
- *
- * \return 0 on success, or -1 if the parameters are not valid
- *
- * \sa SDL_GetSurfaceBlendMode()
+ *  \brief Set the blend mode used for blit operations.
+ *  
+ *  \param surface The surface to update.
+ *  \param blendMode ::SDL_BlendMode to use for blit blending.
+ *  
+ *  \return 0 on success, or -1 if the parameters are not valid.
+ *  
+ *  \sa SDL_GetSurfaceBlendMode()
  */
 extern DECLSPEC int SDLCALL SDL_SetSurfaceBlendMode(SDL_Surface * surface,
                                                     int blendMode);
 
 /**
- * \brief Get the blend mode used for blit operations
- *
- * \param surface The surface to query
- * \param blendMode A pointer filled in with the current blend mode
- *
- * \return 0 on success, or -1 if the surface is not valid
- *
- * \sa SDL_SetSurfaceBlendMode()
+ *  \brief Get the blend mode used for blit operations.
+ *  
+ *  \param surface   The surface to query.
+ *  \param blendMode A pointer filled in with the current blend mode.
+ *  
+ *  \return 0 on success, or -1 if the surface is not valid.
+ *  
+ *  \sa SDL_SetSurfaceBlendMode()
  */
 extern DECLSPEC int SDLCALL SDL_GetSurfaceBlendMode(SDL_Surface * surface,
                                                     int *blendMode);
 
 /**
- * \brief Set the scale mode used for blit operations
- *
- * \param surface The surface to update
- * \param scaleMode SDL_TextureScaleMode to use for blit scaling
- *
- * \return 0 on success, or -1 if the surface is not valid or the scale mode is not supported
- *
- * \note If the scale mode is not supported, the closest supported mode is chosen.  Currently only SDL_TEXTURESCALEMODE_FAST is supported on surfaces.
- *
- * \sa SDL_GetSurfaceScaleMode()
+ *  \brief Set the scale mode used for blit operations.
+ *  
+ *  \param surface   The surface to update.
+ *  \param scaleMode ::SDL_TextureScaleMode to use for blit scaling.
+ *  
+ *  \return 0 on success, or -1 if the surface is not valid or the scale mode is
+ *          not supported.
+ *  
+ *  \note If the scale mode is not supported, the closest supported mode is 
+ *        chosen.  Currently only ::SDL_TEXTURESCALEMODE_FAST is supported on 
+ *        surfaces.
+ *  
+ *  \sa SDL_GetSurfaceScaleMode()
  */
 extern DECLSPEC int SDLCALL SDL_SetSurfaceScaleMode(SDL_Surface * surface,
                                                     int scaleMode);
 
 /**
- * \brief Get the scale mode used for blit operations
- *
- * \param surface The surface to query
- * \param scaleMode A pointer filled in with the current scale mode
- *
- * \return 0 on success, or -1 if the surface is not valid
- *
- * \sa SDL_SetSurfaceScaleMode()
+ *  \brief Get the scale mode used for blit operations.
+ *  
+ *  \param surface   The surface to query.
+ *  \param scaleMode A pointer filled in with the current scale mode.
+ *  
+ *  \return 0 on success, or -1 if the surface is not valid.
+ *  
+ *  \sa SDL_SetSurfaceScaleMode()
  */
 extern DECLSPEC int SDLCALL SDL_GetSurfaceScaleMode(SDL_Surface * surface,
                                                     int *scaleMode);
 
 /**
- * Sets the clipping rectangle for the destination surface in a blit.
- *
- * If the clip rectangle is NULL, clipping will be disabled.
- * If the clip rectangle doesn't intersect the surface, the function will
- * return SDL_FALSE and blits will be completely clipped.  Otherwise the
- * function returns SDL_TRUE and blits to the surface will be clipped to
- * the intersection of the surface area and the clipping rectangle.
- *
- * Note that blits are automatically clipped to the edges of the source
- * and destination surfaces.
+ *  Sets the clipping rectangle for the destination surface in a blit.
+ *  
+ *  If the clip rectangle is NULL, clipping will be disabled.
+ *  
+ *  If the clip rectangle doesn't intersect the surface, the function will
+ *  return SDL_FALSE and blits will be completely clipped.  Otherwise the
+ *  function returns SDL_TRUE and blits to the surface will be clipped to
+ *  the intersection of the surface area and the clipping rectangle.
+ *  
+ *  Note that blits are automatically clipped to the edges of the source
+ *  and destination surfaces.
  */
 extern DECLSPEC SDL_bool SDLCALL SDL_SetClipRect(SDL_Surface * surface,
                                                  const SDL_Rect * rect);
 
 /**
- * Gets the clipping rectangle for the destination surface in a blit.
- * 'rect' must be a pointer to a valid rectangle which will be filled
- * with the correct values.
+ *  Gets the clipping rectangle for the destination surface in a blit.
+ *  
+ *  \c rect must be a pointer to a valid rectangle which will be filled
+ *  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().
+ *  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 \c 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);
 
 /**
- * This function draws a point with 'color'
- * The color should be a pixel of the format used by the surface, and 
- * can be generated by the SDL_MapRGB() function.
- * \return This function returns 0 on success, or -1 on error.
+ *  Draws a point with \c color.
+ *
+ *  The color should be a pixel of the format used by the surface, and 
+ *  can be generated by the SDL_MapRGB() function.
+ *  
+ *  \return 0 on success, or -1 on error.
  */
 extern DECLSPEC int SDLCALL SDL_DrawPoint
     (SDL_Surface * dst, int x, int y, Uint32 color);
 
 /**
- * This function blends a point with an RGBA value
- * The color should be a pixel of the format used by the surface, and 
- * can be generated by the SDL_MapRGB() function.
- * \return This function returns 0 on success, or -1 on error.
+ *  Blends a point with an RGBA value.
+ *  
+ *  The color should be a pixel of the format used by the surface, and 
+ *  can be generated by the SDL_MapRGB() function.
+ *  
+ *  \return 0 on success, or -1 on error.
  */
 extern DECLSPEC int SDLCALL SDL_BlendPoint
     (SDL_Surface * dst, int x, int y, int blendMode,
      Uint8 r, Uint8 g, Uint8 b, Uint8 a);
 
 /**
- * This function draws a line with 'color'
- * The color should be a pixel of the format used by the surface, and 
- * can be generated by the SDL_MapRGB() function.
- * \return This function returns 0 on success, or -1 on error.
+ *  Draws a line with \c color.
+ *  
+ *  The color should be a pixel of the format used by the surface, and 
+ *  can be generated by the SDL_MapRGB() function.
+ *  
+ *  \return 0 on success, or -1 on error.
  */
 extern DECLSPEC int SDLCALL SDL_DrawLine
     (SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color);
 
 /**
- * This function blends an RGBA value along a line
- * \return This function returns 0 on success, or -1 on error.
+ *  Blends an RGBA value along a line.
+ *  
+ *  \return 0 on success, or -1 on error.
  */
 extern DECLSPEC int SDLCALL SDL_BlendLine
     (SDL_Surface * dst, int x1, int y1, int x2, int y2, int blendMode,
      Uint8 r, Uint8 g, Uint8 b, Uint8 a);
 
 /**
- * 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.
- * \return This function returns 0 on success, or -1 on error.
+ *  Performs a fast fill of the given rectangle with \c 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 \c dstrect is NULL, the whole surface will be filled with \c color.
+ *  
+ *  The color should be a pixel of the format used by the surface, and 
+ *  can be generated by the SDL_MapRGB() function.
+ *  
+ *  \return 0 on success, or -1 on error.
  */
 extern DECLSPEC int SDLCALL SDL_FillRect
     (SDL_Surface * dst, SDL_Rect * dstrect, Uint32 color);
 
 /**
- * This function blends an RGBA value into the given rectangle.
- * 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'
- * \return This function returns 0 on success, or -1 on error.
+ *  Blends an RGBA value into the given rectangle.
+ *  
+ *  The given rectangle is clipped to the destination surface clip area
+ *  and the final fill rectangle is saved in the passed in pointer.
+ *  
+ *  If \c dstrect is NULL, the whole surface will be filled with \c color.
+ *  
+ *  \return This function returns 0 on success, or -1 on error.
  */
 extern DECLSPEC int SDLCALL SDL_BlendRect
     (SDL_Surface * dst, SDL_Rect * dstrect, int blendMode, Uint8 r, Uint8 g,
      Uint8 b, Uint8 a);
 
 /**
- * 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
- * surface (src or dst) is copied.  The final blit rectangles are saved
- * in 'srcrect' and 'dstrect' after all clipping is performed.
- * If the blit is successful, it returns 0, otherwise it returns -1.
+ *  Performs a fast blit from the source surface to the destination surface.
+ *  
+ *  This assumes that the source and destination rectangles are
+ *  the same size.  If either \c srcrect or \c dstrect are NULL, the entire
+ *  surface (\c src or \c dst) is copied.  The final blit rectangles are saved
+ *  in \c srcrect and \c dstrect after all clipping is performed.
+ *  
+ *  \return If the blit is successful, it returns 0, otherwise it returns -1.
  *
- * The blit function should not be called on a locked surface.
- *
- * The blit semantics for surfaces with and without alpha and colorkey
- * are defined as follows:
+ *  The blit function should not be called on a locked surface.
  *
- * RGBA->RGB:
- *     SDL_SRCALPHA set:
- * 	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.
- * 
- * RGB->RGBA:
- *     SDL_SRCALPHA set:
- * 	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.
- *     both:
- * 	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.
- *     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: 
- *     SDL_SRCALPHA set:
- * 	alpha-blend (using the source per-surface alpha value).
- *     SDL_SRCALPHA not set:
- * 	copy RGB.
- *     both:
- * 	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 
- * 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);
- *	}
- * @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.
- *
- * You should call SDL_BlitSurface() unless you know exactly how SDL
- * blitting works internally and how to use the other blit functions.
+ *  The blit semantics for surfaces with and without alpha and colorkey
+ *  are defined as follows:
+ *  \verbatim
+    RGBA->RGB:
+      SDL_SRCALPHA set:
+        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.
+   
+    RGB->RGBA:
+      SDL_SRCALPHA set:
+        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.
+      both:
+        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.
+      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: 
+      SDL_SRCALPHA set:
+        alpha-blend (using the source per-surface alpha value).
+      SDL_SRCALPHA not set:
+        copy RGB.
+      both:
+        if SDL_SRCCOLORKEY set, only copy the pixels matching the
+        source colour key.
+    \endverbatim
+ *  
+ *  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_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
+ *  fullscreen application.  The lock will also fail until you have access
+ *  to the video memory again.
+ *  
+ *  You should call SDL_BlitSurface() unless you know exactly how SDL
+ *  blitting works internally and how to use the other blit functions.
  */
 #define SDL_BlitSurface SDL_UpperBlit
 
-/** This is the public blit function, SDL_BlitSurface(), and it performs
+/**
+ *  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 * dst, SDL_Rect * dstrect);
 
-/** This is a semi-private blit function and it performs low-level surface
+/**
+ *  This is a semi-private blit function and it performs low-level surface
  *  blitting only.
  */
 extern DECLSPEC int SDLCALL SDL_LowerBlit
@@ -505,9 +553,10 @@
      SDL_Surface * dst, SDL_Rect * dstrect);
 
 /**
- * \brief Perform a fast, low quality, stretch blit between two surfaces of the same pixel format.
- *
- * \note This function uses a static buffer, and is not thread-safe.
+ *  \brief Perform a fast, low quality, stretch blit between two surfaces of the
+ *         same pixel format.
+ *  
+ *  \note This function uses a static buffer, and is not thread-safe.
  */
 extern DECLSPEC int SDLCALL SDL_SoftStretch(SDL_Surface * src,
                                             const SDL_Rect * srcrect,