Further corrections of typos and dash inconsistences

include/SFML/Audio/Music.hpp

@@ -93,7 +93,7 @@ public:
     /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
     /// Since the music is not loaded completely but rather streamed
     /// continuously, the \a data must remain available as long as the
-    /// music is playing (ie. you can't deallocate it right after calling
+    /// music is playing (i.e. you can't deallocate it right after calling
     /// this function).
     ///
     /// \param data        Pointer to the file data in memory
@@ -116,7 +116,7 @@ public:
     /// w64, mat4, mat5 pvf, htk, sds, avr, sd2, caf, wve, mpc2k, rf64.
     /// Since the music is not loaded completely but rather streamed
     /// continuously, the \a stream must remain alive as long as the
-    /// music is playing (ie. you can't destroy it right after calling
+    /// music is playing (i.e. you can't destroy it right after calling
     /// this function).
     ///
     /// \param stream Source stream to read from
@@ -186,13 +186,13 @@ private:
 /// \class sf::Music
 /// \ingroup audio
 ///
-/// Musics are sounds that are streamed rather than completely
+/// Music objects are sounds that are streamed rather than
-/// loaded in memory. This is especially useful for compressed
+/// completely loaded in memory. This is especially useful for
-/// musics that usually take hundreds of MB when they are
+/// compressed music that usually takes hundreds of MB when it is
 /// uncompressed: by streaming it instead of loading it entirely,
 /// you avoid saturating the memory and have almost no loading delay.
 ///
-/// Apart from that, a sf::Music has almost the same features as
+/// Apart from that, sf::Music has almost the same features as
 /// the sf::SoundBuffer / sf::Sound pair: you can play/pause/stop
 /// it, request its parameters (channels, sample rate), change
 /// the way it is played (pitch, volume, 3D position, ...), etc.

include/SFML/Audio/Sound.hpp

@@ -146,7 +146,7 @@ public:
     /// The playing position can be changed when the sound is
     /// either paused or playing. Changing the playing position
     /// when the sound is stopped has no effect, since playing
-    /// the sound would reset its position.
+    /// the sound will reset its position.
     ///
     /// \param timeOffset New playing position, from the beginning of the sound
     ///

include/SFML/Audio/SoundSource.hpp

@@ -130,7 +130,7 @@ public:
     /// \brief Make the sound's position relative to the listener or absolute
     ///
     /// Making a sound relative to the listener will ensure that it will always
-    /// be played the same way regardless the position of the listener.
+    /// be played the same way regardless of the position of the listener.
     /// This can be useful for non-spatialized sounds, sounds that are
     /// produced by the listener, or sounds attached to it.
     /// The default value is false (position is absolute).

include/SFML/Graphics/Rect.hpp

@@ -219,7 +219,7 @@ typedef Rect<float> FloatRect;
 /// don't intersect.
 ///
 /// sf::Rect is a template and may be used with any numeric type, but
-/// for simplicity the instantiations used by SFML are typedefed:
+/// for simplicity the instantiations used by SFML are typedef'd:
 /// \li sf::Rect<int> is sf::IntRect
 /// \li sf::Rect<float> is sf::FloatRect
 ///

include/SFML/Graphics/RenderTarget.hpp

@@ -74,7 +74,7 @@ public:
     ///
     /// The view is like a 2D camera, it controls which part of
     /// the 2D scene is visible, and how it is viewed in the
-    /// render-target.
+    /// render target.
     /// The new view will affect everything that is drawn, until
     /// another view is set.
     /// The render target keeps its own copy of the view object,
@@ -152,14 +152,14 @@ public:
     /// \brief Convert a point from target coordinates to world coordinates
     ///
     /// This function finds the 2D position that matches the
-    /// given pixel of the render-target. In other words, it does
+    /// given pixel of the render target. In other words, it does
     /// the inverse of what the graphics card does, to find the
     /// initial position of a rendered pixel.
     ///
     /// Initially, both coordinate systems (world units and target pixels)
     /// match perfectly. But if you define a custom view or resize your
-    /// render-target, this assertion is not true anymore, ie. a point
+    /// render target, this assertion is not true anymore, i.e. a point
-    /// located at (10, 50) in your render-target may map to the point
+    /// located at (10, 50) in your render target may map to the point
     /// (150, 75) in your 2D world -- if the view is translated by (140, 25).
     ///
     /// For render-windows, this function is typically used to find
