Merge branch 'bugfix/doc_n_spaces'

cmake/Macros.cmake

@@ -59,7 +59,7 @@ macro(sfml_add_library target)
     endif()
 
     # if using gcc >= 4.0 or clang >= 3.0 on a non-Windows platform, we must hide public symbols by default
-    # (exported ones are explicitely marked)
+    # (exported ones are explicitly marked)
     if(NOT SFML_OS_WINDOWS AND ((SFML_COMPILER_GCC AND NOT SFML_GCC_VERSION VERSION_LESS "4") OR (SFML_COMPILER_CLANG AND NOT SFML_CLANG_VERSION VERSION_LESS "3")))
         set_target_properties(${target} PROPERTIES COMPILE_FLAGS -fvisibility=hidden)
     endif()

cmake/Modules/FindSFML.cmake

@@ -10,7 +10,7 @@
 #   find_package(SFML COMPONENTS graphics window system) // find the graphics, window and system modules
 #
 # You can enforce a specific version, either MAJOR.MINOR or only MAJOR.
-# If nothing is specified, the version won't be checked (ie. any version will be accepted).
+# If nothing is specified, the version won't be checked (i.e. any version will be accepted).
 # example:
 #   find_package(SFML COMPONENTS ...)     // no specific version required
 #   find_package(SFML 2 COMPONENTS ...)   // any 2.x version

examples/cocoa/NSString+stdstring.mm

@@ -64,7 +64,7 @@
 
 -(std::wstring)tostdwstring
 {
-    // According to wikipedia, Mac OS X is Little Endian on x86 and x86-64
+    // According to Wikipedia, Mac OS X is Little Endian on x86 and x86-64
     // http://en.wikipedia.org/wiki/Endianness
     NSData* asData = [self dataUsingEncoding:NSUTF32LittleEndianStringEncoding];
     return std::wstring((wchar_t*)[asData bytes], [asData length] / sizeof(wchar_t));

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/SoundRecorder.hpp

@@ -96,10 +96,10 @@ public:
     unsigned int getSampleRate() const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Get a list of the names of all availabe audio capture devices
+    /// \brief Get a list of the names of all available audio capture devices
     ///
     /// This function returns a vector of strings, containing
-    /// the names of all availabe audio capture devices.
+    /// the names of all available audio capture devices.
     ///
     /// \return A vector of strings containing the names
     ///
@@ -187,7 +187,7 @@ protected:
     ////////////////////////////////////////////////////////////
     /// \brief Start capturing audio data
     ///
-    /// This virtual function may be overriden by a derived class
+    /// This virtual function may be overridden by a derived class
     /// if something has to be done every time a new capture
     /// starts. If not, this function can be ignored; the default
     /// implementation does nothing.
@@ -216,7 +216,7 @@ protected:
     ////////////////////////////////////////////////////////////
     /// \brief Stop capturing audio data
     ///
-    /// This virtual function may be overriden by a derived class
+    /// This virtual function may be overridden by a derived class
     /// if something has to be done every time the capture
     /// ends. If not, this function can be ignored; the default
     /// implementation does nothing.
@@ -285,7 +285,7 @@ private:
 /// A derived class has only one virtual function to override:
 /// \li onProcessSamples provides the new chunks of audio samples while the capture happens
 ///
-/// Moreover, two additionnal virtual functions can be overriden
+/// Moreover, two additional virtual functions can be overridden
 /// as well if necessary:
 /// \li onStart is called before the capture happens, to perform custom initializations
 /// \li onStop is called after the capture ends, to perform custom cleanup
@@ -303,9 +303,9 @@ private:
 ///
 /// If you have multiple sound input devices connected to your
 /// computer (for example: microphone, external soundcard, webcam mic, ...)
-/// you can get a list of all available devices throught the
+/// you can get a list of all available devices through the
 /// getAvailableDevices() function. You can then select a device
-/// by calling setDevice() with the appropiate device. Otherwise
+/// by calling setDevice() with the appropriate device. Otherwise
 /// the default capturing device will be used.
 ///
 /// It is important to note that the audio capture happens in a

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).
@@ -244,7 +244,7 @@ protected:
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor
     ///
-    /// This constructor is meant ot be called by derived classes only.
+    /// This constructor is meant to be called by derived classes only.
     ///
     ////////////////////////////////////////////////////////////
     SoundSource();

include/SFML/Audio/SoundStream.hpp

@@ -207,7 +207,7 @@ protected:
     ////////////////////////////////////////////////////////////
     /// \brief Request a new chunk of audio samples from the stream source
     ///
-    /// This function must be overriden by derived classes to provide
+    /// This function must be overridden by derived classes to provide
     /// the audio samples to play. It is called continuously by the
     /// streaming loop, in a separate thread.
     /// The source can choose to stop the streaming loop at any time, by
@@ -226,7 +226,7 @@ protected:
     ////////////////////////////////////////////////////////////
     /// \brief Change the current playing position in the stream source
     ///
-    /// This function must be overriden by derived classes to
+    /// This function must be overridden by derived classes to
     /// allow random seeking into the stream source.
     ///
     /// \param timeOffset New playing position, relative to the beginning of the stream
@@ -313,7 +313,7 @@ private:
 /// Unlike audio buffers (see sf::SoundBuffer), audio streams
 /// are never completely loaded in memory. Instead, the audio
 /// data is acquired continuously while the stream is playing.
-/// This behaviour allows to play a sound with no loading delay,
+/// This behavior allows to play a sound with no loading delay,
 /// and keeps the memory consumption very low.
 ///
 /// Sound sources that need to be streamed are usually big files

include/SFML/Graphics/Color.hpp

@@ -34,7 +34,7 @@
 namespace sf
 {
 ////////////////////////////////////////////////////////////
-/// \brief Utility class for manpulating RGBA colors
+/// \brief Utility class for manipulating RGBA colors
 ///
 ////////////////////////////////////////////////////////////
 class SFML_GRAPHICS_API Color

include/SFML/Graphics/Glyph.hpp

@@ -51,7 +51,7 @@ public:
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    float     advance;     ///< Offset to move horizontically to the next character
+    float     advance;     ///< Offset to move horizontally to the next character
     FloatRect bounds;      ///< Bounding rectangle of the glyph, in coordinates relative to the baseline
     IntRect   textureRect; ///< Texture coordinates of the glyph inside the font's texture
 };

include/SFML/Graphics/Image.hpp

@@ -76,7 +76,7 @@ public:
     ///
     /// The \a pixel array is assumed to contain 32-bits RGBA pixels,
     /// and have the given \a width and \a height. If not, this is
-    /// an undefined behaviour.
+    /// an undefined behavior.
     /// If \a pixels is null, an empty image is created.
     ///
     /// \param width  Width of the image
@@ -203,7 +203,7 @@ public:
     ///
     /// This function doesn't check the validity of the pixel
     /// coordinates, using out-of-range values will result in
-    /// an undefined behaviour.
+    /// an undefined behavior.
     ///
     /// \param x     X coordinate of pixel to change
     /// \param y     Y coordinate of pixel to change
@@ -219,7 +219,7 @@ public:
     ///
     /// This function doesn't check the validity of the pixel
     /// coordinates, using out-of-range values will result in
-    /// an undefined behaviour.
+    /// an undefined behavior.
     ///
     /// \param x X coordinate of pixel to get
     /// \param y Y coordinate of pixel to get

include/SFML/Graphics/PrimitiveType.hpp

@@ -32,7 +32,7 @@ namespace sf
 /// \brief Types of primitives that a sf::VertexArray can render
 ///
 /// Points and lines have no area, therefore their thickness
-/// will always be 1 pixel, regarldess the current transform
+/// will always be 1 pixel, regardless the current transform
 /// and view.
 ///
 ////////////////////////////////////////////////////////////

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 instanciations 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/RenderStates.hpp

@@ -147,7 +147,7 @@ public:
 /// on top of each object's transform.
 ///
 /// Most objects, especially high-level drawables, can be drawn
-/// directly without defining render states explicitely -- the
+/// directly without defining render states explicitly -- the
 /// default set of states is ok in most cases.
 /// \code
 /// window.Draw(sprite);

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,
@@ -133,7 +133,7 @@ public:
     ///        coordinates, using the current view
     ///
     /// This function is an overload of the mapPixelToCoords
