qrgbafloat.qdoc

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only
 
/*!
    \class QRgbaFloat
    \brief The QRgbaFloat struct contains a four part RGBA floating-point color.
    \since 6.2
 
    \ingroup painting
    \inmodule QtGui
 
    QRgbaFloat is a template class where \a F specifies the floating-point type
    used for the color components. Qt provides two type aliases: QRgbaFloat16
    using 16-bit half-precision floats, and QRgbaFloat32 using 32-bit
    single-precision floats.
 
    \sa QRgb, QRgba64, QColor
*/
 
/*!
    \typealias QRgbaFloat::FastType
 
    Alias for \e float.
*/
 
/*!
    \typedef QRgbaFloat16
    \relates QRgbaFloat
 
    A 64-bit data-structure containing four 16-bit floating point color channels: Red, green, blue and alpha.
*/
 
/*!
    \typedef QRgbaFloat32
    \relates QRgbaFloat
 
    A 128-bit data-structure containing four 32-bit floating point color channels: Red, green, blue and alpha.
*/
 
/*!
    \fn template<typename F> QRgbaFloat QRgbaFloat<F>::fromRgba64(quint16 red, quint16 green, quint16 blue, quint16 alpha)
 
    Constructs a QRgbaFloat  value from the four 16-bit integer color channels \a red, \a green, \a blue and \a alpha.
 
    \sa fromRgba()
*/
 
/*!
    \fn template<typename F> QRgbaFloat QRgbaFloat<F>::fromRgba(quint8 red, quint8 green, quint8 blue, quint8 alpha)
 
    Constructs a QRgbaFloat  value from the four 8-bit color channels \a red, \a green, \a blue and \a alpha.
 
    \sa fromArgb32()
*/
 
/*!
    \fn template<typename F> QRgbaFloat QRgbaFloat<F>::fromArgb32(uint rgb)
 
    Constructs a QRgbaFloat  value from the 32bit ARGB value \a rgb.
 
    \sa fromRgba(), toArgb32()
*/
 
/*!
    \fn template<typename F> bool QRgbaFloat<F>::isOpaque() const
 
    Returns whether the color is fully opaque.
 
    \sa isTransparent(), alpha()
*/
 
/*!
    \fn template<typename F> bool QRgbaFloat<F>::isTransparent() const
 
    Returns whether the color is fully transparent.
 
    \sa isOpaque(), alpha()
*/
 
/*!
    \fn template<typename F> float QRgbaFloat<F>::red() const
 
    Returns the red color component.
 
    \sa setRed()
*/
 
/*!
    \fn template<typename F> void QRgbaFloat<F>::setRed(float red)
 
    Sets the red color component of this color to \a red.
 
    \sa red()
*/
 
/*!
    \fn template<typename F> float QRgbaFloat<F>::green() const
 
    Returns the green color component.
 
    \sa setGreen()
*/
 
/*!
    \fn template<typename F> void QRgbaFloat<F>::setGreen(float green)
 
    Sets the green color component of this color to \a green.
 
    \sa green()
*/
 
/*!
    \fn template<typename F> float QRgbaFloat<F>::blue() const
 
    Returns the blue color component.
 
    \sa setBlue()
*/
 
/*!
    \fn template<typename F> void QRgbaFloat<F>::setBlue(float blue)
 
    Sets the blue color component of this color to \a blue.
 
    \sa blue()
*/
 
/*!
    \fn template<typename F> float QRgbaFloat<F>::alpha() const
 
    Returns the alpha channel.
 
    \sa setAlpha()
*/
 
/*!
    \fn template<typename F> void QRgbaFloat<F>::setAlpha(float alpha)
 
    Sets the alpha of this color to \a alpha.
 
    \sa alpha()
*/
 
/*!
    \fn template<typename F> float QRgbaFloat<F>::redNormalized() const
 
    Returns the red color component normalized to values between \c 0.0f and \c 1.0f.
 
    \sa setRed()
*/
 
/*!
    \fn template<typename F> float QRgbaFloat<F>::greenNormalized() const
 
    Returns the green color component normalized to values between \c 0.0f and \c 1.0f.
 
    \sa setGreen()
*/
 
/*!
    \fn template<typename F> float QRgbaFloat<F>::blueNormalized() const
 
    Returns the blue color component normalized to values between \c 0.0f and \c 1.0f.
 
    \sa setBlue()
*/
 
/*!
    \fn template<typename F> float QRgbaFloat<F>::alphaNormalized() const
 
    Returns the alpha channel normalized to values between \c 0.0f and \c 1.0f.
 
    \sa alpha()
*/
 
/*!
    \fn template<typename F> quint8 QRgbaFloat<F>::red8() const
 
    Returns the red color component as an 8-bit.
*/
 
/*!
    \fn template<typename F> quint8 QRgbaFloat<F>::green8() const
 
    Returns the green color component as an 8-bit.
*/
 
/*!
    \fn template<typename F> quint8 QRgbaFloat<F>::blue8() const
 
    Returns the blue color component as an 8-bit.
*/
 
/*!
    \fn template<typename F> quint8 QRgbaFloat<F>::alpha8() const
 
    Returns the alpha channel as an 8-bit.
*/
 
/*!
    \fn template<typename F> uint QRgbaFloat<F>::toArgb32() const
 
    Returns the color as a 32-bit ARGB value.
 
    \sa fromArgb32()
*/
 
/*!
    \fn template<typename F> quint16 QRgbaFloat<F>::red16() const
 
    Returns the red color component as a 16-bit integer.
*/
 
/*!
    \fn template<typename F> quint16 QRgbaFloat<F>::green16() const
 
    Returns the green color component as a 16-bit integer.
*/
 
/*!
    \fn template<typename F> quint16 QRgbaFloat<F>::blue16() const
 
    Returns the blue color component as a 16-bit integer.
*/
 
/*!
    \fn template<typename F> quint16 QRgbaFloat<F>::alpha16() const
 
    Returns the alpha channel as a 16-bit integer.
*/
 
/*!
    \fn template<typename F> QRgbaFloat QRgbaFloat<F>::premultiplied() const
 
    Returns the color with the alpha premultiplied.
 
    \sa unpremultiplied()
*/
 
/*!
    \fn template<typename F> QRgbaFloat QRgbaFloat<F>::unpremultiplied() const
 
    Returns the color with the alpha unpremultiplied.
 
    \sa premultiplied()
*/