@@ -167,7 +167,7 @@ public:
     ///
     /// This version uses a custom view for calculations, see the other
     /// overload of the function if you want to use the current view of the
-    /// render-target.
+    /// render target.
     ///
     /// \param point Pixel to convert
     /// \param view The view to use for converting the point
@@ -202,19 +202,19 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Convert a point from world coordinates to target coordinates
     ///
-    /// This function finds the pixel of the render-target that matches
+    /// This function finds the pixel of the render target that matches
     /// the given 2D point. In other words, it goes through the same process
     /// as the graphics card, to compute the final position of a rendered point.
     ///
     /// Initially, both coordinate systems (world units and target pixels)
     /// match perfectly. But if you define a custom view or resize your
-    /// render-target, this assertion is not true anymore, ie. a point
+    /// render target, this assertion is not true anymore, i.e. a point
     /// located at (150, 75) in your 2D world may map to the pixel
-    /// (10, 50) of your render-target -- if the view is translated by (140, 25).
+    /// (10, 50) of your render target -- if the view is translated by (140, 25).
     ///
     /// This version uses a custom view for calculations, see the other
     /// overload of the function if you want to use the current view of the
-    /// render-target.
+    /// render target.
     ///
     /// \param point Point to convert
     /// \param view The view to use for converting the point
@@ -227,7 +227,7 @@ public:
     Vector2i mapCoordsToPixel(const Vector2f& point, const View& view) const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Draw a drawable object to the render-target
+    /// \brief Draw a drawable object to the render target
     ///
     /// \param drawable Object to draw
     /// \param states   Render states to use for drawing
@@ -259,7 +259,7 @@ public:
     /// \brief Save the current OpenGL render states and matrices
     ///
     /// This function can be used when you mix SFML drawing
-    /// and direct OpenGL rendering. Combined with PopGLStates,
+    /// and direct OpenGL rendering. Combined with popGLStates,
     /// it ensures that:
     /// \li SFML's internal states are not messed up by your OpenGL code
     /// \li your OpenGL states are not modified by a call to a SFML function
@@ -281,7 +281,7 @@ public:
     /// It is provided for convenience, but the best results will
     /// be achieved if you handle OpenGL states yourself (because
     /// you know which states have really changed, and need to be
-    /// saved and restored). Take a look at the ResetGLStates
+    /// saved and restored). Take a look at the resetGLStates
     /// function if you do so.
     ///
     /// \see popGLStates

include/SFML/Graphics/RenderTexture.hpp

@@ -73,7 +73,7 @@ public:
     /// doing anything with the render-texture.
     /// The last parameter, \a depthBuffer, is useful if you want
     /// to use the render-texture for 3D OpenGL rendering that requires
-    /// a depth-buffer. Otherwise it is unnecessary, and you should
+    /// a depth buffer. Otherwise it is unnecessary, and you should
     /// leave this parameter to false (which is its default value).
     ///
     /// \param width       Width of the render-texture

include/SFML/Graphics/Text.hpp

@@ -193,7 +193,7 @@ public:
     /// \brief Get the text's font
     ///
     /// If the text has no font attached, a NULL pointer is returned.
-    /// The returned reference is const, which means that you
+    /// The returned pointer is const, which means that you
     /// cannot modify the font when you get it from this function.
     ///
     /// \return Pointer to the text's font

include/SFML/Network/Http.hpp

@@ -85,7 +85,7 @@ public:
         /// \brief Set the value of a field
         ///
         /// The field is created if it doesn't exist. The name of
-        /// the field is case insensitive.
+        /// the field is case-insensitive.
         /// By default, a request doesn't contain any field (but the
         /// mandatory fields are added later by the HTTP client when
         /// sending the request).

include/SFML/System/Thread.hpp

@@ -53,7 +53,7 @@ public:
     /// \brief Construct the thread from a functor with no argument
     ///
     /// This constructor works for function objects, as well
-    /// as free function.
+    /// as free functions.
     ///
     /// Use this constructor for this kind of function:
     /// \code
@@ -66,7 +66,7 @@ public:
     ///     void operator()();
     /// };
     /// \endcode