-    /// function that implicitely uses the current view.
+    /// function that implicitly uses the current view.
     /// It is equivalent to:
     /// \code
     /// target.mapPixelToCoords(point, target.getView());
@@ -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
@@ -184,7 +184,7 @@ public:
     ///        coordinates, using the current view
     ///
     /// This function is an overload of the mapCoordsToPixel
-    /// function that implicitely uses the current view.
+    /// function that implicitly uses the current view.
     /// It is equivalent to:
     /// \code
     /// target.mapCoordsToPixel(point, target.getView());
@@ -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
@@ -428,7 +428,7 @@ private:
 /// \class sf::RenderTarget
 /// \ingroup graphics
 ///
-/// sf::RenderTarget defines the common behaviour of all the
+/// sf::RenderTarget defines the common behavior of all the
 /// 2D render targets usable in the graphics module. It makes
 /// it possible to draw 2D entities like sprites, shapes, text
 /// without using any OpenGL command directly.

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/RenderWindow.hpp

@@ -59,7 +59,7 @@ public:
     ///
     /// This constructor creates the window with the size and pixel
     /// depth defined in \a mode. An optional style can be passed to
-    /// customize the look and behaviour of the window (borders,
+    /// customize the look and behavior of the window (borders,
     /// title bar, resizable, closable, ...).
     ///
     /// The fourth parameter is an optional structure specifying

include/SFML/Graphics/Shape.hpp

@@ -59,7 +59,7 @@ public:
     /// doesn't store its own copy of the texture, but rather keeps
     /// a pointer to the one that you passed to this function.
     /// If the source texture is destroyed and the shape tries to
-    /// use it, the behaviour is undefined.
+    /// use it, the behavior is undefined.
     /// \a texture can be NULL to disable texturing.
     /// If \a resetRect is true, the TextureRect property of
     /// the shape is automatically adjusted to the size of the new
@@ -252,7 +252,7 @@ protected:
     /// \brief Recompute the internal geometry of the shape
     ///
     /// This function must be called by the derived class everytime
-    /// the shape's points change (ie. the result of either
+    /// the shape's points change (i.e. the result of either
     /// getPointCount or getPoint is different).
     ///
     ////////////////////////////////////////////////////////////

include/SFML/Graphics/Sprite.hpp

@@ -85,7 +85,7 @@ public:
     /// doesn't store its own copy of the texture, but rather keeps
     /// a pointer to the one that you passed to this function.
     /// If the source texture is destroyed and the sprite tries to
-    /// use it, the behaviour is undefined.
+    /// use it, the behavior is undefined.
     /// If \a resetRect is true, the TextureRect property of
     /// the sprite is automatically adjusted to the size of the new
     /// texture. If it is false, the texture rect is left unchanged.

include/SFML/Graphics/Text.hpp

@@ -116,7 +116,7 @@ public:
     /// doesn't store its own copy of the font, but rather keeps
     /// a pointer to the one that you passed to this function.
     /// If the font is destroyed and the text tries to
-    /// use it, the behaviour is undefined.
+    /// use it, the behavior is undefined.
     ///
     /// \param font New font
     ///
@@ -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/Graphics/Texture.hpp

@@ -244,7 +244,7 @@ public:
     ///
     /// No additional check is performed on the size of the pixel
     /// array, passing invalid arguments will lead to an undefined
-    /// behaviour.
+    /// behavior.
     ///
     /// This function does nothing if \a pixels is null or if the
     /// texture was not previously created.
@@ -262,7 +262,7 @@ public:
     ///
     /// No additional check is performed on the size of the pixel
     /// array or the bounds of the area to update, passing invalid
-    /// arguments will lead to an undefined behaviour.
+    /// arguments will lead to an undefined behavior.
     ///
     /// This function does nothing if \a pixels is null or if the
     /// texture was not previously created.
@@ -286,7 +286,7 @@ public:
     ///
     /// No additional check is performed on the size of the image,
     /// passing an image bigger than the texture will lead to an
-    /// undefined behaviour.
+    /// undefined behavior.
     ///
     /// This function does nothing if the texture was not
     /// previously created.
@@ -301,7 +301,7 @@ public:
     ///
     /// No additional check is performed on the size of the image,
     /// passing an invalid combination of image size and offset
-    /// will lead to an undefined behaviour.
+    /// will lead to an undefined behavior.
     ///
     /// This function does nothing if the texture was not
     /// previously created.
@@ -323,7 +323,7 @@ public:
     ///
     /// No additional check is performed on the size of the window,
     /// passing a window bigger than the texture will lead to an
-    /// undefined behaviour.
+    /// undefined behavior.
     ///
     /// This function does nothing if either the texture or the window
     /// was not previously created.
@@ -338,7 +338,7 @@ public:
     ///
     /// No additional check is performed on the size of the window,
     /// passing an invalid combination of window size and offset
-    /// will lead to an undefined behaviour.
+    /// will lead to an undefined behavior.
     ///
     /// This function does nothing if either the texture or the window
     /// was not previously created.

include/SFML/Graphics/VertexArray.hpp

@@ -75,7 +75,7 @@ public:
     /// \brief Get a read-write access to a vertex by its index
     ///
     /// This function doesn't check \a index, it must be in range
-    /// [0, getVertexCount() - 1]. The behaviour is undefined
+    /// [0, getVertexCount() - 1]. The behavior is undefined
     /// otherwise.
     ///
     /// \param index Index of the vertex to get
@@ -91,7 +91,7 @@ public:
     /// \brief Get a read-only access to a vertex by its index
     ///
     /// This function doesn't check \a index, it must be in range
-    /// [0, getVertexCount() - 1]. The behaviour is undefined
+    /// [0, getVertexCount() - 1]. The behavior is undefined
     /// otherwise.
     ///
     /// \param index Index of the vertex to get

include/SFML/Network/Ftp.hpp

@@ -216,7 +216,7 @@ public:
 
     ////////////////////////////////////////////////////////////
     /// \brief Specialization of FTP response returning a
-    ///        filename lisiting
+    ///        filename listing
     ////////////////////////////////////////////////////////////
     class SFML_NETWORK_API ListingResponse : public Response
     {

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).
@@ -212,12 +212,12 @@ public:
             MultipleChoices  = 300, ///< The requested page can be accessed from several locations
             MovedPermanently = 301, ///< The requested page has permanently moved to a new location
             MovedTemporarily = 302, ///< The requested page has temporarily moved to a new location
-            NotModified      = 304, ///< For conditionnal requests, means the requested page hasn't changed and doesn't need to be refreshed
+            NotModified      = 304, ///< For conditional requests, means the requested page hasn't changed and doesn't need to be refreshed
 
             // 4xx: client error
             BadRequest          = 400, ///< The server couldn't understand the request (syntax error)
-            Unauthorized        = 401, ///< The requested page needs an authentification to be accessed
+            Unauthorized        = 401, ///< The requested page needs an authentication to be accessed
-            Forbidden           = 403, ///< The requested page cannot be accessed at all, even with authentification
+            Forbidden           = 403, ///< The requested page cannot be accessed at all, even with authentication
             NotFound            = 404, ///< The requested page doesn't exist
             RangeNotSatisfiable = 407, ///< The server can't satisfy the partial GET request (with a "Range" header field)
 
@@ -393,7 +393,7 @@ public:
     /// Warning: this function waits for the server's response and may
     /// not return instantly; use a thread if you don't want to block your
     /// application, or use a timeout to limit the time to wait. A value
-    /// of Time::Zero means that the client will use the system defaut timeout
+    /// of Time::Zero means that the client will use the system default timeout
     /// (which is usually pretty long).
     ///
     /// \param request Request to send

include/SFML/Network/Packet.hpp

@@ -139,7 +139,7 @@ public:
     /// A packet will be in an invalid state if it has no more
     /// data to read.
     ///
-    /// This behaviour is the same as standard C++ streams.
+    /// This behavior is the same as standard C++ streams.
     ///
     /// Usage example:
     /// \code
@@ -242,7 +242,7 @@ protected:
     ///
     /// This function can be defined by derived classes to
     /// transform the data after it is received; this can be
