Underscore private MAGNUM_* macros to not leak into autocompletion.

The MAGNUM_GL_ABSTRACTSHADERPROGRAM_SUBCLASS_DRAW_IMPLEMENTATION() and MAGNUM_GL_ABSTRACTSHADERPROGRAM_SUBCLASS_DISPATCH_IMPLEMENTATION() *is* documented so that one stays not underscored.
1 year ago · 7eb520f77a
29 changed files with 58 additions and 58 deletions
--- a/src/Magnum/GL/Context.h
+++ b/src/Magnum/GL/Context.h
@ -1159,7 +1159,7 @@ class MAGNUM_GL_EXPORT Context::Configuration {
 };

 #ifndef DOXYGEN_GENERATING_OUTPUT
-#define MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(Type)       \
+#define _MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(Type)      \
    Type& addDisabledWorkarounds(const Containers::StringIterable& workarounds) { \
        GL::Context::Configuration::addDisabledWorkarounds(workarounds);    \
        return *this;                                                       \
--- a/src/Magnum/Math/Color.h
+++ b/src/Magnum/Math/Color.h
@ -764,11 +764,11 @@ template<class T> class Color3: public Vector3<T> {
            return Implementation::toXyz<T>(*this);
        }

-        MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(3, Color3)
+        _MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(3, Color3)
 };

 #ifdef CORRADE_MSVC2015_COMPATIBILITY
-MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(3, Color3)
+_MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(3, Color3)
 #endif

 /**
@ -1292,11 +1292,11 @@ class Color4: public Vector4<T> {
        constexpr const Color3<T> rgb() const { return xyz(); }
        #endif

-        MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(4, Color4)
+        _MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(4, Color4)
 };

 #ifdef CORRADE_MSVC2015_COMPATIBILITY
-MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(4, Color4)
+_MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(4, Color4)
 #endif

 /** @relatesalso Color3
--- a/src/Magnum/Math/Dual.h
+++ b/src/Magnum/Math/Dual.h
@ -344,7 +344,7 @@ template<class T, class U
 }

 #ifndef DOXYGEN_GENERATING_OUTPUT
-#define MAGNUM_DUAL_SUBCLASS_IMPLEMENTATION(Type, Underlying, Multiplicable) \
+#define _MAGNUM_DUAL_SUBCLASS_IMPLEMENTATION(Type, Underlying, Multiplicable) \
    Type<T> operator+() const {                                             \
        return Math::Dual<Underlying<T>>::operator+();                      \
    }                                                                       \
@ -379,7 +379,7 @@ template<class T, class U
    }

 /* DualComplex needs its own special implementation of multiplication/division */
-#define MAGNUM_DUAL_SUBCLASS_MULTIPLICATION_IMPLEMENTATION(Type, Underlying) \
+#define _MAGNUM_DUAL_SUBCLASS_MULTIPLICATION_IMPLEMENTATION(Type, Underlying) \
    template<class U> Type<T> operator*(const Math::Dual<U>& other) const { \
        return Math::Dual<Underlying<T>>::operator*(other);                 \
    }                                                                       \
@ -393,7 +393,7 @@ template<class T, class U
        return Math::Dual<Underlying<T>>::operator/(other);                 \
    }

-#define MAGNUM_DUAL_OPERATOR_IMPLEMENTATION(Type, Underlying, Multiplicable) \
+#define _MAGNUM_DUAL_OPERATOR_IMPLEMENTATION(Type, Underlying, Multiplicable) \
    template<class T> inline Type<T> operator*(const Math::Dual<Multiplicable>& a, const Type<T>& b) { \
        return a*static_cast<const Math::Dual<Underlying<T>>&>(b);          \
    }                                                                       \
--- a/src/Magnum/Math/DualComplex.h
+++ b/src/Magnum/Math/DualComplex.h
@ -401,12 +401,12 @@ template<class T> class DualComplex: public Dual<Complex<T>> {
            return Vector2<T>(((*this)*DualComplex<T>(vector)).dual());
        }

-        MAGNUM_DUAL_SUBCLASS_IMPLEMENTATION(DualComplex, Vector2, T)
-        /* Not using MAGNUM_DUAL_SUBCLASS_MULTIPLICATION_IMPLEMENTATION(), as
+        _MAGNUM_DUAL_SUBCLASS_IMPLEMENTATION(DualComplex, Vector2, T)
+        /* Not using _MAGNUM_DUAL_SUBCLASS_MULTIPLICATION_IMPLEMENTATION(), as
           we have special multiplication/division implementation */
 };

