Fixed a few typos/style issues

include/SFML/Audio/InputSoundFile.hpp

@@ -45,7 +45,7 @@ class SoundFileReader;
 ////////////////////////////////////////////////////////////
 class SFML_AUDIO_API InputSoundFile : NonCopyable
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor
@@ -161,7 +161,7 @@ public :
     ////////////////////////////////////////////////////////////
     /// \brief Change the current read position to the given time offset
     ///
-    /// Using a time offset is handy but unprecise. If you need an accurate
+    /// Using a time offset is handy but imprecise. If you need an accurate
     /// result, consider using the overload which takes a sample offset.
     ///
     /// If the given time exceeds to total duration, this function jumps
@@ -227,10 +227,10 @@ private:
 ///     /* error */;
 ///
 /// // Print the sound attributes
-/// std::cout << "duration: " << file.getDuration().asSeconds() << std::endl; 
-/// std::cout << "channels: " << file.getChannelCount() << std::endl; 
-/// std::cout << "sample rate: " << file.getSampleRate() << std::endl; 
-/// std::cout << "sample count: " << file.getSampleCount() << std::endl; 
+/// std::cout << "duration: " << file.getDuration().asSeconds() << std::endl;
+/// std::cout << "channels: " << file.getChannelCount() << std::endl;
+/// std::cout << "sample rate: " << file.getSampleRate() << std::endl;
+/// std::cout << "sample count: " << file.getSampleCount() << std::endl;
 ///
 /// // Read and process batches of samples until the end of file is reached
 /// sf::Int16 samples[1024];
@@ -239,7 +239,7 @@ private:
 /// {
 ///     count = file.read(samples, 1024);
 ///
-///     // process, analyse, play, convert, or whatever
+///     // process, analyze, play, convert, or whatever
 ///     // you want to do with the samples...
 /// }
 /// while (count > 0);

include/SFML/Audio/Music.hpp

@@ -47,7 +47,7 @@ class InputStream;
 ////////////////////////////////////////////////////////////
 class SFML_AUDIO_API Music : public SoundStream
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor
@@ -87,7 +87,7 @@ public :
     /// of supported formats.
     /// 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
@@ -109,7 +109,7 @@ public :
     /// of supported formats.
     /// 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
@@ -129,7 +129,7 @@ public :
     ////////////////////////////////////////////////////////////
     Time getDuration() const;
 
-protected :
+protected:
 
     ////////////////////////////////////////////////////////////
     /// \brief Request a new chunk of audio samples from the stream source
@@ -152,7 +152,7 @@ protected :
     ////////////////////////////////////////////////////////////
     virtual void onSeek(Time timeOffset);
 
-private :
+private:
 
     ////////////////////////////////////////////////////////////
     /// \brief Initialize the internal state after loading a new music

include/SFML/Audio/OutputSoundFile.hpp

@@ -43,7 +43,7 @@ class SoundFileWriter;
 ////////////////////////////////////////////////////////////
 class SFML_AUDIO_API OutputSoundFile : NonCopyable
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor

include/SFML/Audio/SoundBuffer.hpp

@@ -48,7 +48,7 @@ class InputStream;
 ////////////////////////////////////////////////////////////
 class SFML_AUDIO_API SoundBuffer : AlResource
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor
@@ -223,7 +223,7 @@ public :
     ////////////////////////////////////////////////////////////
     SoundBuffer& operator =(const SoundBuffer& right);
 
-private :
+private:
 
     friend class Sound;
 
@@ -232,7 +232,7 @@ private :
     ///
     /// \param file Sound file providing access to the new loaded sound
     ///
-    /// \return True on succesful initialization, false on failure
+    /// \return True on successful initialization, false on failure
     ///
     ////////////////////////////////////////////////////////////
     bool initialize(InputSoundFile& file);
@@ -291,7 +291,7 @@ private :
 /// A sound buffer holds the data of a sound, which is
 /// an array of audio samples. A sample is a 16 bits signed integer
 /// that defines the amplitude of the sound at a given time.