-    /// used for uncompression, decryption, etc.
+    /// used for decompression, decryption, etc.
     /// The function receives a pointer to the received data,
     /// and must fill the packet with the transformed bytes.
     /// The default implementation fills the packet directly
@@ -300,12 +300,12 @@ private:
 /// (sf::TcpSocket, sf::UdpSocket).
 ///
 /// Packets solve 2 fundamental problems that arise when
-/// transfering data over the network:
+/// transferring data over the network:
 /// \li data is interpreted correctly according to the endianness
 /// \li the bounds of the packet are preserved (one send == one receive)
 ///
 /// The sf::Packet class provides both input and output modes.
-/// It is designed to follow the behaviour of standard C++ streams,
+/// It is designed to follow the behavior of standard C++ streams,
 /// using operators >> and << to extract and insert data.
 ///
 /// It is recommended to use only fixed-size types (like sf::Int32, etc.),

include/SFML/Network/SocketSelector.hpp

@@ -188,7 +188,7 @@ private:
 /// (socket classes are not copyable anyway), it simply keeps
 /// a reference to the original sockets that you pass to the
 /// "add" function. Therefore, you can't use the selector as a
-/// socket container, you must store them oustide and make sure
+/// socket container, you must store them outside and make sure
 /// that they are alive as long as they are used in the selector.
 ///
 /// Using a selector is simple:

include/SFML/Network/TcpSocket.hpp

@@ -244,7 +244,7 @@ private:
 /// class to get more details about how they work.
 ///
 /// The socket is automatically disconnected when it is destroyed,
-/// but if you want to explicitely close the connection while
+/// but if you want to explicitly close the connection while
 /// the socket instance is still alive, you can call disconnect.
 ///
 /// Usage example:

include/SFML/Network/UdpSocket.hpp

@@ -235,7 +235,7 @@ private:
 ///
 /// If the socket is bound to a port, it is automatically
 /// unbound from it when the socket is destroyed. However,
-/// you can unbind the socket explicitely with the Unbind
+/// you can unbind the socket explicitly with the Unbind
 /// function if necessary, to stop receiving messages or
 /// make the port available for other sockets.
 ///

include/SFML/System.hpp

@@ -50,7 +50,7 @@
 /// \defgroup system System module
 ///
 /// Base module of SFML, defining various utilities. It provides
-/// vector classes, unicode strings and conversion functions,
+/// vector classes, Unicode strings and conversion functions,
 /// threads and mutexes, timing classes.
 /// 
 ////////////////////////////////////////////////////////////

include/SFML/System/Lock.hpp

@@ -107,7 +107,7 @@ private:
 /// } // mutex is unlocked
 /// \endcode
 ///
-/// Because the mutex is not explicitely unlocked in the code,
+/// Because the mutex is not explicitly unlocked in the code,
 /// it may remain locked longer than needed. If the region
 /// of the code that needs to be protected by the mutex is
 /// not the entire function, a good practice is to create a

include/SFML/System/NonCopyable.hpp

@@ -47,7 +47,7 @@ protected:
     ///
     /// Because this class has a copy constructor, the compiler
     /// will not automatically generate the default constructor.
-    /// That's why we must define it explicitely.
+    /// That's why we must define it explicitly.
     ///
     ////////////////////////////////////////////////////////////
     NonCopyable() {}
@@ -89,7 +89,7 @@ private:
 /// \class sf::NonCopyable
 /// \ingroup system
 ///
-/// This class makes its instances non-copyable, by explicitely
+/// This class makes its instances non-copyable, by explicitly
 /// disabling its copy constructor and its assignment operator.
 ///
 /// To create a non-copyable class, simply inherit from

include/SFML/System/String.hpp

@@ -49,7 +49,7 @@ public:
     // Types
     ////////////////////////////////////////////////////////////
     typedef std::basic_string<Uint32>::iterator       Iterator;      ///< Iterator type
-    typedef std::basic_string<Uint32>::const_iterator ConstIterator; ///< Constant iterator type
+    typedef std::basic_string<Uint32>::const_iterator ConstIterator; ///< Read-only iterator type
 
     ////////////////////////////////////////////////////////////
     // Static member data
@@ -235,7 +235,7 @@ public:
     operator std::wstring() const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Convert the unicode string to an ANSI string
+    /// \brief Convert the Unicode string to an ANSI string
     ///
     /// The UTF-32 string is converted to an ANSI string in
     /// the encoding defined by \a locale.
@@ -252,7 +252,7 @@ public:
     std::string toAnsiString(const std::locale& locale = std::locale()) const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Convert the unicode string to a wide string
+    /// \brief Convert the Unicode string to a wide string
     ///
     /// Characters that do not fit in the target encoding are
     /// discarded from the returned string.
@@ -265,7 +265,7 @@ public:
     std::wstring toWideString() const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Convert the unicode string to a UTF-8 string
+    /// \brief Convert the Unicode string to a UTF-8 string
     ///
     /// \return Converted UTF-8 string
     ///
@@ -275,7 +275,7 @@ public:
     std::basic_string<Uint8> toUtf8() const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Convert the unicode string to a UTF-16 string
+    /// \brief Convert the Unicode string to a UTF-16 string
     ///
     /// \return Converted UTF-16 string
     ///
@@ -285,7 +285,7 @@ public:
     std::basic_string<Uint16> toUtf16() const;
 
     ////////////////////////////////////////////////////////////
-    /// \brief Convert the unicode string to a UTF-32 string
+    /// \brief Convert the Unicode string to a UTF-32 string
     ///
     /// This function doesn't perform any conversion, since the
     /// string is already stored as UTF-32 internally.
@@ -321,7 +321,7 @@ public:
     /// \brief Overload of [] operator to access a character by its position
     ///
     /// This function provides read-only access to characters.
-    /// Note: this function doesn't throw if \a index is out of range.
+    /// Note: the behavior is undefined if \a index is out of range.
     ///
     /// \param index Index of the character to get
     ///
@@ -334,7 +334,7 @@ public:
     /// \brief Overload of [] operator to access a character by its position
     ///
     /// This function provides read and write access to characters.
-    /// Note: this function doesn't throw if \a index is out of range.
+    /// Note: the behavior is undefined if \a index is out of range.
     ///
     /// \param index Index of the character to get
     ///
@@ -418,7 +418,7 @@ public:
     /// and spans \a length characters with the string \a replaceWith.
     ///
     /// \param position    Index of the first character to be replaced
-    /// \param length      Number of characters to replace. You can pass InvalidPos to 
+    /// \param length      Number of characters to replace. You can pass InvalidPos to
     ///                    replace all characters until the end of the string.
     /// \param replaceWith String that replaces the given substring.
     ///
@@ -428,7 +428,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Replace all occurrences of a substring with a replacement string
     ///
-    /// This function replaces all occurences of \a searchFor in this string
+    /// This function replaces all occurrences of \a searchFor in this string
     /// with the string \a replaceWith.
     ///
     /// \param searchFor   The value being searched for
@@ -440,13 +440,13 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Return a part of the string
     ///
-    /// This function returns the substring that starts at index \a position 
+    /// This function returns the substring that starts at index \a position
     /// and spans \a length characters.
     ///
-    /// \param position Index of the first character 
+    /// \param position Index of the first character
     /// \param length   Number of characters to include in the substring (if
     ///                 the string is shorter, as many characters as possible
-    ///                 are included). \ref InvalidPos can be used to include all 
+    ///                 are included). \ref InvalidPos can be used to include all
     ///                 characters until the end of the string.
     ///
     /// \return String object containing a substring of this object
@@ -557,7 +557,7 @@ SFML_SYSTEM_API bool operator !=(const String& left, const String& right);
 /// \param left  Left operand (a string)
 /// \param right Right operand (a string)
 ///
-/// \return True if \a left is alphabetically less than \a right
+/// \return True if \a left is lexicographically before \a right
 ///
 ////////////////////////////////////////////////////////////
 SFML_SYSTEM_API bool operator <(const String& left, const String& right);
@@ -569,7 +569,7 @@ SFML_SYSTEM_API bool operator <(const String& left, const String& right);
 /// \param left  Left operand (a string)
 /// \param right Right operand (a string)
 ///
-/// \return True if \a left is alphabetically greater than \a right
+/// \return True if \a left is lexicographically after \a right
 ///
 ////////////////////////////////////////////////////////////
 SFML_SYSTEM_API bool operator >(const String& left, const String& right);