-MAGNUM_DUAL_OPERATOR_IMPLEMENTATION(DualComplex, Vector2, T)
+_MAGNUM_DUAL_OPERATOR_IMPLEMENTATION(DualComplex, Vector2, T)

 #ifndef CORRADE_SINGLES_NO_DEBUG
 /** @debugoperator{DualComplex} */
--- a/src/Magnum/Math/DualQuaternion.h
+++ b/src/Magnum/Math/DualQuaternion.h
@ -565,11 +565,11 @@ template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
            return ((*this)*DualQuaternion<T>(vector)*conjugated()).dual().vector();
        }

-        MAGNUM_DUAL_SUBCLASS_IMPLEMENTATION(DualQuaternion, Quaternion, T)
-        MAGNUM_DUAL_SUBCLASS_MULTIPLICATION_IMPLEMENTATION(DualQuaternion, Quaternion)
+        _MAGNUM_DUAL_SUBCLASS_IMPLEMENTATION(DualQuaternion, Quaternion, T)
+        _MAGNUM_DUAL_SUBCLASS_MULTIPLICATION_IMPLEMENTATION(DualQuaternion, Quaternion)
 };

-MAGNUM_DUAL_OPERATOR_IMPLEMENTATION(DualQuaternion, Quaternion, T)
+_MAGNUM_DUAL_OPERATOR_IMPLEMENTATION(DualQuaternion, Quaternion, T)

 #ifndef CORRADE_SINGLES_NO_DEBUG
 /** @debugoperator{DualQuaternion} */
--- a/src/Magnum/Math/Matrix.h
+++ b/src/Magnum/Math/Matrix.h
@ -307,7 +307,7 @@ template<std::size_t size, class T> class Matrix: public RectangularMatrix<size,
        Matrix<size, T> transposed() const {
            return RectangularMatrix<size, size, T>::transposed();
        }
-        MAGNUM_RECTANGULARMATRIX_SUBCLASS_IMPLEMENTATION(size, size, Matrix<size, T>)
+        _MAGNUM_RECTANGULARMATRIX_SUBCLASS_IMPLEMENTATION(size, size, Matrix<size, T>)
        #endif

    private:
@ -352,10 +352,10 @@ additional functions for transformations in 3D.
 template<class T> using Matrix4x4 = Matrix<4, T>;
 #endif

-MAGNUM_MATRIX_OPERATOR_IMPLEMENTATION(Matrix<size, T>)
+_MAGNUM_MATRIX_OPERATOR_IMPLEMENTATION(Matrix<size, T>)

 #ifndef DOXYGEN_GENERATING_OUTPUT
-#define MAGNUM_MATRIX_SUBCLASS_IMPLEMENTATION(size, Type, VectorType)       \
+#define _MAGNUM_MATRIX_SUBCLASS_IMPLEMENTATION(size, Type, VectorType)      \
    VectorType<T>& operator[](std::size_t col) {                            \
        return static_cast<VectorType<T>&>(Matrix<size, T>::operator[](col)); \
    }                                                                       \
--- a/src/Magnum/Math/Matrix3.h
+++ b/src/Magnum/Math/Matrix3.h
@ -747,12 +747,12 @@ template<class T> class Matrix3: public Matrix3x3<T> {
            return ((*this)*Vector3<T>(vector, T(1))).xy();
        }

-        MAGNUM_RECTANGULARMATRIX_SUBCLASS_IMPLEMENTATION(3, 3, Matrix3<T>)
-        MAGNUM_MATRIX_SUBCLASS_IMPLEMENTATION(3, Matrix3, Vector3)
+        _MAGNUM_RECTANGULARMATRIX_SUBCLASS_IMPLEMENTATION(3, 3, Matrix3<T>)
+        _MAGNUM_MATRIX_SUBCLASS_IMPLEMENTATION(3, Matrix3, Vector3)
 };

 #ifndef DOXYGEN_GENERATING_OUTPUT
