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/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