@@ -581,7 +581,7 @@ SFML_SYSTEM_API bool operator >(const String& left, const String& right);
 /// \param left  Left operand (a string)
 /// \param right Right operand (a string)
 ///
-/// \return True if \a left is alphabetically less or equal than \a right
+/// \return True if \a left is lexicographically before or equivalent to \a right
 ///
 ////////////////////////////////////////////////////////////
 SFML_SYSTEM_API bool operator <=(const String& left, const String& right);
@@ -593,7 +593,7 @@ SFML_SYSTEM_API bool operator <=(const String& left, const String& right);
 /// \param left  Left operand (a string)
 /// \param right Right operand (a string)
 ///
-/// \return True if \a left is alphabetically greater or equal than \a right
+/// \return True if \a left is lexicographically after or equivalent to \a right
 ///
 ////////////////////////////////////////////////////////////
 SFML_SYSTEM_API bool operator >=(const String& left, const String& right);
@@ -625,7 +625,7 @@ SFML_SYSTEM_API String operator +(const String& left, const String& right);
 /// sf::String is a utility string class defined mainly for
 /// convenience. It is a Unicode string (implemented using
 /// UTF-32), thus it can store any character in the world
-/// (european, chinese, arabic, hebrew, etc.).
+/// (European, Chinese, Arabic, Hebrew, etc.).
 ///
 /// It automatically handles conversions from/to ANSI and
 /// wide strings, so that you can work with standard string

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/ThreadLocal.hpp

@@ -51,7 +51,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Default constructor
     ///
-    /// \param value Optional value to initalize the variable
+    /// \param value Optional value to initialize the variable
     ///
     ////////////////////////////////////////////////////////////
     ThreadLocal(void* value = NULL);

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 implicitely 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/System/Utf.inl

@@ -339,7 +339,7 @@ Out Utf<16>::encode(Uint32 input, Out output, Uint16 replacement)
     }
     else if (input > 0x0010FFFF)
     {
-        // Invalid character (greater than the maximum unicode value)
+        // Invalid character (greater than the maximum Unicode value)
         if (replacement)
             *output++ = replacement;
     }
@@ -638,7 +638,7 @@ Out Utf<32>::toUtf32(In begin, In end, Out output)
 template <typename In>
 Uint32 Utf<32>::decodeAnsi(In input, const std::locale& locale)
 {
-    // On Windows, gcc's standard library (glibc++) has almost
+    // On Windows, GCC's standard library (glibc++) has almost
     // no support for Unicode stuff. As a consequence, in this
     // context we can only use the default locale and ignore
     // the one passed as parameter.

include/SFML/System/Vector2.hpp

@@ -280,7 +280,7 @@ typedef Vector2<float>        Vector2f;
 /// \li sf::Vector2<unsigned int> is sf::Vector2u
 ///
 /// The sf::Vector2 class has a small and simple interface, its x and y members
-/// can be accessed directly (there's no accessor like setX(), getX()) and it
+/// can be accessed directly (there are no accessors like setX(), getX()) and it
 /// contains no mathematical function like dot product, cross product, length, etc.
 ///
 /// Usage example:

include/SFML/System/Vector3.hpp

@@ -280,7 +280,7 @@ typedef Vector3<float> Vector3f;
 /// \li sf::Vector3<int> is sf::Vector3i
 ///
 /// The sf::Vector3 class has a small and simple interface, its x and y members
-/// can be accessed directly (there's no accessor like setX(), getX()) and it
+/// can be accessed directly (there are no accessors like setX(), getX()) and it
 /// contains no mathematical function like dot product, cross product, length, etc.
 ///
 /// Usage example:

include/SFML/Window/Context.hpp

@@ -66,7 +66,7 @@ public:
     ~Context();
 
     ////////////////////////////////////////////////////////////
-    /// \brief Activate or deactivate explicitely the context
+    /// \brief Activate or deactivate explicitly the context
     ///
     /// \param active True to activate, false to deactivate
     ///

include/SFML/Window/Event.hpp

@@ -74,7 +74,7 @@ public:
     ////////////////////////////////////////////////////////////
     struct TextEvent
     {
-        Uint32 unicode; ///< UTF-32 unicode value of the character
+        Uint32 unicode; ///< UTF-32 Unicode value of the character
     };
 
     ////////////////////////////////////////////////////////////

include/SFML/Window/Joystick.hpp

@@ -157,9 +157,9 @@ public:
     /// \brief Update the states of all joysticks
     ///
     /// This function is used internally by SFML, so you normally
-    /// don't have to call it explicitely. However, you may need to
+    /// 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();
@@ -202,7 +202,7 @@ public:
 /// joysticks. When you have a window with event handling, this is done
 /// automatically, you don't need to call anything. But if you have no
 /// window, or if you want to check joysticks state before creating one,
-/// you must call sf::Joystick::update explicitely.
+/// you must call sf::Joystick::update explicitly.
 ///
 /// Usage example:
 /// \code

include/SFML/Window/Sensor.hpp

@@ -107,7 +107,7 @@ public:
 ///
 /// sf::Sensor provides an interface to the state of the
 /// various sensors that a device provides. It only contains static
-/// functions, so it's not meant to be instanciated.
+/// functions, so it's not meant to be instantiated.
 ///
 /// This class allows users to query the sensors values at any
 /// time and directly, without having to deal with a window and

include/SFML/Window/Touch.hpp

@@ -94,7 +94,7 @@ public:
 ///
 /// sf::Touch provides an interface to the state of the
 /// touches. It only contains static functions, so it's not
-/// meant to be instanciated.
+/// meant to be instantiated.
 ///
 /// This class allows users to query the touches state at any
 /// time and directly, without having to deal with a window and

include/SFML/Window/VideoMode.hpp

@@ -203,7 +203,7 @@ SFML_WINDOW_API bool operator >=(const VideoMode& left, const VideoMode& right);
 /// A custom video mode can also be checked directly for
 /// fullscreen compatibility with its isValid() function.
 ///
-/// Additionnally, sf::VideoMode provides a static function
+/// Additionally, sf::VideoMode provides a static function
 /// to get the mode currently used by the desktop: getDesktopMode().
 /// This allows to build windows with the same size or pixel
 /// depth as the current resolution.

include/SFML/Window/Window.hpp

@@ -72,7 +72,7 @@ public:
     ///
     /// This constructor creates the window with the size and pixel
     /// depth defined in \a mode. An optional style can be passed to
-    /// customize the look and behaviour of the window (borders,
+    /// customize the look and behavior of the window (borders,
     /// title bar, resizable, closable, ...). If \a style contains
     /// Style::Fullscreen, then \a mode must be a valid video mode.
     ///
@@ -217,7 +217,7 @@ public:
     ///
     /// This function is blocking: if there's no pending event then
     /// it will wait until an event is received.
-    /// After this function returns (and no error occured),
+    /// After this function returns (and no error occurred),
     /// the \a event object is always valid and filled properly.
     /// This function is typically used when you have a thread that
     /// is dedicated to events handling: you want to make this thread
@@ -232,7 +232,7 @@ public:
     ///
     /// \param event Event to be returned
     ///
-    /// \return False if any error occured
+    /// \return False if any error occurred
     ///
     /// \see pollEvent
     ///

src/SFML/Audio/SoundStream.cpp

@@ -315,7 +315,7 @@ void SoundStream::streamData()
             }
         }
 
-        // Get the number of buffers that have been processed (ie. ready for reuse)
+        // Get the number of buffers that have been processed (i.e. ready for reuse)
         ALint nbProcessed = 0;
         alCheck(alGetSourcei(m_source, AL_BUFFERS_PROCESSED, &nbProcessed));
 
@@ -381,7 +381,7 @@ void SoundStream::streamData()
     // Stop the playback
     alCheck(alSourceStop(m_source));
 
-    // Unqueue any buffer left in the queue
+    // Dequeue any buffer left in the queue
     clearQueue();
 
     // Delete the buffers
@@ -460,7 +460,7 @@ void SoundStream::clearQueue()
     ALint nbQueued;
     alCheck(alGetSourcei(m_source, AL_BUFFERS_QUEUED, &nbQueued));
 