-MAGNUM_MATRIXn_OPERATOR_IMPLEMENTATION(3, Matrix3)
+_MAGNUM_MATRIXn_OPERATOR_IMPLEMENTATION(3, Matrix3)
 #endif

 template<class T> Matrix3<T> Matrix3<T>::rotation(const Rad<T> angle) {
--- a/src/Magnum/Math/Matrix4.h
+++ b/src/Magnum/Math/Matrix4.h
@ -1192,12 +1192,12 @@ template<class T> class Matrix4: public Matrix4x4<T> {
            return transformed.xyz()/transformed.w();
        }

-        MAGNUM_RECTANGULARMATRIX_SUBCLASS_IMPLEMENTATION(4, 4, Matrix4<T>)
-        MAGNUM_MATRIX_SUBCLASS_IMPLEMENTATION(4, Matrix4, Vector4)
+        _MAGNUM_RECTANGULARMATRIX_SUBCLASS_IMPLEMENTATION(4, 4, Matrix4<T>)
+        _MAGNUM_MATRIX_SUBCLASS_IMPLEMENTATION(4, Matrix4, Vector4)
 };

 #ifndef DOXYGEN_GENERATING_OUTPUT
-MAGNUM_MATRIXn_OPERATOR_IMPLEMENTATION(4, Matrix4)
+_MAGNUM_MATRIXn_OPERATOR_IMPLEMENTATION(4, Matrix4)
 #endif

 template<class T> Matrix4<T> Matrix4<T>::rotation(const Rad<T> angle, const Vector3<T>& normalizedAxis) {
--- a/src/Magnum/Math/Range.h
+++ b/src/Magnum/Math/Range.h
@ -395,7 +395,7 @@ template<UnsignedInt dimensions, class T> class Range {
 };

 #ifndef DOXYGEN_GENERATING_OUTPUT
-#define MAGNUM_RANGE_SUBCLASS_IMPLEMENTATION(dimensions, Type, VectorType)  \
+#define _MAGNUM_RANGE_SUBCLASS_IMPLEMENTATION(dimensions, Type, VectorType)  \
    static Type<T> fromSize(const VectorType<T>& min, const VectorType<T>& size) { \
        return Range<dimensions, T>::fromSize(min, size);                   \
    }                                                                       \
@ -581,7 +581,7 @@ template<class T> class Range2D: public Range<2, T> {
            return (Range<2, T>::min().y() + Range<2, T>::max().y())/T(2);
        }

-        MAGNUM_RANGE_SUBCLASS_IMPLEMENTATION(2, Range2D, Vector2)
+        _MAGNUM_RANGE_SUBCLASS_IMPLEMENTATION(2, Range2D, Vector2)
 };

 /**
@ -780,7 +780,7 @@ template<class T> class Range3D: public Range<3, T> {
            return (Range<3, T>::min().z() + Range<3, T>::max().z())/T(2);
        }

-        MAGNUM_RANGE_SUBCLASS_IMPLEMENTATION(3, Range3D, Vector3)
+        _MAGNUM_RANGE_SUBCLASS_IMPLEMENTATION(3, Range3D, Vector3)
 };

 /** @relatesalso Range
--- a/src/Magnum/Math/RectangularMatrix.h
+++ b/src/Magnum/Math/RectangularMatrix.h
@ -811,7 +811,7 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const RectangularMatrix<
 #endif

 #ifndef DOXYGEN_GENERATING_OUTPUT
-#define MAGNUM_RECTANGULARMATRIX_SUBCLASS_IMPLEMENTATION(cols, rows, ...)   \
+#define _MAGNUM_RECTANGULARMATRIX_SUBCLASS_IMPLEMENTATION(cols, rows, ...)  \
    static __VA_ARGS__& from(T* data) {                                     \
        return *reinterpret_cast<__VA_ARGS__*>(data);                       \
    }                                                                       \
@ -866,7 +866,7 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const RectangularMatrix<
 /* Unlike with Vector, these are kept non-member and non-friend as it'd mean
   too many macro combinations otherwise */

-#define MAGNUM_MATRIX_OPERATOR_IMPLEMENTATION(...)                          \
+#define _MAGNUM_MATRIX_OPERATOR_IMPLEMENTATION(...)                         \
    template<std::size_t size, class T> inline __VA_ARGS__ operator*(typename std::common_type<T>::type number, const __VA_ARGS__& matrix) { \
        return number*static_cast<const Math::RectangularMatrix<size, size, T>&>(matrix); \
    }                                                                       \
@ -877,7 +877,7 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const RectangularMatrix<
        return Math::RectangularMatrix<1, size, T>(vector)*matrix;          \
    }

