Improved tags for doxygen documentation (added relations between free functions and classes, grouped classes into modules)

git-svn-id: https://sfml.svn.sourceforge.net/svnroot/sfml/branches/sfml2@1535 4e206d99-4929-0410-ac5d-dfc041789085

include/SFML/Audio.hpp

@@ -40,3 +40,8 @@
 
 
 #endif // SFML_AUDIO_HPP
+
+////////////////////////////////////////////////////////////
+/// \defgroup audio Audio module
+/// 
+////////////////////////////////////////////////////////////

include/SFML/Audio/Listener.hpp

@@ -154,6 +154,7 @@ public :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Listener
+/// \ingroup audio
 ///
 /// The audio listener defines the global properties of the
 /// audio environment, it defines where and how sounds and musics

include/SFML/Audio/Music.hpp

@@ -146,6 +146,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Music
+/// \ingroup audio
 ///
 /// Musics are sounds that are streamed rather than completely
 /// loaded in memory. This is especially useful for compressed

include/SFML/Audio/Sound.hpp

@@ -228,6 +228,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Sound
+/// \ingroup audio
 ///
 /// sf::Sound is the class to use to play sounds.
 /// It provides:

include/SFML/Audio/SoundBuffer.hpp

@@ -261,6 +261,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::SoundBuffer
+/// \ingroup audio
 ///
 /// A sound buffer holds the data of a sound, which is
 /// an array of audio samples. A sample is a 16 bits signed integer

include/SFML/Audio/SoundBufferRecorder.hpp

@@ -98,6 +98,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::SoundBufferRecorder
+/// \ingroup audio
 ///
 /// sf::SoundBufferRecorder allows to access a recorded sound
 /// through a sf::SoundBuffer, so that it can be played, saved

include/SFML/Audio/SoundRecorder.hpp

@@ -193,6 +193,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::SoundRecorder
+/// \ingroup audio
 ///
 /// sf::SoundBuffer provides a simple interface to access
 /// the audio recording capabilities of the computer

include/SFML/Audio/SoundSource.hpp

@@ -271,6 +271,7 @@ protected :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::SoundSource
+/// \ingroup audio
 ///
 /// sf::SoundSource is not meant to be used directly, it
 /// only serves as a common base for all audio objects

include/SFML/Audio/SoundStream.hpp

@@ -296,6 +296,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::SoundStream
+/// \ingroup audio
 ///
 /// Unlike audio buffers (see sf::SoundBuffer), audio streams
 /// are never completely loaded in memory. Instead, the audio

include/SFML/Graphics.hpp

@@ -45,3 +45,8 @@
 
 
 #endif // SFML_GRAPHICS_HPP
+
+////////////////////////////////////////////////////////////
+/// \defgroup graphics Graphics module
+/// 
+////////////////////////////////////////////////////////////

include/SFML/Graphics/Color.hpp

@@ -83,6 +83,7 @@ public :
 };
 
 ////////////////////////////////////////////////////////////
+/// \relates Color
 /// \brief Overload of the == operator
 ///
 /// This operator compares two colors and check if they are equal.