-    // Unqueue them all
+    // Dequeue them all
     ALuint buffer;
     for (ALint i = 0; i < nbQueued; ++i)
         alCheck(alSourceUnqueueBuffers(m_source, 1, &buffer));

src/SFML/Graphics/Font.cpp

@@ -197,7 +197,7 @@ bool Font::loadFromMemory(const void* data, std::size_t sizeInBytes)
         return false;
     }
 
-    // Select the unicode character map
+    // Select the Unicode character map
     if (FT_Select_Charmap(face, FT_ENCODING_UNICODE) != 0)
     {
         err() << "Failed to load font from memory (failed to set the Unicode character set)" << std::endl;
@@ -261,7 +261,7 @@ bool Font::loadFromStream(InputStream& stream)
         return false;
     }
 
-    // Select the unicode character map
+    // Select the Unicode character map
     if (FT_Select_Charmap(face, FT_ENCODING_UNICODE) != 0)
     {
         err() << "Failed to load font from stream (failed to set the Unicode character set)" << std::endl;
@@ -520,7 +520,7 @@ Glyph Font::loadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) c
     if ((width > 0) && (height > 0))
     {
         // Leave a small padding around characters, so that filtering doesn't
-        // pollute them with pixels from neighbours
+        // pollute them with pixels from neighbors
         const unsigned int padding = 1;
 
         // Get the glyphs page corresponding to the character size
@@ -529,7 +529,7 @@ Glyph Font::loadGlyph(Uint32 codePoint, unsigned int characterSize, bool bold) c
         // Find a good position for the new glyph into the texture
         glyph.textureRect = findGlyphRect(page, width + 2 * padding, height + 2 * padding);
 
-        // Make sure the texture data is positioned in the centre
+        // Make sure the texture data is positioned in the center
         // of the allocated texture rectangle
         glyph.textureRect.left += padding;
         glyph.textureRect.top += padding;

src/SFML/Graphics/ImageLoader.cpp

@@ -286,7 +286,7 @@ bool ImageLoader::writeJpg(const std::string& filename, const std::vector<Uint8>
     jpeg_set_defaults(&compressInfos);
     jpeg_set_quality(&compressInfos, 90, TRUE);
 
-    // Get rid of the aplha channel
+    // Get rid of the alpha channel
     std::vector<Uint8> buffer(width * height * 3);
     for (std::size_t i = 0; i < width * height; ++i)
     {

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

src/SFML/Graphics/Shader.cpp

@@ -632,7 +632,7 @@ int Shader::getParamLocation(const std::string& name)
 
 #else // SFML_OPENGL_ES
 
-// OpenGL ES 1 does't support GLSL shaders at all, we have to provide an empty implementation
+// OpenGL ES 1 doesn't support GLSL shaders at all, we have to provide an empty implementation
 
 namespace sf
 {

src/SFML/Main/MainAndroid.cpp

@@ -64,7 +64,7 @@ ActivityStates* retrieveStates(ANativeActivity* activity)
 ////////////////////////////////////////////////////////////
 static void initializeMain(ActivityStates* states)
 {
-    // Protect from concurent access
+    // Protect from concurrent access
     Lock lock(states->mutex);
 
     // Prepare and share the looper to be read later
@@ -80,7 +80,7 @@ static void initializeMain(ActivityStates* states)
 ////////////////////////////////////////////////////////////
 static void terminateMain(ActivityStates* states)
 {
-    // Protect from concurent access
+    // Protect from concurrent access
     Lock lock(states->mutex);
 
     // The main thread has finished, we must explicitly ask the activity to finish
@@ -154,7 +154,7 @@ void goToFullscreenMode(ANativeActivity* activity)
 
 void getScreenSizeInPixels(ANativeActivity* activity, int* width, int* height)
 {
-    // Perform the following java code:
+    // Perform the following Java code:
     //
     // DisplayMetrics dm = new DisplayMetrics();
     // getWindowManager().getDefaultDisplay().getMetrics(dm);

src/SFML/Main/SFMLActivity.cpp

@@ -41,7 +41,7 @@ std::string getLibraryName(JNIEnv* lJNIEnv, jobject& objectActivityInfo)
 {
     // This function reads the value of meta-data "sfml.app.lib_name"
     // found in the Android Manifest file and returns it. It performs the
-    // following java code using the JNI interface:
+    // following Java code using the JNI interface:
     //
     // ai.metaData.getString("sfml.app.lib_name");
 

src/SFML/Network/IpAddress.cpp

@@ -37,7 +37,7 @@ namespace
     {
         if (address == "255.255.255.255")
         {
-            // The broadcast address needs to be handled explicitely,
+            // The broadcast address needs to be handled explicitly,
             // because it is also the value returned by inet_addr on error
             return INADDR_BROADCAST;
         }
@@ -84,7 +84,7 @@ m_address(0)
 {
     // We're using 0 (INADDR_ANY) instead of INADDR_NONE to represent the invalid address,
     // because the latter is also the broadcast address (255.255.255.255); it's ok because
-    // SFML doesn't publicly use INADDR_ANY (it is always used implicitely)
+    // SFML doesn't publicly use INADDR_ANY (it is always used implicitly)
 }
 
 

src/SFML/Network/Socket.cpp

@@ -101,7 +101,7 @@ void Socket::create(SocketHandle handle)
 
         if (m_type == Tcp)
         {
-            // Disable the Nagle algorithm (ie. removes buffering of TCP packets)
+            // Disable the Nagle algorithm (i.e. removes buffering of TCP packets)
             int yes = 1;
             if (setsockopt(m_socket, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char*>(&yes), sizeof(yes)) == -1)
             {

src/SFML/Network/TcpSocket.cpp

@@ -157,7 +157,7 @@ Socket::Status TcpSocket::connect(const IpAddress& remoteAddress, unsigned short
         // Get the error status
         Status status = priv::SocketImpl::getErrorStatus();
 
-        // If we were in non-blocking mode, return immediatly
+        // If we were in non-blocking mode, return immediately
         if (!blocking)
             return status;
 

src/SFML/System/Err.cpp

@@ -33,7 +33,7 @@
 namespace
 {
 // This class will be used as the default streambuf of sf::Err,
-// it outputs to stderr by default (to keep the default behaviour)
+// it outputs to stderr by default (to keep the default behavior)
 class DefaultErrStreamBuf : public std::streambuf
 {
 public:

src/SFML/System/String.cpp

@@ -295,7 +295,7 @@ void String::replace(const String& searchFor, const String& replaceWith)
     std::size_t len = searchFor.getSize();
     std::size_t pos = find(searchFor);
 
-    // Replace each occurence of search
+    // Replace each occurrence of search
     while (pos != InvalidPos)
     {
         replace(pos, len, replaceWith);

src/SFML/System/Unix/ClockImpl.hpp

@@ -37,7 +37,7 @@ namespace sf
 namespace priv
 {
 ////////////////////////////////////////////////////////////
-/// \brief Unix implementaton of sf::Clock
+/// \brief Unix implementation of sf::Clock
 ///
 ////////////////////////////////////////////////////////////
 class ClockImpl

src/SFML/System/Unix/MutexImpl.cpp

@@ -35,7 +35,7 @@ namespace priv
 ////////////////////////////////////////////////////////////
 MutexImpl::MutexImpl()
 {
-    // Make it recursive to follow the expected behaviour
+    // Make it recursive to follow the expected behavior
     pthread_mutexattr_t attributes;
     pthread_mutexattr_init(&attributes);
     pthread_mutexattr_settype(&attributes, PTHREAD_MUTEX_RECURSIVE);

src/SFML/System/Unix/ThreadImpl.cpp

@@ -79,7 +79,7 @@ void* ThreadImpl::entryPoint(void* userData)
     Thread* owner = static_cast<Thread*>(userData);
 
     #ifndef SFML_SYSTEM_ANDROID
-        // Tell the thread to handle cancel requests immediatly
+        // Tell the thread to handle cancel requests immediately
         pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
     #endif
 

src/SFML/System/Win32/ClockImpl.hpp

@@ -37,7 +37,7 @@ namespace sf
 namespace priv
 {
 ////////////////////////////////////////////////////////////
-/// \brief Windows implementaton of sf::Clock
+/// \brief Windows implementation of sf::Clock
 ///
 ////////////////////////////////////////////////////////////
 class ClockImpl

src/SFML/Window/Android/SensorImpl.cpp

@@ -139,7 +139,7 @@ ASensor const* SensorImpl::getDefaultSensor(Sensor::Type sensor)
 
     int type = types[sensor];
 
-    // Retrive the default sensor matching this type
+    // Retrieve the default sensor matching this type
     return ASensorManager_getDefaultSensor(sensorManager, type);
 }
 

src/SFML/Window/Android/WindowImplAndroid.cpp

@@ -300,7 +300,7 @@ int WindowImplAndroid::processEvent(int fd, int events, void* data)
 ////////////////////////////////////////////////////////////
 void WindowImplAndroid::processScrollEvent(AInputEvent* _event, ActivityStates* states)
 {
-    // Prepare the java virtual machine
+    // Prepare the Java virtual machine
     jint lResult;
     jint lFlags = 0;
 
@@ -315,9 +315,9 @@ void WindowImplAndroid::processScrollEvent(AInputEvent* _event, ActivityStates*
     lResult=lJavaVM->AttachCurrentThread(&lJNIEnv, &lJavaVMAttachArgs);
 
     if (lResult == JNI_ERR)
-        err() << "Failed to initialize JNI, couldn't get the unicode value" << std::endl;
+        err() << "Failed to initialize JNI, couldn't get the Unicode value" << std::endl;
 
-    // Retrieve everything we need to create this MotionEvent in java
+    // Retrieve everything we need to create this MotionEvent in Java
     jlong downTime = AMotionEvent_getDownTime(_event);
     jlong eventTime = AMotionEvent_getEventTime(_event);
     jint action = AMotionEvent_getAction(_event);
@@ -331,7 +331,7 @@ void WindowImplAndroid::processScrollEvent(AInputEvent* _event, ActivityStates*
     jint deviceId = AInputEvent_getDeviceId(_event);
     jint edgeFlags = AMotionEvent_getEdgeFlags(_event);
 
-    // Create the MotionEvent object in java trough its static constructor obtain()
+    // Create the MotionEvent object in Java trough its static constructor obtain()
     jclass ClassMotionEvent = lJNIEnv->FindClass("android/view/MotionEvent");
     jmethodID StaticMethodObtain = lJNIEnv->GetStaticMethodID(ClassMotionEvent, "obtain", "(JJIFFFFIFFII)Landroid/view/MotionEvent;");
     jobject ObjectMotionEvent = lJNIEnv->CallStaticObjectMethod(ClassMotionEvent, StaticMethodObtain, downTime, eventTime, action, x, y, pressure, size, metaState, xPrecision, yPrecision, deviceId, edgeFlags);
@@ -349,7 +349,7 @@ void WindowImplAndroid::processScrollEvent(AInputEvent* _event, ActivityStates*
 
     forwardEvent(event);
 
-    // Dettach this thread from the JVM
+    // Detach this thread from the JVM
     lJavaVM->DetachCurrentThread();
 }
 
@@ -670,7 +670,7 @@ int WindowImplAndroid::getUnicode(AInputEvent* event)
     lResult=lJavaVM->AttachCurrentThread(&lJNIEnv, &lJavaVMAttachArgs);
 
     if (lResult == JNI_ERR)
-        err() << "Failed to initialize JNI, couldn't get the unicode value" << std::endl;
+        err() << "Failed to initialize JNI, couldn't get the Unicode value" << std::endl;
 
     // Retrieve key data from the input event
     jlong downTime = AKeyEvent_getDownTime(event);
@@ -689,11 +689,11 @@ int WindowImplAndroid::getUnicode(AInputEvent* event)
     jmethodID KeyEventConstructor = lJNIEnv->GetMethodID(ClassKeyEvent, "<init>", "(JJIIIIIIII)V");
     jobject ObjectKeyEvent = lJNIEnv->NewObject(ClassKeyEvent, KeyEventConstructor, downTime, eventTime, action, code, repeat, metaState, deviceId, scancode, flags, source);
 
-    // Call its getUnicodeChar() method to get the unicode value
+    // Call its getUnicodeChar() method to get the Unicode value
     jmethodID MethodGetUnicode = lJNIEnv->GetMethodID(ClassKeyEvent, "getUnicodeChar", "(I)I");
     int unicode = lJNIEnv->CallIntMethod(ObjectKeyEvent, MethodGetUnicode, metaState);
 
-    // Dettach this thread from the JVM
+    // Detach this thread from the JVM
     lJavaVM->DetachCurrentThread();
 
     return unicode;

src/SFML/Window/Android/WindowImplAndroid.hpp

@@ -204,17 +204,17 @@ private:
     ///
     /// \param symbol Android key to convert
     ///
-    /// \return Corrsponding SFML key code
+    /// \return Corresponding SFML key code
     ///
     ////////////////////////////////////////////////////////////
     static Keyboard::Key androidKeyToSF(int32_t key);
 
     ////////////////////////////////////////////////////////////
-    /// \brief Get unicode decoded from the input event
+    /// \brief Get Unicode decoded from the input event
     ///
     /// \param Event Input event
     ///
-    /// \return The unicode value
+    /// \return The Unicode value
     ///
     ////////////////////////////////////////////////////////////
     static int getUnicode(AInputEvent* event);

src/SFML/Window/EGLCheck.cpp

@@ -144,7 +144,7 @@ void eglCheckError(const char* file, unsigned int line)
             case EGL_CONTEXT_LOST:
             {
                 error = "EGL_CONTEXT_LOST";
-                description = "a power management event has occured. The application must destroy all contexts and reinitialise client API state and objects to continue rendering";
+                description = "a power management event has occurred. The application must destroy all contexts and reinitialize client API state and objects to continue rendering";
                 break;
             }
         }

src/SFML/Window/EglContext.cpp

@@ -80,7 +80,7 @@ m_context (EGL_NO_CONTEXT),
 m_surface (EGL_NO_SURFACE),
 m_config  (NULL)
 {
-    // Get the intialized EGL display
+    // Get the initialized EGL display
     m_display = getInitializedDisplay();
 
     // Get the best EGL config matching the default video settings
@@ -118,7 +118,7 @@ m_config  (NULL)
 
 #endif
 
-    // Get the intialized EGL display
+    // Get the initialized EGL display
     m_display = getInitializedDisplay();
     
     // Get the best EGL config matching the requested video settings
@@ -148,7 +148,7 @@ m_config  (NULL)
 ////////////////////////////////////////////////////////////
 EglContext::~EglContext()
 {
-    // Desactive the current context
+    // Deactivate the current context
     EGLContext currentContext = eglCheck(eglGetCurrentContext());
 
     if (currentContext == m_context)
@@ -258,7 +258,7 @@ EGLConfig EglContext::getBestConfig(EGLDisplay display, unsigned int bitsPerPixe
 ////////////////////////////////////////////////////////////
 XVisualInfo EglContext::selectBestVisual(::Display* XDisplay, unsigned int bitsPerPixel, const ContextSettings& settings)
 {
-    // Get the intialized EGL display
+    // Get the initialized EGL display
     EGLDisplay display = getInitializedDisplay();
     
     // Get the best EGL config matching the default video settings

src/SFML/Window/FreeBSD/JoystickImpl.cpp

@@ -219,7 +219,7 @@ bool JoystickImpl::open(unsigned int index)
             // And the id
             m_id = hid_get_report_id(m_file);
 
-            // Then allocate a buffer for data retrievement
+            // Then allocate a buffer for data retrieval
             m_length = hid_report_size(m_desc, hid_input, m_id);
             m_buffer.resize(m_length);
 

src/SFML/Window/GlContext.hpp

@@ -201,7 +201,7 @@ protected:
     /// lower the score is, the better the configuration is.
     ///
     /// \param bitsPerPixel Requested pixel depth (bits per pixel)
-    /// \param settings     Requested additionnal settings
+    /// \param settings     Requested additional settings
     /// \param colorBits    Color bits of the configuration to evaluate
     /// \param depthBits    Depth bits of the configuration to evaluate
     /// \param stencilBits  Stencil bits of the configuration to evaluate

src/SFML/Window/OSX/HIDInputManager.mm

@@ -54,7 +54,7 @@ long HIDInputManager::getLocationID(IOHIDDeviceRef device)
 {
     long loc = 0;
 
-    // Get a unique ID: its usb location ID
+    // Get a unique ID: its USB location ID
     CFTypeRef typeRef = IOHIDDeviceGetProperty(device,
                                                CFSTR(kIOHIDLocationIDKey));
     if (!typeRef || (CFGetTypeID(typeRef) != CFNumberGetTypeID()))
@@ -225,7 +225,7 @@ void HIDInputManager::loadKey(IOHIDElementRef key)
     if (virtualCode == 0xff)
         return; // no corresponding virtual code -> skip
 
-    // Now translate the virtual code to unicode according to
+    // Now translate the virtual code to Unicode according to
     // the current keyboard layout
 
     UInt32       deadKeyState = 0;
@@ -286,7 +286,7 @@ void HIDInputManager::loadKey(IOHIDElementRef key)
         //          0x4c       | 0x77 | Select
 
         //if (code == Keyboard::Unknown) { // The key is unknown.
-        //    sf::err() << "This is an unknow key. Virtual key code is 0x"
+        //    sf::err() << "This is an unknown key. Virtual key code is 0x"
         //              << std::hex
         //              << (UInt32)virtualCode
         //              << " and HID usage code is 0x"

src/SFML/Window/OSX/JoystickImpl.hpp

@@ -126,7 +126,7 @@ private:
     Joystick::Identification m_identification; ///< Joystick identification
 
     static Location m_locationIDs[sf::Joystick::Count]; ///< Global Joystick register
-    /// For a corresponding SFML index, m_locationIDs is either some usb
+    /// For a corresponding SFML index, m_locationIDs is either some USB
     /// location or 0 if there isn't currently a connected joystick device
 };
 

src/SFML/Window/OSX/SFApplication.h

@@ -30,7 +30,7 @@
 #import <Foundation/Foundation.h>
 
 ////////////////////////////////////////////////////////////
-/// \brief Event processing & Menu bar initialisation
+/// \brief Event processing & Menu bar initialization
 ///
 ////////////////////////////////////////////////////////////
 @interface SFApplication : NSApplication

src/SFML/Window/OSX/SFOpenGLView.mm

@@ -665,7 +665,7 @@ BOOL isValidTextUnicode(NSEvent* event);
     }
 
 
-    // Handle text entred event:
+    // Handle text entered event:
     // Ignore event if we don't want repeated keystrokes
     if (m_useKeyRepeat || ![theEvent isARepeat])
     {
@@ -687,7 +687,7 @@ BOOL isValidTextUnicode(NSEvent* event);
         // Backspace
         if (keycode == 0x33)
         {
-            // Send the correct unicode value (i.e. 8) instead of 127 (which is 'delete')
+            // Send the correct Unicode value (i.e. 8) instead of 127 (which is 'delete')
             m_requester->textEntered(8);
         }
 
@@ -770,7 +770,7 @@ BOOL isValidTextUnicode(NSEvent* event);
 
 //#ifdef SFML_DEBUG // Don't bother the final customers with annoying messages.
 //    if (key.code == sf::Keyboard::Unknown) { // The key is unknown.
-//        sf::err() << "This is an unknow key. Virtual key code is 0x"
+//        sf::err() << "This is an unknown key. Virtual key code is 0x"
 //                  << std::hex
 //                  << [event keyCode]
 //                  << "."

src/SFML/Window/OSX/SFWindowController.mm

@@ -386,7 +386,7 @@
 ////////////////////////////////////////////////////////
 -(void)resizeTo:(unsigned int)width by:(unsigned int)height
 {
-    // Before resizing, remove resizeable mask to be able to resize
+    // Before resizing, remove resizable mask to be able to resize
     // beyond the desktop boundaries.
     NSUInteger styleMask = [m_window styleMask];
 

src/SFML/Window/Unix/WindowImplX11.cpp

@@ -383,7 +383,7 @@ void WindowImplX11::setSize(const Vector2u& size)
 void WindowImplX11::setTitle(const String& title)
 {
     // Bare X11 has no Unicode window title support.
-    // There is however an option to tell the window manager your unicode title via hints.
+    // There is however an option to tell the window manager your Unicode title via hints.
 
     // Convert to UTF-8 encoding.
     std::basic_string<Uint8> utf8Title;

src/SFML/Window/Unix/WindowImplX11.hpp

@@ -220,7 +220,7 @@ private:
     ///
     /// \param symbol Key symbol to convert
     ///
-    /// \return Corrsponding SFML key code
+    /// \return Corresponding SFML key code
     ///
     ////////////////////////////////////////////////////////////
     static Keyboard::Key keysymToSF(KeySym symbol);
@@ -232,11 +232,11 @@ private:
     ::Display* m_display;      ///< Pointer to the display
     int        m_screen;       ///< Screen identifier
     XIM        m_inputMethod;  ///< Input method linked to the X display
-    XIC        m_inputContext; ///< Input context used to get unicode input in our window
+    XIC        m_inputContext; ///< Input context used to get Unicode input in our window
     bool       m_isExternal;   ///< Tell whether the window has been created externally or by SFML
     Atom       m_atomClose;    ///< Atom used to identify the close event
     int        m_oldVideoMode; ///< Video mode in use before we switch to fullscreen
-    Cursor     m_hiddenCursor; ///< As X11 doesn't provide cursor hidding, we must create a transparent one
+    Cursor     m_hiddenCursor; ///< As X11 doesn't provide cursor hiding, we must create a transparent one
     bool       m_keyRepeat;    ///< Is the KeyRepeat feature enabled?
     Vector2i   m_previousSize; ///< Previous size of the window, to find if a ConfigureNotify event is a resize event (could be a move event only)
     bool       m_useSizeHints; ///< Is the size of the window fixed with size hints?

src/SFML/Window/Win32/JoystickImpl.cpp

@@ -177,7 +177,7 @@ void JoystickImpl::cleanup()
 bool JoystickImpl::isConnected(unsigned int index)
 {
     // We check the connection state of joysticks only every N milliseconds,
-    // because of a strange (buggy?) behaviour of joyGetPosEx when joysticks
+    // because of a strange (buggy?) behavior of joyGetPosEx when joysticks
     // are just plugged/unplugged -- it takes really long and kills the app performances
     ConnectionCache& cache = connectionCache[index];
     if (cache.timer.getElapsedTime() > connectionRefreshDelay)

src/SFML/Window/Window.cpp

@@ -410,7 +410,7 @@ bool Window::filterEvent(const Event& event)
 ////////////////////////////////////////////////////////////
 void Window::initialize()
 {
-    // Setup default behaviours (to get a consistent behaviour across different implementations)
+    // Setup default behaviors (to get a consistent behavior across different implementations)
     setVisible(true);
     setMouseCursorVisible(true);
     setVerticalSyncEnabled(false);

src/SFML/Window/WindowImpl.hpp

@@ -88,7 +88,7 @@ public:
     virtual ~WindowImpl();
 
     ////////////////////////////////////////////////////////////
-    /// \brief Change the joystick threshold, ie. the value below which
+    /// \brief Change the joystick threshold, i.e. the value below which
     ///        no move event will be generated
     ///
     /// \param threshold New threshold, in range [0, 100]
@@ -101,7 +101,7 @@ public:
     ///
     /// If there's no event available, this function calls the
     /// window's internal event processing function.
-    /// The \a block parameter controls the behaviour of the function
+    /// The \a block parameter controls the behavior of the function
     /// if no event is available: if it is true then the function
     /// doesn't return until a new event is triggered; otherwise it
     /// returns false to indicate that no event is available.

src/SFML/Window/iOS/EaglContext.hpp

@@ -59,7 +59,7 @@ public:
     ///
     ////////////////////////////////////////////////////////////
     EaglContext(EaglContext* shared);
-    
+
     ////////////////////////////////////////////////////////////
     /// \brief Create a new context attached to a window
     ///
@@ -71,7 +71,7 @@ public:
     ////////////////////////////////////////////////////////////
     EaglContext(EaglContext* shared, const ContextSettings& settings,
                 const WindowImpl* owner, unsigned int bitsPerPixel);
-    
+
     ////////////////////////////////////////////////////////////
     /// \brief Create a new context that embeds its own rendering target
     ///
@@ -81,9 +81,9 @@ public:
     /// \param height   Back buffer height, in pixels
     ///
     ////////////////////////////////////////////////////////////
-    EaglContext(EaglContext* shared, const ContextSettings& settings, 
+    EaglContext(EaglContext* shared, const ContextSettings& settings,
                 unsigned int width, unsigned int height);
-    
+
     ////////////////////////////////////////////////////////////
     /// \brief Destructor
     ///
@@ -106,7 +106,7 @@ public:
     ///
     ////////////////////////////////////////////////////////////
     virtual void display();
-    
+
     ////////////////////////////////////////////////////////////
     /// \brief Enable or disable vertical synchronization
     ///
@@ -119,9 +119,9 @@ public:
     ///
     ////////////////////////////////////////////////////////////
     virtual void setVerticalSyncEnabled(bool enabled);
-    
+
 protected:
-    
+
     ////////////////////////////////////////////////////////////
     /// \brief Activate the context as the current target
     ///        for rendering
@@ -130,9 +130,9 @@ protected:
     ///
     ////////////////////////////////////////////////////////////
     virtual bool makeCurrent();
-    
+
 private:
-    
+
     ////////////////////////////////////////////////////////////
     /// \brief Create the context
     ///
@@ -144,9 +144,9 @@ private:
     ////////////////////////////////////////////////////////////
     void createContext(EaglContext* shared,
                        const WindowImplUIKit* window,
-                       unsigned int bitsPerPixel, 
+                       unsigned int bitsPerPixel,
                        const ContextSettings& settings);
-    
+
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
@@ -157,9 +157,9 @@ private:
     bool m_vsyncEnabled;    ///< Vertical sync activation flag
     Clock m_clock;          ///< Measures the elapsed time for the fake v-sync implementation
 };
-    
+
 } // namespace priv
-    
+
 } // namespace sf
 
 #endif // SFML_EAGLCONTEXT_HPP

src/SFML/Window/iOS/EaglContext.mm

@@ -56,7 +56,7 @@ m_clock       ()
         m_context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES1];
 }
 
-    
+
 ////////////////////////////////////////////////////////////
 EaglContext::EaglContext(EaglContext* shared, const ContextSettings& settings,
                          const WindowImpl* owner, unsigned int bitsPerPixel) :
@@ -74,7 +74,7 @@ m_clock       ()
 
 
 ////////////////////////////////////////////////////////////
-EaglContext::EaglContext(EaglContext* shared, const ContextSettings& settings, 
+EaglContext::EaglContext(EaglContext* shared, const ContextSettings& settings,
                          unsigned int width, unsigned int height) :
 m_context     (nil),
 m_framebuffer (0),
@@ -96,7 +96,7 @@ EaglContext::~EaglContext()
         // Activate the context, so that we can destroy the buffers
         EAGLContext* previousContext = [EAGLContext currentContext];
         [EAGLContext setCurrentContext:m_context];
-    
+
         // Destroy the buffers
         if (m_framebuffer)
             glDeleteFramebuffersOES(1, &m_framebuffer);
@@ -161,7 +161,7 @@ void EaglContext::recreateRenderBuffers(SFView* glView)
     [EAGLContext setCurrentContext:previousContext];
 }
 
-    
+
 ////////////////////////////////////////////////////////////
 bool EaglContext::makeCurrent()
 {
@@ -193,11 +193,11 @@ void EaglContext::setVerticalSyncEnabled(bool enabled)
     m_vsyncEnabled = enabled;
 }
 
-    
+
 ////////////////////////////////////////////////////////////
 void EaglContext::createContext(EaglContext* shared,
                                 const WindowImplUIKit* window,
-                                unsigned int bitsPerPixel, 
+                                unsigned int bitsPerPixel,
                                 const ContextSettings& settings)
 {
     // Save the settings

src/SFML/Window/iOS/SFAppDelegate.mm

@@ -73,7 +73,7 @@ namespace
     // Save the delegate instance
     delegateInstance = self;
 
-    // Instanciate the motion manager
+    // Instantiate the motion manager
     self.motionManager = [[CMMotionManager alloc] init];
 
     // Register orientation changes notifications

src/SFML/Window/iOS/WindowImplUIKit.hpp

@@ -57,7 +57,7 @@ public:
     ///
     ////////////////////////////////////////////////////////////
     WindowImplUIKit(WindowHandle handle);
-    
+
     ////////////////////////////////////////////////////////////
     /// \brief Create the window implementation
     ///
@@ -68,7 +68,7 @@ public:
     ///
     ////////////////////////////////////////////////////////////
     WindowImplUIKit(VideoMode mode, const String& title, unsigned long style, const ContextSettings& settings);
-    
+
     ////////////////////////////////////////////////////////////
     /// \brief Destructor
     ///
@@ -82,7 +82,7 @@ public:
     ///
     ////////////////////////////////////////////////////////////
     virtual WindowHandle getSystemHandle() const;
-    
+
     ////////////////////////////////////////////////////////////
     /// \brief Get the position of the window
     ///
@@ -177,7 +177,7 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Notify an event
     ///
-    /// \param event Evenet to forward
+    /// \param event Event to forward
     ///
     ////////////////////////////////////////////////////////////
     void forwardEvent(Event event);
@@ -216,9 +216,9 @@ private:
     SFViewController* m_viewController; ///< Controller attached to the view
     bool              m_hasFocus;       ///< Current focus state of the window
 };
-    
+
 } // namespace priv
-    
+
 } // namespace sf
 
 

src/SFML/Window/iOS/WindowImplUIKit.mm

@@ -47,7 +47,7 @@ WindowImplUIKit::WindowImplUIKit(WindowHandle handle)
 
 ////////////////////////////////////////////////////////////
 WindowImplUIKit::WindowImplUIKit(VideoMode mode,
-                                 const String& title, 
+                                 const String& title,
                                  unsigned long style,
                                  const ContextSettings& /*settings*/)
 {
@@ -67,7 +67,7 @@ WindowImplUIKit::WindowImplUIKit(VideoMode mode,
 
     // Assign it to the application delegate
     [SFAppDelegate getInstance].sfWindow = this;
-    
+
     // Create the view
     m_view = [[SFView alloc] initWithFrame:frame];
     [m_view resignFirstResponder];
@@ -96,14 +96,14 @@ void WindowImplUIKit::processEvents()
         ;
 }
 
-    
+
 ////////////////////////////////////////////////////////////
 WindowHandle WindowImplUIKit::getSystemHandle() const
 {
     return (__bridge WindowHandle)m_window;
 }
 
-    
+
 ////////////////////////////////////////////////////////////
 Vector2i WindowImplUIKit::getPosition() const
 {
@@ -123,7 +123,7 @@ Vector2u WindowImplUIKit::getSize() const
     return Vector2u(m_window.frame.size.width, m_window.frame.size.height);
 }
 
-    
+
 ////////////////////////////////////////////////////////////
 void WindowImplUIKit::setSize(const Vector2u& size)
 {
@@ -136,35 +136,35 @@ void WindowImplUIKit::setSize(const Vector2u& size)
         [[UIApplication sharedApplication] setStatusBarOrientation:UIInterfaceOrientationPortrait];
 }
 
-    
+
 ////////////////////////////////////////////////////////////
 void WindowImplUIKit::setTitle(const String& title)
 {
     // Not applicable
 }
 
-    
+
 ////////////////////////////////////////////////////////////
 void WindowImplUIKit::setIcon(unsigned int width, unsigned int height, const Uint8* pixels)
 {
     // Not applicable
 }
 
-    
+
 ////////////////////////////////////////////////////////////
 void WindowImplUIKit::setVisible(bool visible)
 {
     // Not applicable
 }
 
-    
+
 ////////////////////////////////////////////////////////////
 void WindowImplUIKit::setMouseCursorVisible(bool visible)
 {
     // Not applicable
 }
 
-    
+
 ////////////////////////////////////////////////////////////
 void WindowImplUIKit::setKeyRepeatEnabled(bool enabled)
 {
@@ -213,7 +213,7 @@ void WindowImplUIKit::setVirtualKeyboardVisible(bool visible)
     else
         [m_view resignFirstResponder];
 }
-    
+
 } // namespace priv
-    
+
 } // namespace sf