-    /// Note: this does *not* run the thread, use Launch().
+    /// Note: this does *not* run the thread, use launch().
     ///
     /// \param function Functor or free function to use as the entry point of the thread
     ///
@@ -78,7 +78,7 @@ public:
     /// \brief Construct the thread from a functor with an argument
     ///
     /// This constructor works for function objects, as well
-    /// as free function.
+    /// as free functions.
     /// It is a template, which means that the argument can
     /// have any type (int, std::string, void*, Toto, ...).
     ///
@@ -93,7 +93,7 @@ public:
     ///     void operator()(std::string arg);
     /// };
     /// \endcode
-    /// Note: this does *not* run the thread, use Launch().
+    /// Note: this does *not* run the thread, use launch().
     ///
     /// \param function Functor or free function to use as the entry point of the thread
     /// \param argument argument to forward to the function
@@ -105,7 +105,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Construct the thread from a member function and an object
     ///
-    /// This constructor is template, which means that you can
+    /// This constructor is a template, which means that you can
     /// use it with any class.
     /// Use this constructor for this kind of function:
     /// \code
@@ -116,7 +116,7 @@ public:
     ///     void function();
     /// };
     /// \endcode
-    /// Note: this does *not* run the thread, use Launch().
+    /// Note: this does *not* run the thread, use launch().
     ///
     /// \param function Entry point of the thread
     /// \param object Pointer to the object to use
@@ -128,7 +128,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Destructor
     ///
-    /// This destructor calls Wait(), so that the internal thread
+    /// This destructor calls wait(), so that the internal thread
     /// cannot survive after its sf::Thread instance is destroyed.
     ///
     ////////////////////////////////////////////////////////////

include/SFML/System/ThreadLocalPtr.hpp

@@ -45,7 +45,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor
     ///
-    /// \param value Optional value to initalize the variable
+    /// \param value Optional value to initialize the variable
     ///
     ////////////////////////////////////////////////////////////
     ThreadLocalPtr(T* value = NULL);
@@ -54,9 +54,9 @@ public:
     /// \brief Overload of unary operator *
     ///
     /// Like raw pointers, applying the * operator returns a
-    /// reference to the pointed object.
+    /// reference to the pointed-to object.
     ///
-    /// \return Reference to the pointed object
+    /// \return Reference to the thread-local variable
     ///
     ////////////////////////////////////////////////////////////
     T& operator *() const;
@@ -64,16 +64,16 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Overload of operator ->
     ///
-    /// Like raw pointers, applying the -> operator returns the
+    /// Similarly to raw pointers, applying the -> operator
-    /// pointed object.
+    /// returns the pointed-to object.
     ///
-    /// \return Pointed object
+    /// \return Pointer to the thread-local variable
     ///
     ////////////////////////////////////////////////////////////
     T* operator ->() const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Cast operator to implicitly convert the
+    /// \brief Conversion operator to implicitly convert the
     ///        pointer to its raw pointer type (T*)
     ///
     /// \return Pointer to the actual object
@@ -117,7 +117,7 @@ public:
 /// sf::ThreadLocalPtr is a type-safe wrapper for storing
 /// pointers to thread-local variables. A thread-local
 /// variable holds a different value for each different
-/// thread, unlike normal variable that are shared.
+/// thread, unlike normal variables that are shared.
 ///
 /// Its usage is completely transparent, so that it is similar
 /// to manipulating the raw pointer directly (like any smart pointer).

include/SFML/Window/Joystick.hpp

@@ -159,7 +159,7 @@ public:
     /// This function is used internally by SFML, so you normally
     /// don't have to call it explicitly. However, you may need to
     /// call it if you have no window yet (or no window at all):
-    /// in this case the joysticks states are not updated automatically.
+    /// in this case the joystick states are not updated automatically.
     ///
     ////////////////////////////////////////////////////////////
     static void update();

src/SFML/Graphics/RenderTextureImplDefault.hpp

@@ -39,7 +39,7 @@ namespace priv
 {
 ////////////////////////////////////////////////////////////
 /// \brief Default specialization of RenderTextureImpl,
-///        using a in-memory context
+///        using an in-memory context
 ///
 ////////////////////////////////////////////////////////////
 class RenderTextureImplDefault : public RenderTextureImpl, GlResource