@@ -96,6 +97,7 @@ public :
 SFML_API bool operator ==(const Color& left, const Color& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Color
 /// \brief Overload of the != operator
 ///
 /// This operator compares two colors and check if they are different.
@@ -109,6 +111,7 @@ SFML_API bool operator ==(const Color& left, const Color& right);
 SFML_API bool operator !=(const Color& left, const Color& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Color
 /// \brief Overload of the binary + operator
 ///
 /// This operator returns the component-wise sum of two colors.
@@ -123,6 +126,7 @@ SFML_API bool operator !=(const Color& left, const Color& right);
 SFML_API Color operator +(const Color& left, const Color& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Color
 /// \brief Overload of the binary * operator
 ///
 /// This operator returns the component-wise multiplication
@@ -139,6 +143,7 @@ SFML_API Color operator +(const Color& left, const Color& right);
 SFML_API Color operator *(const Color& left, const Color& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Color
 /// \brief Overload of the binary += operator
 ///
 /// This operator computes the component-wise sum of two colors,
@@ -154,6 +159,7 @@ SFML_API Color operator *(const Color& left, const Color& right);
 SFML_API Color& operator +=(Color& left, const Color& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Color
 /// \brief Overload of the binary *= operator
 ///
 /// This operator returns the component-wise multiplication
@@ -178,6 +184,7 @@ SFML_API Color& operator *=(Color& left, const Color& right);
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Color
+/// \ingroup graphics
 ///
 /// sf::Color is a simple color class composed of 4 components:
 /// \li Red

include/SFML/Graphics/Drawable.hpp

@@ -41,6 +41,7 @@ class RenderTarget;
 namespace Blend
 {
     ////////////////////////////////////////////////////////////
+    /// \ingroup graphics
     /// \brief Available blending modes for drawable objects
     ///
     ////////////////////////////////////////////////////////////
@@ -524,6 +525,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Drawable
+/// \ingroup graphics
 ///
 /// sf::Drawable defines the attributes and operations that
 /// are common to all the drawable classes:

include/SFML/Graphics/Font.hpp

@@ -291,6 +291,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Font
+/// \ingroup graphics
 ///
 /// Fonts can be loaded from a file or from memory, from
 /// the most common types of fonts. See the LoadFromFile

include/SFML/Graphics/Glyph.hpp

@@ -64,6 +64,7 @@ public :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Glyph
+/// \ingroup graphics
 ///
 /// A glyph is the visual representation of a character.
 ///

include/SFML/Graphics/Image.hpp

@@ -463,6 +463,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Image
+/// \ingroup graphics
 ///
 /// sf::Image is an abstraction to manipulate images
 /// as bidimensional arrays of pixels. The class provides

include/SFML/Graphics/Matrix3.hpp

@@ -165,6 +165,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Matrix3
+/// \ingroup graphics
 ///
 /// Matrix3 is only meant for internal use, its interface is
 /// limited and its implementation is optimized for OpenGL

include/SFML/Graphics/Rect.hpp

@@ -154,6 +154,7 @@ typedef Rect<float> FloatRect;
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Rect
+/// \ingroup graphics
 ///
 /// A rectangle is defined by its top-left corner and its size.
 /// It is a very simple class defined for convenience, so

include/SFML/Graphics/RenderImage.hpp

@@ -221,6 +221,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::RenderImage
+/// \ingroup graphics
 ///
 /// sf::RenderImage is the little brother of sf::RenderWindow.
 /// It implements the same 2D drawing and OpenGL-related functions

include/SFML/Graphics/RenderTarget.hpp

@@ -311,6 +311,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::RenderTarget
+/// \ingroup graphics
 ///
 /// sf::RenderTarget defines the common behaviour of all the
 /// 2D render targets usable in the graphics module. It makes

include/SFML/Graphics/RenderWindow.hpp

@@ -165,6 +165,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::RenderWindow
+/// \ingroup graphics
 ///
 /// sf::RenderWindow is the main class of the Graphics module.
 /// It defines an OS window that can be painted using the other

include/SFML/Graphics/Renderer.hpp

@@ -372,6 +372,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Renderer
+/// \ingroup graphics
 ///
 /// sf::Renderer is the abstraction layer between SFML code
 /// and the low-level drawing API (OpenGL). It manages

include/SFML/Graphics/Shader.hpp

@@ -370,6 +370,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Shader
+/// \ingroup graphics
 ///
 /// Pixel shaders (or fragment shaders) are programs written
 /// using a specific language, executed directly by the

include/SFML/Graphics/Shape.hpp

@@ -433,6 +433,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Shape
+/// \ingroup graphics
 ///
 /// sf::Shape is a drawable class that allows to define and
 /// display a custom convex shape on a render target.

include/SFML/Graphics/Sprite.hpp

@@ -243,6 +243,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Sprite
+/// \ingroup graphics
 ///
 /// sf::Sprite is a drawable class that allows to easily display
 /// an image (or a part of it) on a render target.

include/SFML/Graphics/Text.hpp

@@ -254,6 +254,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Text
+/// \ingroup graphics
 ///
 /// sf::Text is a drawable class that allows to easily display
 /// some text with custom style and color on a render target.

include/SFML/Graphics/View.hpp

@@ -287,6 +287,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::View
+/// \ingroup graphics
 ///
 /// sf::View defines a camera in the 2D scene. This is a
 /// very powerful concept: you can scroll, rotate or zoom

include/SFML/Network.hpp

@@ -41,3 +41,8 @@
 
 
 #endif // SFML_NETWORK_HPP
+
+////////////////////////////////////////////////////////////
+/// \defgroup network Network module
+/// 
+////////////////////////////////////////////////////////////

include/SFML/Network/Ftp.hpp

@@ -532,6 +532,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Ftp
+/// \ingroup network
 ///
 /// sf::Ftp is a very simple FTP client that allows you
 /// to communicate with a FTP server. The FTP protocol allows

include/SFML/Network/Http.hpp

@@ -407,6 +407,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Http
+/// \ingroup network
 ///
 /// sf::Http is a very simple HTTP client that allows you
 /// to communicate with a web server. You can retrieve

include/SFML/Network/IpAddress.hpp

@@ -287,6 +287,7 @@ SFML_API std::ostream& operator <<(std::ostream& stream, const IpAddress& addres
 
 ////////////////////////////////////////////////////////////
 /// \class sf::IpAddress
+/// \ingroup network
 ///
 /// sf::IpAddress is a utility class for manipulating network
 /// addresses. It provides a set a implicit constructors and

include/SFML/Network/Packet.hpp

@@ -269,6 +269,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Packet
+/// \ingroup network
 ///
 /// Packets provide a safe and easy way to serialize data,
 /// in order to send it over the network using sockets

include/SFML/Network/Socket.hpp

@@ -202,6 +202,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Socket
+/// \ingroup network
 ///
 /// This class mainly defines internal stuff to be used by
 /// derived classes.

include/SFML/Network/SocketSelector.hpp

@@ -167,6 +167,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::SocketSelector
+/// \ingroup network
 ///
 /// Socket selectors provide a way to wait until some data is
 /// available on a set of sockets, instead of just one. This

include/SFML/Network/TcpListener.hpp

@@ -104,6 +104,7 @@ public :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::TcpListener
+/// \ingroup network
 ///
 /// A listener socket is a special type of socket that listens to
 /// a given port and waits for connections on that port.

include/SFML/Network/TcpSocket.hpp

@@ -193,6 +193,7 @@ public :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::TcpSocket
+/// \ingroup network
 ///
 /// TCP is a connected protocol, which means that a TCP
 /// socket can only communicate with the host it is connected

include/SFML/Network/UdpSocket.hpp

@@ -190,6 +190,7 @@ public :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::UdpSocket
+/// \ingroup network
 ///
 /// A UDP socket is a connectionless socket. Instead of
 /// connecting once to a remote host, like TCP sockets,

include/SFML/System.hpp

@@ -45,3 +45,8 @@
 #include <SFML/System/Vector3.hpp>
 
 #endif // SFML_SYSTEM_HPP
+
+////////////////////////////////////////////////////////////
+/// \defgroup system System module
+/// 
+////////////////////////////////////////////////////////////

include/SFML/System/Clock.hpp

@@ -85,6 +85,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Clock
+/// \ingroup system
 ///
 /// sf::Clock is a lightweight class for measuring time.
 /// Its resolution depends on the underlying OS, but you can generally

include/SFML/System/Err.hpp

@@ -48,6 +48,7 @@ SFML_API std::ostream& Err();
 
 ////////////////////////////////////////////////////////////
 /// \fn sf::Err
+/// \ingroup system
 ///
 /// By default, sf::Err() outputs to the same location as std::cerr,
 /// (-> the stderr descriptor) which is the console if there's

include/SFML/System/Lock.hpp

@@ -77,6 +77,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Lock
+/// \ingroup system
 ///
 /// sf::Lock is a RAII wrapper for sf::Mutex. By unlocking
 /// it in its destructor, it ensures that the mutex will

include/SFML/System/Mutex.hpp

@@ -96,6 +96,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Mutex
+/// \ingroup system
 ///
 /// Mutex stands for "MUTual EXclusion". A mutex is a
 /// synchronization object, used when multiple threads are involved.

include/SFML/System/NonCopyable.hpp

@@ -87,6 +87,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::NonCopyable
+/// \ingroup system
 ///
 /// This class makes its instances non-copyable, by explicitely
 /// disabling its copy constructor and its assignment operator.

include/SFML/System/Randomizer.hpp

@@ -91,6 +91,7 @@ public :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Randomizer
+/// \ingroup system
 ///
 /// sf::Randomizer generates pseudo-random numbers using the
 /// standard library.

include/SFML/System/Resource.hpp

@@ -243,6 +243,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Resource
+/// \ingroup system
 ///
 /// sf::Resource is a base for classes that want to be
 /// compatible with the sf::ResourcePtr safe pointer.
@@ -256,6 +257,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::ResourcePtr
+/// \ingroup system
 ///
 /// sf::ResourcePtr is a special kind of smart pointer for
 /// resources. Its main feature is to automatically

include/SFML/System/Sleep.hpp

@@ -34,6 +34,7 @@
 namespace sf
 {
 ////////////////////////////////////////////////////////////
+/// \ingroup system
 /// \brief Make the current thread sleep for a given time
 ///
 /// sf::Sleep is the best way to block a program or one of its

include/SFML/System/String.hpp

@@ -461,6 +461,7 @@ private :
 };
 
 ////////////////////////////////////////////////////////////
+/// \relates String
 /// \brief Overload of == operator to compare two UTF-32 strings
 ///
 /// \param left  Left operand (a string)
@@ -472,6 +473,7 @@ private :
 SFML_API bool operator ==(const String& left, const String& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates String
 /// \brief Overload of != operator to compare two UTF-32 strings
 ///
 /// \param left  Left operand (a string)
@@ -483,6 +485,7 @@ SFML_API bool operator ==(const String& left, const String& right);
 SFML_API bool operator !=(const String& left, const String& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates String
 /// \brief Overload of < operator to compare two UTF-32 strings
 ///
 /// \param left  Left operand (a string)
@@ -494,6 +497,7 @@ SFML_API bool operator !=(const String& left, const String& right);
 SFML_API bool operator <(const String& left, const String& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates String
 /// \brief Overload of > operator to compare two UTF-32 strings
 ///
 /// \param left  Left operand (a string)
@@ -505,6 +509,7 @@ SFML_API bool operator <(const String& left, const String& right);
 SFML_API bool operator >(const String& left, const String& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates String
 /// \brief Overload of <= operator to compare two UTF-32 strings
 ///
 /// \param left  Left operand (a string)
@@ -516,6 +521,7 @@ SFML_API bool operator >(const String& left, const String& right);
 SFML_API bool operator <=(const String& left, const String& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates String
 /// \brief Overload of >= operator to compare two UTF-32 strings
 ///
 /// \param left  Left operand (a string)
@@ -527,6 +533,7 @@ SFML_API bool operator <=(const String& left, const String& right);
 SFML_API bool operator >=(const String& left, const String& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates String
 /// \brief Overload of binary + operator to concatenate two strings
 ///
 /// \param left  Left operand (a string)
@@ -545,6 +552,7 @@ SFML_API String operator +(const String& left, const String& right);
 
 ////////////////////////////////////////////////////////////
 /// \class sf::String
+/// \ingroup system
 ///
 /// sf::String is a utility string class defined mainly for
 /// convenience. It is a Unicode string (implemented using

include/SFML/System/Thread.hpp

@@ -135,6 +135,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Thread
+/// \ingroup system
 ///
 /// Threads provide a way to run multiple parts of the code
 /// in parallel. When you launch a new thread, the execution

include/SFML/System/ThreadLocal.hpp

@@ -94,6 +94,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::ThreadLocal
+/// \ingroup system
 ///
 /// This class manipulates void* parameters and thus is not
 /// appropriate for strongly-typed variables. You should rather

include/SFML/System/ThreadLocalPtr.hpp

@@ -112,6 +112,7 @@ public :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::ThreadLocalPtr
+/// \ingroup system
 ///
 /// sf::ThreadLocalPtr is a type-safe wrapper for storing
 /// pointers to thread-local variables. A thread-local

include/SFML/System/Utf.hpp

@@ -38,6 +38,7 @@
 namespace sf
 {
 ////////////////////////////////////////////////////////////
+/// \ingroup system
 /// \brief Get the default system locale
 ///
 /// \return Reference to the default system locale
@@ -670,6 +671,7 @@ typedef Utf<32> Utf32;
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Utf
+/// \ingroup system
 ///
 /// Utility class providing generic functions for UTF conversions.
 ///

include/SFML/System/Vector2.hpp

@@ -61,6 +61,7 @@ public :
 };
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector2
 /// \brief Overload of unary operator -
 ///
 /// \param right Vector to negate
@@ -72,6 +73,7 @@ template <typename T>
 Vector2<T> operator -(const Vector2<T>& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector2
 /// \brief Overload of binary operator +=
 ///
 /// This operator performs a memberwise addition of both vectors,
@@ -87,6 +89,7 @@ template <typename T>
 Vector2<T>& operator +=(Vector2<T>& left, const Vector2<T>& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector2
 /// \brief Overload of binary operator -=
 ///
 /// This operator performs a memberwise subtraction of both vectors,
@@ -102,6 +105,7 @@ template <typename T>
 Vector2<T>& operator -=(Vector2<T>& left, const Vector2<T>& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector2
 /// \brief Overload of binary operator +
 ///
 /// \param left  Left operand (a vector)
@@ -114,6 +118,7 @@ template <typename T>
 Vector2<T> operator +(const Vector2<T>& left, const Vector2<T>& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector2
 /// \brief Overload of binary operator -
 ///
 /// \param left  Left operand (a vector)
@@ -126,6 +131,7 @@ template <typename T>
 Vector2<T> operator -(const Vector2<T>& left, const Vector2<T>& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector2
 /// \brief Overload of binary operator *
 ///
 /// \param left  Left operand (a vector)
@@ -138,6 +144,7 @@ template <typename T>
 Vector2<T> operator *(const Vector2<T>& left, T right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector2
 /// \brief Overload of binary operator *
 ///
 /// \param left  Left operand (a scalar value)
@@ -150,6 +157,7 @@ template <typename T>
 Vector2<T> operator *(T left, const Vector2<T>& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector2
 /// \brief Overload of binary operator *=
 ///
 /// This operator performs a memberwise multiplication by \a right,
@@ -165,6 +173,7 @@ template <typename T>
 Vector2<T>& operator *=(Vector2<T>& left, T right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector2
 /// \brief Overload of binary operator /
 ///
 /// \param left  Left operand (a scalar value)
@@ -177,6 +186,7 @@ template <typename T>
 Vector2<T> operator /(const Vector2<T>& left, T right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector2
 /// \brief Overload of binary operator /=
 ///
 /// This operator performs a memberwise division by \a right,
@@ -192,6 +202,7 @@ template <typename T>
 Vector2<T>& operator /=(Vector2<T>& left, T right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector2
 /// \brief Overload of binary operator ==
 ///
 /// This operator compares strict equality between two vectors.
@@ -206,6 +217,7 @@ template <typename T>
 bool operator ==(const Vector2<T>& left, const Vector2<T>& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector2
 /// \brief Overload of binary operator !=
 ///
 /// This operator compares strict difference between two vectors.
@@ -233,6 +245,7 @@ typedef Vector2<float> Vector2f;
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Vector2
+/// \ingroup system
 ///
 /// sf::Vector2 is a simple class that defines a mathematical
 /// vector with two coordinates (x and y). It can be used to

include/SFML/System/Vector3.hpp

@@ -63,6 +63,7 @@ public :
 };
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector3
 /// \brief Overload of unary operator -
 ///
 /// \param right Vector to negate
@@ -74,6 +75,7 @@ template <typename T>
 Vector3<T> operator -(const Vector3<T>& left);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector3
 /// \brief Overload of binary operator +=
 ///
 /// This operator performs a memberwise addition of both vectors,
@@ -89,6 +91,7 @@ template <typename T>
 Vector3<T>& operator +=(Vector3<T>& left, const Vector3<T>& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector3
 /// \brief Overload of binary operator -=
 ///
 /// This operator performs a memberwise subtraction of both vectors,
@@ -104,6 +107,7 @@ template <typename T>
 Vector3<T>& operator -=(Vector3<T>& left, const Vector3<T>& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector3
 /// \brief Overload of binary operator +
 ///
 /// \param left  Left operand (a vector)
@@ -116,6 +120,7 @@ template <typename T>
 Vector3<T> operator +(const Vector3<T>& left, const Vector3<T>& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector3
 /// \brief Overload of binary operator -
 ///
 /// \param left  Left operand (a vector)
@@ -128,6 +133,7 @@ template <typename T>
 Vector3<T> operator -(const Vector3<T>& left, const Vector3<T>& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector3
 /// \brief Overload of binary operator *
 ///
 /// \param left  Left operand (a vector)
@@ -140,6 +146,7 @@ template <typename T>
 Vector3<T> operator *(const Vector3<T>& left, T right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector3
 /// \brief Overload of binary operator *
 ///
 /// \param left  Left operand (a scalar value)
@@ -152,6 +159,7 @@ template <typename T>
 Vector3<T> operator *(T left, const Vector3<T>& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector3
 /// \brief Overload of binary operator *=
 ///
 /// This operator performs a memberwise multiplication by \a right,
@@ -167,6 +175,7 @@ template <typename T>
 Vector3<T>& operator *=(Vector3<T>& left, T right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector3
 /// \brief Overload of binary operator /
 ///
 /// \param left  Left operand (a scalar value)
@@ -179,6 +188,7 @@ template <typename T>
 Vector3<T> operator /(const Vector3<T>& left, T right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector3
 /// \brief Overload of binary operator /=
 ///
 /// This operator performs a memberwise division by \a right,
@@ -194,6 +204,7 @@ template <typename T>
 Vector3<T>& operator /=(Vector3<T>& left, T right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector3
 /// \brief Overload of binary operator ==
 ///
 /// This operator compares strict equality between two vectors.
@@ -208,6 +219,7 @@ template <typename T>
 bool operator ==(const Vector3<T>& left, const Vector3<T>& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates Vector3
 /// \brief Overload of binary operator !=
 ///
 /// This operator compares strict difference between two vectors.
@@ -235,6 +247,7 @@ typedef Vector3<float> Vector3f;
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Vector3
+/// \ingroup system
 ///
 /// sf::Vector3 is a simple class that defines a mathematical
 /// vector with three coordinates (x, y and z). It can be used to

include/SFML/Window.hpp

@@ -40,3 +40,8 @@
 
 
 #endif // SFML_SFML_WINDOW_HPP
+
+////////////////////////////////////////////////////////////
+/// \defgroup window Window module
+/// 
+////////////////////////////////////////////////////////////

include/SFML/Window/Context.hpp

@@ -98,6 +98,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Context
+/// \ingroup window
 ///
 /// If you need to make OpenGL / graphics calls without
 /// having an active window (like in a thread), you can use

include/SFML/Window/ContextSettings.hpp

@@ -72,6 +72,7 @@ struct ContextSettings
 
 ////////////////////////////////////////////////////////////
 /// \class sf::ContextSettings
+/// \ingroup window
 ///
 /// ContextSettings allows to define several advanced settings
 /// of the OpenGL context attached to a window. All these

include/SFML/Window/Event.hpp

@@ -36,6 +36,7 @@ namespace sf
 namespace Key
 {
     ////////////////////////////////////////////////////////////
+    /// \ingroup window
     /// \brief Definition of key codes for keyboard events
     ///
     ////////////////////////////////////////////////////////////
@@ -151,6 +152,7 @@ namespace Key
 namespace Mouse
 {
     ////////////////////////////////////////////////////////////
+    /// \ingroup window
     /// \brief Definition of button codes for mouse events
     ///
     ////////////////////////////////////////////////////////////
@@ -170,6 +172,7 @@ namespace Mouse
 namespace Joy
 {
     ////////////////////////////////////////////////////////////
+    /// \ingroup window
     /// \brief Definition of joystick axis for joystick events
     ///
     ////////////////////////////////////////////////////////////
@@ -340,6 +343,7 @@ public :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Event
+/// \ingroup window
 ///
 /// sf::Event holds all the informations about a system event
 /// that just happened. Events are retrieved using the

include/SFML/Window/Input.hpp

@@ -159,6 +159,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Input
+/// \ingroup window
 ///
 /// sf::Input provides a way to access the state of keys,
 /// mouse buttons, mouse position, joystick buttons and

include/SFML/Window/VideoMode.hpp

@@ -105,6 +105,7 @@ public :
 };
 
 ////////////////////////////////////////////////////////////
+/// \relates VideoMode
 /// \brief Overload of == operator to compare two video modes
 ///
 /// \param left  Left operand (a video mode)
@@ -116,6 +117,7 @@ public :
 SFML_API bool operator ==(const VideoMode& left, const VideoMode& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates VideoMode
 /// \brief Overload of != operator to compare two video modes
 ///
 /// \param left  Left operand (a video mode)
@@ -127,6 +129,7 @@ SFML_API bool operator ==(const VideoMode& left, const VideoMode& right);
 SFML_API bool operator !=(const VideoMode& left, const VideoMode& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates VideoMode
 /// \brief Overload of < operator to compare video modes
 ///
 /// \param left  Left operand (a video mode)
@@ -138,6 +141,7 @@ SFML_API bool operator !=(const VideoMode& left, const VideoMode& right);
 SFML_API bool operator <(const VideoMode& left, const VideoMode& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates VideoMode
 /// \brief Overload of > operator to compare video modes
 ///
 /// \param left  Left operand (a video mode)
@@ -149,6 +153,7 @@ SFML_API bool operator <(const VideoMode& left, const VideoMode& right);
 SFML_API bool operator >(const VideoMode& left, const VideoMode& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates VideoMode
 /// \brief Overload of <= operator to compare video modes
 ///
 /// \param left  Left operand (a video mode)
@@ -160,6 +165,7 @@ SFML_API bool operator >(const VideoMode& left, const VideoMode& right);
 SFML_API bool operator <=(const VideoMode& left, const VideoMode& right);
 
 ////////////////////////////////////////////////////////////
+/// \relates VideoMode
 /// \brief Overload of >= operator to compare video modes
 ///
 /// \param left  Left operand (a video mode)
@@ -178,6 +184,7 @@ SFML_API bool operator >=(const VideoMode& left, const VideoMode& right);
 
 ////////////////////////////////////////////////////////////
 /// \class sf::VideoMode
+/// \ingroup window
 ///
 /// A video mode is defined by a width and a height (in pixels)
 /// and a depth (in bits per pixel). Video modes are used to

include/SFML/Window/Window.hpp

@@ -510,6 +510,7 @@ private :
 
 ////////////////////////////////////////////////////////////
 /// \class sf::Window
+/// \ingroup window
 ///
 /// sf::Window is the main class of the Window module. It defines
 /// an OS window that is able to receive an OpenGL rendering.

include/SFML/Window/WindowStyle.hpp

@@ -31,6 +31,7 @@ namespace sf
 namespace Style
 {
     ////////////////////////////////////////////////////////////
+    /// \ingroup window
     /// \brief Enumeration of the window styles
     ///
     ////////////////////////////////////////////////////////////