Replace tabs with spaces

doc/doxyfile.in

@@ -835,7 +835,7 @@ INPUT_ENCODING         = UTF-8
 # *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf and *.qsf.
 
 FILE_PATTERNS          = *.h \
-						 *.hpp
+                         *.hpp
 
 # The RECURSIVE tag can be used to specify whether or not subdirectories should
 # be searched for input files as well.

include/SFML/Window/Context.h

@@ -76,7 +76,7 @@ CSFML_WINDOW_API sfBool sfContext_setActive(sfContext* context, sfBool active);
 ////////////////////////////////////////////////////////////
 /// \brief Get the address of an OpenGL function.
 ///
-/// \param name	Name of the function to get the address of
+/// \param name Name of the function to get the address of
 ///
 /// \return Address of the OpenGL function, 0 on failure
 ///

include/SFML/Window/WindowHandle.h

@@ -49,7 +49,7 @@
 #elif defined(CSFML_SYSTEM_MACOS)
 
     // Window handle is NSWindow (void*) on Mac OS X - Cocoa
-	typedef void* sfWindowHandle;
+    typedef void* sfWindowHandle;
 
 #endif
 

src/SFML/Graphics/Shader.cpp

@@ -193,277 +193,277 @@ sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, sfInputSt
 ////////////////////////////////////////////////////////////
 void sfShader_destroy(sfShader* shader)
 {
-	delete shader;
+    delete shader;
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setFloatUniform(sfShader* shader, const char* name, float x)
 {
-	CSFML_CALL(shader, setUniform(name, x));
+    CSFML_CALL(shader, setUniform(name, x));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVec2Uniform(sfShader* shader, const char* name, sfGlslVec2 vector)
 {
-	CSFML_CALL(shader, setUniform(name, sf::Glsl::Vec2(vector.x, vector.y)));
+    CSFML_CALL(shader, setUniform(name, sf::Glsl::Vec2(vector.x, vector.y)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVec3Uniform(sfShader* shader, const char* name, sfGlslVec3 vector)
 {
-	CSFML_CALL(shader, setUniform(name, sf::Glsl::Vec3(vector.x, vector.y, vector.z)));
+    CSFML_CALL(shader, setUniform(name, sf::Glsl::Vec3(vector.x, vector.y, vector.z)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVec4Uniform(sfShader* shader, const char* name, sfGlslVec4 vector)
 {
-	CSFML_CALL(shader, setUniform(name, sf::Glsl::Vec4(vector.x, vector.y, vector.z, vector.w)));
+    CSFML_CALL(shader, setUniform(name, sf::Glsl::Vec4(vector.x, vector.y, vector.z, vector.w)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setColorUniform(sfShader* shader, const char* name, sfColor color)
 {
-	sfGlslVec4 vec4;
+    sfGlslVec4 vec4;
-	vec4.x = color.r / 255.f;
+    vec4.x = color.r / 255.f;
-	vec4.y = color.g / 255.f;
+    vec4.y = color.g / 255.f;
-	vec4.z = color.b / 255.f;
+    vec4.z = color.b / 255.f;
-	vec4.w = color.a / 255.f;
+    vec4.w = color.a / 255.f;
 
-	sfShader_setVec4Uniform(shader, name, vec4);
+    sfShader_setVec4Uniform(shader, name, vec4);
 }
 
 ////////////////////////////////////////////////////////////
 void sfShader_setIntUniform(sfShader* shader, const char* name, int x)
 {
-	CSFML_CALL(shader, setUniform(name, x));
+    CSFML_CALL(shader, setUniform(name, x));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setIvec2Uniform(sfShader* shader, const char* name, sfGlslIvec2 vector)
 {
-	CSFML_CALL(shader, setUniform(name, sf::Glsl::Ivec2(vector.x, vector.y)));
+    CSFML_CALL(shader, setUniform(name, sf::Glsl::Ivec2(vector.x, vector.y)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setIvec3Uniform(sfShader* shader, const char* name, sfGlslIvec3 vector)
 {
-	CSFML_CALL(shader, setUniform(name, sf::Glsl::Ivec3(vector.x, vector.y, vector.z)));
+    CSFML_CALL(shader, setUniform(name, sf::Glsl::Ivec3(vector.x, vector.y, vector.z)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setIvec4Uniform(sfShader* shader, const char* name, sfGlslIvec4 vector)
 {
-	CSFML_CALL(shader, setUniform(name, sf::Glsl::Ivec4(vector.x, vector.y, vector.z, vector.w)));
+    CSFML_CALL(shader, setUniform(name, sf::Glsl::Ivec4(vector.x, vector.y, vector.z, vector.w)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setIntColorUniform(sfShader* shader, const char* name, sfColor color)
 {
-	sfGlslIvec4 ivec4;
+    sfGlslIvec4 ivec4;
-	ivec4.x = static_cast<int>(color.r);
+    ivec4.x = static_cast<int>(color.r);
-	ivec4.y = static_cast<int>(color.g);
+    ivec4.y = static_cast<int>(color.g);
-	ivec4.z = static_cast<int>(color.b);
+    ivec4.z = static_cast<int>(color.b);
-	ivec4.w = static_cast<int>(color.a);
+    ivec4.w = static_cast<int>(color.a);
 
-	sfShader_setIvec4Uniform(shader, name, ivec4);
+    sfShader_setIvec4Uniform(shader, name, ivec4);
 }
 
 ////////////////////////////////////////////////////////////
 void sfShader_setBoolUniform(sfShader* shader, const char* name, sfBool x)
 {
-	CSFML_CALL(shader, setUniform(name, x != sfFalse));
+    CSFML_CALL(shader, setUniform(name, x != sfFalse));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setBvec2Uniform(sfShader* shader, const char* name, sfGlslBvec2 vector)
 {
-	CSFML_CALL(shader, setUniform(name, sf::Glsl::Bvec2(vector.x != sfFalse, vector.y != sfFalse)));
+    CSFML_CALL(shader, setUniform(name, sf::Glsl::Bvec2(vector.x != sfFalse, vector.y != sfFalse)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setBvec3Uniform(sfShader* shader, const char* name, sfGlslBvec3 vector)
 {
-	CSFML_CALL(shader, setUniform(name, sf::Glsl::Bvec3(vector.x != sfFalse, vector.y != sfFalse, vector.z != sfFalse)));
+    CSFML_CALL(shader, setUniform(name, sf::Glsl::Bvec3(vector.x != sfFalse, vector.y != sfFalse, vector.z != sfFalse)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setBvec4Uniform(sfShader* shader, const char* name, sfGlslBvec4 vector)
 {
-	CSFML_CALL(shader, setUniform(name, sf::Glsl::Bvec4(vector.x != sfFalse, vector.y != sfFalse, vector.z != sfFalse, vector.w != sfFalse)));
+    CSFML_CALL(shader, setUniform(name, sf::Glsl::Bvec4(vector.x != sfFalse, vector.y != sfFalse, vector.z != sfFalse, vector.w != sfFalse)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setMat3Uniform(sfShader* shader, const char* name, const sfGlslMat3* matrix)
 {
-	CSFML_CALL(shader, setUniform(name, sf::Glsl::Mat3(matrix->array)));
+    CSFML_CALL(shader, setUniform(name, sf::Glsl::Mat3(matrix->array)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setMat4Uniform(sfShader* shader, const char* name, const sfGlslMat4* matrix)
 {
-	CSFML_CALL(shader, setUniform(name, sf::Glsl::Mat4(matrix->array)));
+    CSFML_CALL(shader, setUniform(name, sf::Glsl::Mat4(matrix->array)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setTextureUniform(sfShader* shader, const char* name, const sfTexture* texture)
 {
-	CSFML_CALL(shader, setUniform(name, *texture->This));
+    CSFML_CALL(shader, setUniform(name, *texture->This));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setCurrentTextureUniform(sfShader* shader, const char* name)
 {
-	CSFML_CALL(shader, setUniform(name, sf::Shader::CurrentTexture));
+    CSFML_CALL(shader, setUniform(name, sf::Shader::CurrentTexture));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setFloatUniformArray(sfShader* shader, const char* name, const float* scalarArray, size_t length)
 {
-	CSFML_CALL(shader, setUniformArray(name, scalarArray, length));
+    CSFML_CALL(shader, setUniformArray(name, scalarArray, length));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVec2UniformArray(sfShader* shader, const char* name, const sfGlslVec2* vectorArray, size_t length)
 {
-	CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Vec2*>(vectorArray), length));
+    CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Vec2*>(vectorArray), length));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVec3UniformArray(sfShader* shader, const char* name, const sfGlslVec3* vectorArray, size_t length)
 {
-	CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Vec3*>(vectorArray), length));
+    CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Vec3*>(vectorArray), length));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVec4UniformArray(sfShader* shader, const char* name, const sfGlslVec4* vectorArray, size_t length)
 {
-	CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Vec4*>(vectorArray), length));
+    CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Vec4*>(vectorArray), length));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setMat3UniformArray(sfShader* shader, const char* name, const sfGlslMat3* matrixArray, size_t length)
 {
-	CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Mat3*>(matrixArray), length));
+    CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Mat3*>(matrixArray), length));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setMat4UniformArray(sfShader* shader, const char* name, const sfGlslMat4* matrixArray, size_t length)
 {
-	CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Mat4*>(matrixArray), length));
+    CSFML_CALL(shader, setUniformArray(name, reinterpret_cast<const sf::Glsl::Mat4*>(matrixArray), length));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setFloatParameter(sfShader* shader, const char* name, float x)
 {
-	CSFML_CALL(shader, setParameter(name, x));
+    CSFML_CALL(shader, setParameter(name, x));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setFloat2Parameter(sfShader* shader, const char* name, float x, float y)
 {
-	CSFML_CALL(shader, setParameter(name, x, y));
+    CSFML_CALL(shader, setParameter(name, x, y));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setFloat3Parameter(sfShader* shader, const char* name, float x, float y, float z)
 {
-	CSFML_CALL(shader, setParameter(name, x, y, z));
+    CSFML_CALL(shader, setParameter(name, x, y, z));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setFloat4Parameter(sfShader* shader, const char* name, float x, float y, float z, float w)
 {
-	CSFML_CALL(shader, setParameter(name, x, y, z, w));
+    CSFML_CALL(shader, setParameter(name, x, y, z, w));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVector2Parameter(sfShader* shader, const char* name, sfVector2f vector)
 {
-	CSFML_CALL(shader, setParameter(name, sf::Vector2f(vector.x, vector.y)));
+    CSFML_CALL(shader, setParameter(name, sf::Vector2f(vector.x, vector.y)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setVector3Parameter(sfShader* shader, const char* name, sfVector3f vector)
 {
-	CSFML_CALL(shader, setParameter(name, sf::Vector3f(vector.x, vector.y, vector.z)));
+    CSFML_CALL(shader, setParameter(name, sf::Vector3f(vector.x, vector.y, vector.z)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setColorParameter(sfShader* shader, const char* name, sfColor color)
 {
-	CSFML_CALL(shader, setParameter(name, sf::Color(color.r, color.g, color.b, color.a)));
+    CSFML_CALL(shader, setParameter(name, sf::Color(color.r, color.g, color.b, color.a)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setTransformParameter(sfShader* shader, const char* name, sfTransform transform)
 {
-	CSFML_CALL(shader, setParameter(name, convertTransform(transform)));
+    CSFML_CALL(shader, setParameter(name, convertTransform(transform)));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setTextureParameter(sfShader* shader, const char* name, const sfTexture* texture)
 {
-	CSFML_CHECK(texture);
+    CSFML_CHECK(texture);
-	CSFML_CALL(shader, setParameter(name,*texture->This));
+    CSFML_CALL(shader, setParameter(name,*texture->This));
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_setCurrentTextureParameter(sfShader* shader, const char* name)
 {
-	CSFML_CALL(shader, setParameter(name, sf::Shader::CurrentTexture));
+    CSFML_CALL(shader, setParameter(name, sf::Shader::CurrentTexture));
 }
 
 
 ////////////////////////////////////////////////////////////
 unsigned int sfShader_getNativeHandle(const sfShader* shader)
 {
-	CSFML_CALL_RETURN(shader, getNativeHandle(), 0);
+    CSFML_CALL_RETURN(shader, getNativeHandle(), 0);
 }
 
 
 ////////////////////////////////////////////////////////////
 void sfShader_bind(const sfShader* shader)
 {
-	sf::Shader::bind(shader ? &shader->This : NULL);
+    sf::Shader::bind(shader ? &shader->This : NULL);
 }
 
 
 ////////////////////////////////////////////////////////////
 sfBool sfShader_isAvailable(void)
 {
-	return sf::Shader::isAvailable() ? sfTrue : sfFalse;
+    return sf::Shader::isAvailable() ? sfTrue : sfFalse;
 }