-#define MAGNUM_MATRIXn_OPERATOR_IMPLEMENTATION(size, Type)                  \
+#define _MAGNUM_MATRIXn_OPERATOR_IMPLEMENTATION(size, Type)                 \
    template<class T> inline Type<T> operator*(typename std::common_type<T>::type number, const Type<T>& matrix) { \
        return number*static_cast<const Math::RectangularMatrix<size, size, T>&>(matrix); \
    }                                                                       \
--- a/src/Magnum/Math/Test/DualTest.cpp
+++ b/src/Magnum/Math/Test/DualTest.cpp
@ -323,11 +323,11 @@ template<class T> class BasicDualVec2: public Math::Dual<Math::Vector2<T>> {
    public:
        template<class ...U> constexpr BasicDualVec2(U&&... args): Math::Dual<Math::Vector2<T>>{args...} {}

-        MAGNUM_DUAL_SUBCLASS_IMPLEMENTATION(BasicDualVec2, Math::Vector2, T)
-        MAGNUM_DUAL_SUBCLASS_MULTIPLICATION_IMPLEMENTATION(BasicDualVec2, Math::Vector2)
+        _MAGNUM_DUAL_SUBCLASS_IMPLEMENTATION(BasicDualVec2, Math::Vector2, T)
+        _MAGNUM_DUAL_SUBCLASS_MULTIPLICATION_IMPLEMENTATION(BasicDualVec2, Math::Vector2)
 };

-MAGNUM_DUAL_OPERATOR_IMPLEMENTATION(BasicDualVec2, Math::Vector2, T)
+_MAGNUM_DUAL_OPERATOR_IMPLEMENTATION(BasicDualVec2, Math::Vector2, T)

 typedef BasicDualVec2<Float> DualVec2;

--- a/src/Magnum/Math/Test/MatrixTest.cpp
+++ b/src/Magnum/Math/Test/MatrixTest.cpp
@ -575,7 +575,7 @@ template<class T> class BasicMat2: public Math::Matrix<2, T> {
    public:
        template<class ...U> constexpr BasicMat2(U&&... args): Math::Matrix<2, T>{args...} {}

-        MAGNUM_MATRIX_SUBCLASS_IMPLEMENTATION(2, BasicMat2, BasicVec2)
+        _MAGNUM_MATRIX_SUBCLASS_IMPLEMENTATION(2, BasicMat2, BasicVec2)
 };

 typedef BasicVec2<Float> Vec2;
--- a/src/Magnum/Math/Test/RangeTest.cpp
+++ b/src/Magnum/Math/Test/RangeTest.cpp
@ -968,7 +968,7 @@ template<class T> class BasicRect: public Math::Range<2, T> {
    public:
        template<class ...U> constexpr BasicRect(U&&... args): Math::Range<2, T>{args...} {}

-        MAGNUM_RANGE_SUBCLASS_IMPLEMENTATION(2, BasicRect, Vector2)
+        _MAGNUM_RANGE_SUBCLASS_IMPLEMENTATION(2, BasicRect, Vector2)
 };

 typedef BasicRect<Int> Recti;
--- a/src/Magnum/Math/Test/RectangularMatrixTest.cpp
+++ b/src/Magnum/Math/Test/RectangularMatrixTest.cpp
@ -815,19 +815,19 @@ template<std::size_t size, class T> class BasicMat: public Math::RectangularMatr
    public:
        template<class ...U> constexpr BasicMat(U&&... args): Math::RectangularMatrix<size, size, T>{args...} {}

-        MAGNUM_RECTANGULARMATRIX_SUBCLASS_IMPLEMENTATION(size, size, BasicMat<size, T>)
+        _MAGNUM_RECTANGULARMATRIX_SUBCLASS_IMPLEMENTATION(size, size, BasicMat<size, T>)
 };

-MAGNUM_MATRIX_OPERATOR_IMPLEMENTATION(BasicMat<size, T>)
+_MAGNUM_MATRIX_OPERATOR_IMPLEMENTATION(BasicMat<size, T>)

 template<class T> class BasicMat2x2: public BasicMat<2, T> {
    public:
        template<class ...U> constexpr BasicMat2x2(U&&... args): BasicMat<2, T>{args...} {}

-        MAGNUM_RECTANGULARMATRIX_SUBCLASS_IMPLEMENTATION(2, 2, BasicMat2x2<T>)
+        _MAGNUM_RECTANGULARMATRIX_SUBCLASS_IMPLEMENTATION(2, 2, BasicMat2x2<T>)
 };

