Fix whitespace: Convert tabs to spaces and remove trailing whitespace.

include/SFML/Audio.hpp

@@ -52,5 +52,5 @@
 ///
 /// Sounds, streaming (musics or custom sources), recording,
 /// spatialization.
-/// 
+///
 ////////////////////////////////////////////////////////////

include/SFML/Audio/Listener.hpp

@@ -210,7 +210,7 @@ public:
 /// audio environment, it defines where and how sounds and musics
 /// are heard. If sf::View is the eyes of the user, then sf::Listener
 /// is his ears (by the way, they are often linked together --
-/// same position, orientation, etc.). 
+/// same position, orientation, etc.).
 ///
 /// sf::Listener is a simple interface, which allows to setup the
 /// listener in the 3D audio environment (position, direction and

include/SFML/Graphics/BlendMode.hpp

@@ -146,7 +146,7 @@ SFML_GRAPHICS_API bool operator !=(const BlendMode& left, const BlendMode& right
 ////////////////////////////////////////////////////////////
 // Commonly used blending modes
 ////////////////////////////////////////////////////////////
-SFML_GRAPHICS_API extern const BlendMode BlendAlpha;    ///< Blend source and dest according to dest alpha 
+SFML_GRAPHICS_API extern const BlendMode BlendAlpha;    ///< Blend source and dest according to dest alpha
 SFML_GRAPHICS_API extern const BlendMode BlendAdd;      ///< Add source to dest
 SFML_GRAPHICS_API extern const BlendMode BlendMultiply; ///< Multiply source and dest
 SFML_GRAPHICS_API extern const BlendMode BlendNone;     ///< Overwrite dest with source
@@ -164,7 +164,7 @@ SFML_GRAPHICS_API extern const BlendMode BlendNone;     ///< Overwrite dest with
 /// sf::BlendMode is a class that represents a blend mode. A blend
 /// mode determines how the colors of an object you draw are
 /// mixed with the colors that are already in the buffer.
-/// 
+///
 /// The class is composed of 6 components, each of which has its
 /// own public member variable:
 /// \li %Color Source Factor (@ref colorSrcFactor)
@@ -173,7 +173,7 @@ SFML_GRAPHICS_API extern const BlendMode BlendNone;     ///< Overwrite dest with
 /// \li Alpha Source Factor (@ref alphaSrcFactor)
 /// \li Alpha Destination Factor (@ref alphaDstFactor)
 /// \li Alpha Blend Equation (@ref alphaEquation)
-/// 
+///
 /// The source factor specifies how the pixel you are drawing contributes
 /// to the final color. The destination factor specifies how the pixel
 /// already drawn in the buffer contributes to the final color.

include/SFML/Graphics/Color.hpp

@@ -68,7 +68,7 @@ public:
     ///
     ////////////////////////////////////////////////////////////
     explicit Color(Uint32 color);
-    
+
     ////////////////////////////////////////////////////////////
     /// \brief Retrieve the color as a 32-bit unsigned integer
     ///

include/SFML/Graphics/Sprite.hpp

@@ -262,7 +262,7 @@ private:
 /// // Declare and load a texture
 /// sf::Texture texture;
 /// texture.loadFromFile("texture.png");
-/// 
+///
 /// // Create a sprite
 /// sf::Sprite sprite;
 /// sprite.setTexture(texture);

include/SFML/Graphics/Text.hpp

@@ -291,7 +291,7 @@ private:
 
     ////////////////////////////////////////////////////////////
     /// \brief Make sure the text's geometry is updated
-    /// 
+    ///
     /// All the attributes related to rendering are cached, such
     /// that the geometry is only updated when necessary.
     ///
@@ -356,7 +356,7 @@ private:
 /// // Declare and load a font
 /// sf::Font font;
 /// font.loadFromFile("arial.ttf");
-/// 
+///
 /// // Create a text
 /// sf::Text text("hello", font);
 /// text.setCharacterSize(30);

include/SFML/Graphics/Transformable.hpp

@@ -413,7 +413,7 @@ private:
 /// \endcode
 ///
 /// A note on coordinates and undistorted rendering: \n
-/// By default, SFML (or more exactly, OpenGL) may interpolate drawable objects  
+/// By default, SFML (or more exactly, OpenGL) may interpolate drawable objects
 /// such as sprites or texts when rendering. While this allows transitions
 /// like slow movements or rotations to appear smoothly, it can lead to
 /// unwanted results in some cases, for example blurred or distorted objects.
@@ -423,7 +423,7 @@ private:
 /// * The object's position, origin and scale have no fractional part
 /// * The object's and the view's rotation are a multiple of 90 degrees
 /// * The view's center and size have no fractional part
-/// 
+///
 /// \see sf::Transform
 ///
 ////////////////////////////////////////////////////////////

include/SFML/Graphics/View.hpp

@@ -313,7 +313,7 @@ private:
 /// \code
 /// sf::RenderWindow window;
 /// sf::View view;
-/// 
+///
 /// // Initialize the view to a rectangle located at (100, 100) and with a size of 400x200
 /// view.reset(sf::FloatRect(100, 100, 400, 200));
 ///

include/SFML/Network/UdpSocket.hpp

@@ -207,7 +207,7 @@ private:
 /// stream of data (TCP). Therefore, one call to send will always
 /// match one call to receive (if the datagram is not lost),
 /// with the same data that was sent.
-/// 
+///
 /// The UDP protocol is lightweight but unreliable. Unreliable
 /// means that datagrams may be duplicated, be lost or
 /// arrive reordered. However, if a datagram arrives, its

include/SFML/System.hpp

@@ -56,5 +56,5 @@
 /// Base module of SFML, defining various utilities. It provides
 /// vector classes, Unicode strings and conversion functions,
 /// threads and mutexes, timing classes.
-/// 
+///
 ////////////////////////////////////////////////////////////

include/SFML/System/Lock.hpp

@@ -94,16 +94,16 @@ private:
 /// Usage example:
 /// \code
 /// sf::Mutex mutex;
-/// 
+///
 /// void function()
 /// {
 ///     sf::Lock lock(mutex); // mutex is now locked
-/// 
+///
 ///     functionThatMayThrowAnException(); // mutex is unlocked if this function throws
-/// 
+///
 ///     if (someCondition)
 ///         return; // mutex is unlocked
-/// 
+///
 /// } // mutex is unlocked
 /// \endcode
 ///
@@ -116,15 +116,15 @@ private:
 ///
 /// \code
 /// sf::Mutex mutex;
-/// 
+///
 /// void function()
 /// {
 ///     {
 ///       sf::Lock lock(mutex);
 ///       codeThatRequiresProtection();
-/// 
+///
 ///     } // mutex is unlocked here
-/// 
+///
 ///     codeThatDoesntCareAboutTheMutex();
 /// }
 /// \endcode

include/SFML/System/Mutex.hpp

@@ -119,7 +119,7 @@ private:
 ///     database.write(...);
 ///     mutex.unlock(); // if thread2 was waiting, it will now be unblocked
 /// }
-/// 
+///
 /// void thread2()
 /// {
 ///     mutex.lock(); // this call will block the thread if the mutex is already locked by thread1

include/SFML/Window/Event.hpp

@@ -174,10 +174,10 @@ public:
     ////////////////////////////////////////////////////////////
     struct SensorEvent
     {
-		Sensor::Type type; ///< Type of the sensor
-		float x;           ///< Current value of the sensor on X axis
-		float y;           ///< Current value of the sensor on Y axis
-		float z;           ///< Current value of the sensor on Z axis
+        Sensor::Type type; ///< Type of the sensor
+        float x;           ///< Current value of the sensor on X axis
+        float y;           ///< Current value of the sensor on Y axis
+        float z;           ///< Current value of the sensor on Z axis
     };
 
     ////////////////////////////////////////////////////////////

include/SFML/Window/Sensor.hpp

@@ -72,7 +72,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Enable or disable a sensor
     ///
-    /// All sensors are disabled by default, to avoid consuming too 
+    /// All sensors are disabled by default, to avoid consuming too
     /// much battery power. Once a sensor is enabled, it starts
     /// sending events of the corresponding type.
     ///