-/// The sound is then restituted by playing these samples at
+/// The sound is then reconstituted by playing these samples at
 /// a high rate (for example, 44100 samples per second is the
 /// standard rate used for playing CDs). In short, audio samples
 /// are like texture pixels, and a sf::SoundBuffer is similar to
@@ -324,20 +324,20 @@ private :
 /// \code
 /// // Declare a new sound buffer
 /// sf::SoundBuffer buffer;
-/// 
+///
 /// // Load it from a file
 /// if (!buffer.loadFromFile("sound.wav"))
 /// {
 ///     // error...
 /// }
-/// 
+///
 /// // Create a sound source and bind it to the buffer
 /// sf::Sound sound1;
 /// sound1.setBuffer(buffer);
-/// 
+///
 /// // Play the sound
 /// sound1.play();
-/// 
+///
 /// // Create another sound source bound to the same buffer
 /// sf::Sound sound2;
 /// sound2.setBuffer(buffer);

include/SFML/Audio/SoundFileFactory.hpp

@@ -40,12 +40,12 @@ class SoundFileReader;
 class SoundFileWriter;
 
 ////////////////////////////////////////////////////////////
-/// \brief Manages and instanciates sound file readers and writers
+/// \brief Manages and instantiates sound file readers and writers
 ///
 ////////////////////////////////////////////////////////////
 class SFML_AUDIO_API SoundFileFactory
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Register a new reader
@@ -84,7 +84,9 @@ public :
     static void unregisterWriter();
 
     ////////////////////////////////////////////////////////////
-    /// \brief Instanciate the right reader for the given file on disk
+    /// \brief Instantiate the right reader for the given file on disk
+    ///
+    /// It's up to the caller to release the returned reader
     ///
     /// \param filename Path of the sound file
     ///
@@ -96,7 +98,9 @@ public :
     static SoundFileReader* createReaderFromFilename(const std::string& filename);
 
     ////////////////////////////////////////////////////////////
-    /// \brief Instanciate the right codec for the given file in memory
+    /// \brief Instantiate the right codec for the given file in memory
+    ///
+    /// It's up to the caller to release the returned reader
     ///
     /// \param data        Pointer to the file data in memory
     /// \param sizeInBytes Total size of the file data, in bytes
@@ -109,7 +113,9 @@ public :
     static SoundFileReader* createReaderFromMemory(const void* data, std::size_t sizeInBytes);
 
     ////////////////////////////////////////////////////////////
-    /// \brief Instanciate the right codec for the given file in stream
+    /// \brief Instantiate the right codec for the given file in stream
+    ///
+    /// It's up to the caller to release the returned reader
     ///
     /// \param stream Source stream to read from
     ///
@@ -121,7 +127,9 @@ public :
     static SoundFileReader* createReaderFromStream(InputStream& stream);
 
     ////////////////////////////////////////////////////////////
-    /// \brief Instanciate the right writer for the given file on disk
+    /// \brief Instantiate the right writer for the given file on disk
+    ///
+    /// It's up to the caller to release the returned writer
     ///
     /// \param filename Path of the sound file
     ///
@@ -168,7 +176,7 @@ private:
 /// \ingroup audio
 ///
 /// This class is where all the sound file readers and writers are
-/// registered. You should normally only need to use its regitration
+/// registered. You should normally only need to use its registration
 /// and unregistration functions; readers/writers creation and manipulation
 /// are wrapped into the higher-level classes sf::InputSoundFile and
 /// sf::OutputSoundFile.

include/SFML/Audio/SoundFileReader.hpp

@@ -42,7 +42,7 @@ class InputStream;
 ////////////////////////////////////////////////////////////
 class SFML_AUDIO_API SoundFileReader
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Structure holding the audio properties of a sound file

include/SFML/Audio/SoundFileWriter.hpp

@@ -40,7 +40,7 @@ namespace sf
 ////////////////////////////////////////////////////////////
 class SFML_AUDIO_API SoundFileWriter
 {
-public :
+public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Virtual destructor