-MAGNUM_MATRIXn_OPERATOR_IMPLEMENTATION(2, BasicMat2x2)
+_MAGNUM_MATRIXn_OPERATOR_IMPLEMENTATION(2, BasicMat2x2)

 typedef BasicMat2x2<Float> Mat2x2;

--- a/src/Magnum/Math/Test/VectorTest.cpp
+++ b/src/Magnum/Math/Test/VectorTest.cpp
@ -896,11 +896,11 @@ template<class T> class BasicVec2: public Math::Vector<2, T> {
    public:
        template<class ...U> constexpr BasicVec2(U&&... args): Math::Vector<2, T>{args...} {}

-        MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(2, BasicVec2)
+        _MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(2, BasicVec2)
 };

 #ifdef CORRADE_MSVC2015_COMPATIBILITY
-MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(2, BasicVec2)
+_MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(2, BasicVec2)
 #endif

 typedef BasicVec2<Float> Vec2;
--- a/src/Magnum/Math/Vector.h
+++ b/src/Magnum/Math/Vector.h
@ -1341,7 +1341,7 @@ extern template MAGNUM_EXPORT Debug& operator<<(Debug&, const Vector<4, Double>&
 #endif

 #ifndef DOXYGEN_GENERATING_OUTPUT
-#define MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(size, Type_)                  \
+#define _MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(size, Type_)                 \
    static Type_<T>& from(T* data) {                                        \
        return *reinterpret_cast<Type_<T>*>(data);                          \
    }                                                                       \
@ -1530,7 +1530,7 @@ template<std::size_t size, class FloatingPoint, class Integral, typename std::en
    return vector*scalar;
 }

-#define MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(size, Type)                   \
+#define _MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(size, Type)                 \
    template<class FloatingPoint, class Integral, typename std::enable_if<std::is_integral<Integral>::value && std::is_floating_point<FloatingPoint>::value, int>::type = 0> constexpr Type<Integral> operator*(FloatingPoint scalar, const Type<Integral>& vector) { \
        return vector*scalar;                                               \
    }
--- a/src/Magnum/Math/Vector2.h
+++ b/src/Magnum/Math/Vector2.h
@ -238,14 +238,14 @@ template<class T> class Vector2: public Vector<2, T> {
        #endif
        T aspectRatio() const { return x()/y(); }

-        MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(2, Vector2)
+        _MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(2, Vector2)

    private:
        template<class U> friend U cross(const Vector2<U>&, const Vector2<U>&);
 };

 #ifdef CORRADE_MSVC2015_COMPATIBILITY
-MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(2, Vector2)
+_MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(2, Vector2)
 #endif

 namespace Implementation {
--- a/src/Magnum/Math/Vector3.h
+++ b/src/Magnum/Math/Vector3.h
@ -276,14 +276,14 @@ template<class T> class Vector3: public Vector<3, T> {
            return {Vector<3, T>::_data[0], Vector<3, T>::_data[1]};
        }

-        MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(3, Vector3)
+        _MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(3, Vector3)

    private:
        template<class U> friend Vector3<U> cross(const Vector3<U>&, const Vector3<U>&);
 };

 #ifdef CORRADE_MSVC2015_COMPATIBILITY
-MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(3, Vector3)
+_MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(3, Vector3)
 #endif

 #ifndef MAGNUM_NO_MATH_STRICT_WEAK_ORDERING
--- a/src/Magnum/Math/Vector4.h
+++ b/src/Magnum/Math/Vector4.h
@ -258,11 +258,11 @@ template<class T> class Vector4: public Vector<4, T> {
            return {Vector<4, T>::_data[0], Vector<4, T>::_data[1]};
        }

-        MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(4, Vector4)
+        _MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(4, Vector4)
 };

 #ifdef CORRADE_MSVC2015_COMPATIBILITY
-MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(4, Vector4)
+_MAGNUM_VECTORn_OPERATOR_IMPLEMENTATION(4, Vector4)
 #endif

 /** @relatesalso Vector4
--- a/src/Magnum/Platform/AbstractXApplication.h
+++ b/src/Magnum/Platform/AbstractXApplication.h
@ -1019,7 +1019,7 @@ class AbstractXApplication::GLConfiguration: public GL::Context::Configuration {

        /* Overloads to remove WTF-factor from method chaining order */
        #ifndef DOXYGEN_GENERATING_OUTPUT
-        MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(GLConfiguration)
+        _MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(GLConfiguration)
        #endif

    private:
--- a/src/Magnum/Platform/AndroidApplication.h
+++ b/src/Magnum/Platform/AndroidApplication.h
@ -851,7 +851,7 @@ class AndroidApplication::GLConfiguration: public GL::Context::Configuration {

        /* Overloads to remove WTF-factor from method chaining order */
        #ifndef DOXYGEN_GENERATING_OUTPUT
-        MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(GLConfiguration)
+        _MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(GLConfiguration)
        #endif

    private:
--- a/src/Magnum/Platform/EmscriptenApplication.h
+++ b/src/Magnum/Platform/EmscriptenApplication.h
@ -1724,7 +1724,7 @@ class EmscriptenApplication::GLConfiguration: public GL::Context::Configuration

        /* Overloads to remove WTF-factor from method chaining order */
        #ifndef DOXYGEN_GENERATING_OUTPUT
-        MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(GLConfiguration)
+        _MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(GLConfiguration)
        #endif

    private:
--- a/src/Magnum/Platform/GlfwApplication.h
+++ b/src/Magnum/Platform/GlfwApplication.h
@ -1602,7 +1602,7 @@ class GlfwApplication::GLConfiguration: public GL::Context::Configuration {

        /* Overloads to remove WTF-factor from method chaining order */
        #ifndef DOXYGEN_GENERATING_OUTPUT
-        MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(GLConfiguration)
+        _MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(GLConfiguration)
        #endif

    private:
--- a/src/Magnum/Platform/Sdl2Application.h
+++ b/src/Magnum/Platform/Sdl2Application.h
@ -2235,7 +2235,7 @@ class Sdl2Application::GLConfiguration: public GL::Context::Configuration {

        /* Overloads to remove WTF-factor from method chaining order */
        #ifndef DOXYGEN_GENERATING_OUTPUT
-        MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(GLConfiguration)
+        _MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(GLConfiguration)
        #endif

    private:
--- a/src/Magnum/Platform/WindowlessCglApplication.h
+++ b/src/Magnum/Platform/WindowlessCglApplication.h
@ -277,7 +277,7 @@ class WindowlessCglContext::Configuration: public GL::Context::Configuration {

        /* Overloads to remove WTF-factor from method chaining order */
        #ifndef DOXYGEN_GENERATING_OUTPUT
-        MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(Configuration)
+        _MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(Configuration)
        #endif

    private:
--- a/src/Magnum/Platform/WindowlessEglApplication.h
+++ b/src/Magnum/Platform/WindowlessEglApplication.h
@ -408,7 +408,7 @@ class WindowlessEglContext::Configuration: public GL::Context::Configuration {

        /* Overloads to remove WTF-factor from method chaining order */
        #ifndef DOXYGEN_GENERATING_OUTPUT
-        MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(Configuration)
+        _MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(Configuration)
        #endif

    private:
--- a/src/Magnum/Platform/WindowlessGlxApplication.h
+++ b/src/Magnum/Platform/WindowlessGlxApplication.h
@ -331,7 +331,7 @@ class WindowlessGlxContext::Configuration: public GL::Context::Configuration {

        /* Overloads to remove WTF-factor from method chaining order */
        #ifndef DOXYGEN_GENERATING_OUTPUT
-        MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(Configuration)
+        _MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(Configuration)
        #endif

    private:
--- a/src/Magnum/Platform/WindowlessIosApplication.h
+++ b/src/Magnum/Platform/WindowlessIosApplication.h
@ -244,7 +244,7 @@ class WindowlessIosContext::Configuration: public GL::Context::Configuration {

        /* Overloads to remove WTF-factor from method chaining order */
        #ifndef DOXYGEN_GENERATING_OUTPUT
-        MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(Configuration)
+        _MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(Configuration)
        #endif
 };

--- a/src/Magnum/Platform/WindowlessWglApplication.h
+++ b/src/Magnum/Platform/WindowlessWglApplication.h
@ -318,7 +318,7 @@ class WindowlessWglContext::Configuration: public GL::Context::Configuration {

        /* Overloads to remove WTF-factor from method chaining order */
        #ifndef DOXYGEN_GENERATING_OUTPUT
-        MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(Configuration)
+        _MAGNUM_GL_CONTEXT_CONFIGURATION_SUBCLASS_IMPLEMENTATION(Configuration)
        #endif

    private: