/* This file is autogenerated. DO NOT CHANGE. All changes will be lost */


#include "QtGui/QtGui.qpb.h"

#include <QtProtobuf/qprotobufregistration.h>

#include <cmath>

QT_BEGIN_NAMESPACE
namespace QtProtobufPrivate::QtGui {

class QRgba64_QtProtobufData : public QSharedData
{
public:
    QRgba64_QtProtobufData()
        : QSharedData(),
          m_rgba64(0)
    {
    }

    QRgba64_QtProtobufData(const QRgba64_QtProtobufData &other)
        : QSharedData(other),
          m_rgba64(other.m_rgba64)
    {
    }

    QtProtobuf::uint64 m_rgba64;
};

QRgba64::~QRgba64() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_QRgba64_uint_data;
    const char qt_protobuf_QRgba64_char_data[22];
} qt_protobuf_QRgba64_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        13, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        14, /* = rgba64 */
        21, /* = end-of-string-marker */
        // Field numbers:
        1, /* = rgba64 */
        // Property indices:
        0, /* = rgba64 */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = rgba64 */
    },
    // char_data
    /* metadata char_data: */
    "QtGui.QRgba64\0" /* = full message name */
    /* field char_data: */
    "rgba64\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering QRgba64::staticPropertyOrdering = {
    &qt_protobuf_QRgba64_metadata.data
};

void QRgba64::registerTypes()
{
    qRegisterMetaType<QRgba64>();
    qRegisterMetaType<QList<QRgba64>>();
}

QRgba64::QRgba64()
    : QProtobufMessage(&QRgba64::staticMetaObject, &QRgba64::staticPropertyOrdering),
      dptr(new QRgba64_QtProtobufData)
{
}

QRgba64::QRgba64(const QRgba64 &other)
    = default;
QRgba64 &QRgba64::operator =(const QRgba64 &other)
{
    QRgba64 temp(other);
    swap(temp);
    return *this;
}
QRgba64::QRgba64(QRgba64 &&other) noexcept
    = default;
QRgba64::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
bool comparesEqual(const QRgba64 &lhs, const QRgba64 &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_rgba64 == rhs.dptr->m_rgba64;
}

QtProtobuf::uint64 QRgba64::rgba64() const
{
    return dptr->m_rgba64;
}

void QRgba64::setRgba64(QtProtobuf::uint64 rgba64)
{
    if (dptr->m_rgba64 != rgba64) {
        dptr.detach();
        dptr->m_rgba64 = rgba64;
    }
}


class QColor_QtProtobufData : public QSharedData
{
public:
    QColor_QtProtobufData()
        : QSharedData()
    {
    }

    QColor_QtProtobufData(const QColor_QtProtobufData &other)
        : QSharedData(other),
          m_color(other.m_color)
    {
    }

    QtProtobufPrivate::QProtobufOneof m_color;
};

QColor::~QColor() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 9> qt_protobuf_QColor_uint_data;
    const char qt_protobuf_QColor_char_data[26];
} qt_protobuf_QColor_metadata {
    // data
    {
        0, /* = version */
        2, /* = num fields */
        3, /* = field number offset */
        5, /* = property index offset */
        7, /* = field flags offset */
        12, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        13, /* = rgba64 */
        20, /* = rgba */
        25, /* = end-of-string-marker */
        // Field numbers:
        1, /* = rgba64 */
        2, /* = rgba */
        // Property indices:
        0, /* = rgba64 */
        2, /* = rgba */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Oneof | QtProtobufPrivate::FieldFlag::ExplicitPresence | QtProtobufPrivate::FieldFlag::Message), /* = rgba64 */
        uint(QtProtobufPrivate::FieldFlag::Oneof | QtProtobufPrivate::FieldFlag::ExplicitPresence), /* = rgba */
    },
    // char_data
    /* metadata char_data: */
    "QtGui.QColor\0" /* = full message name */
    /* field char_data: */
    "rgba64\0rgba\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering QColor::staticPropertyOrdering = {
    &qt_protobuf_QColor_metadata.data
};

void QColor::registerTypes()
{
    qRegisterMetaType<QColor>();
    qRegisterMetaType<QList<QColor>>();
}

QColor::QColor()
    : QProtobufMessage(&QColor::staticMetaObject, &QColor::staticPropertyOrdering),
      dptr(new QColor_QtProtobufData)
{
}

QColor::QColor(const QColor &other)
    = default;
QColor &QColor::operator =(const QColor &other)
{
    QColor temp(other);
    swap(temp);
    return *this;
}
QColor::QColor(QColor &&other) noexcept
    = default;
QColor::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
bool comparesEqual(const QColor &lhs, const QColor &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_color == rhs.dptr->m_color;
}

QRgba64 *QColor::rgba64_p()
{
    if (!dptr->m_color.holdsField(1))
        dptr.detach();
    return dptr->m_color.message<QRgba64>();
}

bool QColor::hasRgba64() const
{
    return dptr->m_color.holdsField(1);
}
QRgba64 &QColor::rgba64() const
{
    Q_ASSERT(dptr->m_color.holdsField(1));
    return *(dptr->m_color.message<QRgba64>());
}

QtProtobuf::uint32 QColor::rgba_p() const
{
    return dptr->m_color.holdsField(2) ?
        dptr->m_color.value<QtProtobuf::uint32>() : QtProtobuf::uint32(0);
}

bool QColor::hasRgba() const
{
    return dptr->m_color.holdsField(2);
}
QtProtobuf::uint32 QColor::rgba() const
{
    Q_ASSERT(dptr->m_color.holdsField(2));
    return dptr->m_color.value<QtProtobuf::uint32>();
}

void QColor::setRgba64(const QRgba64 &rgba64)
{
    if (!dptr->m_color.isEqual(rgba64, 1)) {
        dptr.detach();
        dptr->m_color.setValue(rgba64, 1);
    }
}

void QColor::setRgba64(QRgba64 &&rgba64)
{
    if (!dptr->m_color.isEqual(rgba64, 1)) {
        dptr.detach();
        dptr->m_color.setValue(std::move(rgba64), 1);
    }
}

void QColor::setRgba64_p(QRgba64 *rgba64)
{
    const QRgba64 &value = *rgba64;
    if (!dptr->m_color.isEqual(value, 1)) {
        dptr.detach();
        dptr->m_color.setValue(value, 1);
    }
}

void QColor::setRgba(QtProtobuf::uint32 rgba)
{
    if (!dptr->m_color.isEqual(rgba, 2)) {
        dptr.detach();
        dptr->m_color.setValue(rgba, 2);
    }
}

void QColor::setRgba_p(QtProtobuf::uint32 rgba)
{
    if (!dptr->m_color.isEqual(rgba, 2)) {
        dptr.detach();
        dptr->m_color.setValue(rgba, 2);
    }
}

QColor::ColorFields QColor::colorField() const
{
    return static_cast<ColorFields>(dptr->m_color.fieldNumber());
}
void QColor::clearColor()
{
    if (dptr->m_color.fieldNumber() != QtProtobuf::InvalidFieldNumber) {
        dptr.detach();
        dptr->m_color = QtProtobufPrivate::QProtobufOneof();
    }
}

class QMatrix4x4_QtProtobufData : public QSharedData
{
public:
    QMatrix4x4_QtProtobufData()
        : QSharedData()
    {
    }

    QMatrix4x4_QtProtobufData(const QMatrix4x4_QtProtobufData &other)
        : QSharedData(other),
          m_m(other.m_m)
    {
    }

    QtProtobuf::floatList m_m;
};

QMatrix4x4::~QMatrix4x4() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_QMatrix4x4_uint_data;
    const char qt_protobuf_QMatrix4x4_char_data[20];
} qt_protobuf_QMatrix4x4_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        16, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        17, /* = m */
        19, /* = end-of-string-marker */
        // Field numbers:
        1, /* = m */
        // Property indices:
        0, /* = m */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = m */
    },
    // char_data
    /* metadata char_data: */
    "QtGui.QMatrix4x4\0" /* = full message name */
    /* field char_data: */
    "m\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering QMatrix4x4::staticPropertyOrdering = {
    &qt_protobuf_QMatrix4x4_metadata.data
};

void QMatrix4x4::registerTypes()
{
    qRegisterMetaType<QMatrix4x4>();
    qRegisterMetaType<QList<QMatrix4x4>>();
}

QMatrix4x4::QMatrix4x4()
    : QProtobufMessage(&QMatrix4x4::staticMetaObject, &QMatrix4x4::staticPropertyOrdering),
      dptr(new QMatrix4x4_QtProtobufData)
{
}

QMatrix4x4::QMatrix4x4(const QMatrix4x4 &other)
    = default;
QMatrix4x4 &QMatrix4x4::operator =(const QMatrix4x4 &other)
{
    QMatrix4x4 temp(other);
    swap(temp);
    return *this;
}
QMatrix4x4::QMatrix4x4(QMatrix4x4 &&other) noexcept
    = default;
QMatrix4x4::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
bool comparesEqual(const QMatrix4x4 &lhs, const QMatrix4x4 &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_m == rhs.dptr->m_m;
}

const QtProtobuf::floatList &QMatrix4x4::m() const &
{
    return dptr->m_m;
}

void QMatrix4x4::setM(const QtProtobuf::floatList &m)
{
    if (dptr->m_m != m) {
        dptr.detach();
        dptr->m_m = m;
    }
}

void QMatrix4x4::setM(QtProtobuf::floatList &&m)
{
    if (dptr->m_m != m) {
        dptr.detach();
        dptr->m_m = std::move(m);
    }
}


class QVector2D_QtProtobufData : public QSharedData
{
public:
    QVector2D_QtProtobufData()
        : QSharedData(),
          m_xPos(0.0),
          m_yPos(0.0)
    {
    }

    QVector2D_QtProtobufData(const QVector2D_QtProtobufData &other)
        : QSharedData(other),
          m_xPos(other.m_xPos),
          m_yPos(other.m_yPos)
    {
    }

    float m_xPos;
    float m_yPos;
};

QVector2D::~QVector2D() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 9> qt_protobuf_QVector2D_uint_data;
    const char qt_protobuf_QVector2D_char_data[27];
} qt_protobuf_QVector2D_metadata {
    // data
    {
        0, /* = version */
        2, /* = num fields */
        3, /* = field number offset */
        5, /* = property index offset */
        7, /* = field flags offset */
        15, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        16, /* = xPos */
        21, /* = yPos */
        26, /* = end-of-string-marker */
        // Field numbers:
        1, /* = xPos */
        2, /* = yPos */
        // Property indices:
        0, /* = xPos */
        1, /* = yPos */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = xPos */
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = yPos */
    },
    // char_data
    /* metadata char_data: */
    "QtGui.QVector2D\0" /* = full message name */
    /* field char_data: */
    "xPos\0yPos\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering QVector2D::staticPropertyOrdering = {
    &qt_protobuf_QVector2D_metadata.data
};

void QVector2D::registerTypes()
{
    qRegisterMetaType<QVector2D>();
    qRegisterMetaType<QList<QVector2D>>();
}

QVector2D::QVector2D()
    : QProtobufMessage(&QVector2D::staticMetaObject, &QVector2D::staticPropertyOrdering),
      dptr(new QVector2D_QtProtobufData)
{
}

QVector2D::QVector2D(const QVector2D &other)
    = default;
QVector2D &QVector2D::operator =(const QVector2D &other)
{
    QVector2D temp(other);
    swap(temp);
    return *this;
}
QVector2D::QVector2D(QVector2D &&other) noexcept
    = default;
QVector2D::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
bool comparesEqual(const QVector2D &lhs, const QVector2D &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_xPos == rhs.dptr->m_xPos
        && lhs.dptr->m_yPos == rhs.dptr->m_yPos;
}

float QVector2D::xPos() const
{
    return dptr->m_xPos;
}

float QVector2D::yPos() const
{
    return dptr->m_yPos;
}

void QVector2D::setXPos(float xPos)
{
    if (dptr->m_xPos != xPos ||
        std::signbit(dptr->m_xPos) != std::signbit(xPos)) {
        dptr.detach();
        dptr->m_xPos = xPos;
    }
}

void QVector2D::setYPos(float yPos)
{
    if (dptr->m_yPos != yPos ||
        std::signbit(dptr->m_yPos) != std::signbit(yPos)) {
        dptr.detach();
        dptr->m_yPos = yPos;
    }
}


class QVector3D_QtProtobufData : public QSharedData
{
public:
    QVector3D_QtProtobufData()
        : QSharedData(),
          m_xPos(0.0),
          m_yPos(0.0),
          m_zPos(0.0)
    {
    }

    QVector3D_QtProtobufData(const QVector3D_QtProtobufData &other)
        : QSharedData(other),
          m_xPos(other.m_xPos),
          m_yPos(other.m_yPos),
          m_zPos(other.m_zPos)
    {
    }

    float m_xPos;
    float m_yPos;
    float m_zPos;
};

QVector3D::~QVector3D() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 13> qt_protobuf_QVector3D_uint_data;
    const char qt_protobuf_QVector3D_char_data[32];
} qt_protobuf_QVector3D_metadata {
    // data
    {
        0, /* = version */
        3, /* = num fields */
        4, /* = field number offset */
        7, /* = property index offset */
        10, /* = field flags offset */
        15, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        16, /* = xPos */
        21, /* = yPos */
        26, /* = zPos */
        31, /* = end-of-string-marker */
        // Field numbers:
        1, /* = xPos */
        2, /* = yPos */
        3, /* = zPos */
        // Property indices:
        0, /* = xPos */
        1, /* = yPos */
        2, /* = zPos */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = xPos */
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = yPos */
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = zPos */
    },
    // char_data
    /* metadata char_data: */
    "QtGui.QVector3D\0" /* = full message name */
    /* field char_data: */
    "xPos\0yPos\0zPos\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering QVector3D::staticPropertyOrdering = {
    &qt_protobuf_QVector3D_metadata.data
};

void QVector3D::registerTypes()
{
    qRegisterMetaType<QVector3D>();
    qRegisterMetaType<QList<QVector3D>>();
}

QVector3D::QVector3D()
    : QProtobufMessage(&QVector3D::staticMetaObject, &QVector3D::staticPropertyOrdering),
      dptr(new QVector3D_QtProtobufData)
{
}

QVector3D::QVector3D(const QVector3D &other)
    = default;
QVector3D &QVector3D::operator =(const QVector3D &other)
{
    QVector3D temp(other);
    swap(temp);
    return *this;
}
QVector3D::QVector3D(QVector3D &&other) noexcept
    = default;
QVector3D::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
bool comparesEqual(const QVector3D &lhs, const QVector3D &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_xPos == rhs.dptr->m_xPos
        && lhs.dptr->m_yPos == rhs.dptr->m_yPos
        && lhs.dptr->m_zPos == rhs.dptr->m_zPos;
}

float QVector3D::xPos() const
{
    return dptr->m_xPos;
}

float QVector3D::yPos() const
{
    return dptr->m_yPos;
}

float QVector3D::zPos() const
{
    return dptr->m_zPos;
}

void QVector3D::setXPos(float xPos)
{
    if (dptr->m_xPos != xPos ||
        std::signbit(dptr->m_xPos) != std::signbit(xPos)) {
        dptr.detach();
        dptr->m_xPos = xPos;
    }
}

void QVector3D::setYPos(float yPos)
{
    if (dptr->m_yPos != yPos ||
        std::signbit(dptr->m_yPos) != std::signbit(yPos)) {
        dptr.detach();
        dptr->m_yPos = yPos;
    }
}

void QVector3D::setZPos(float zPos)
{
    if (dptr->m_zPos != zPos ||
        std::signbit(dptr->m_zPos) != std::signbit(zPos)) {
        dptr.detach();
        dptr->m_zPos = zPos;
    }
}


class QVector4D_QtProtobufData : public QSharedData
{
public:
    QVector4D_QtProtobufData()
        : QSharedData(),
          m_xPos(0.0),
          m_yPos(0.0),
          m_zPos(0.0),
          m_wPos(0.0)
    {
    }

    QVector4D_QtProtobufData(const QVector4D_QtProtobufData &other)
        : QSharedData(other),
          m_xPos(other.m_xPos),
          m_yPos(other.m_yPos),
          m_zPos(other.m_zPos),
          m_wPos(other.m_wPos)
    {
    }

    float m_xPos;
    float m_yPos;
    float m_zPos;
    float m_wPos;
};

QVector4D::~QVector4D() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 17> qt_protobuf_QVector4D_uint_data;
    const char qt_protobuf_QVector4D_char_data[37];
} qt_protobuf_QVector4D_metadata {
    // data
    {
        0, /* = version */
        4, /* = num fields */
        5, /* = field number offset */
        9, /* = property index offset */
        13, /* = field flags offset */
        15, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        16, /* = xPos */
        21, /* = yPos */
        26, /* = zPos */
        31, /* = wPos */
        36, /* = end-of-string-marker */
        // Field numbers:
        1, /* = xPos */
        2, /* = yPos */
        3, /* = zPos */
        4, /* = wPos */
        // Property indices:
        0, /* = xPos */
        1, /* = yPos */
        2, /* = zPos */
        3, /* = wPos */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = xPos */
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = yPos */
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = zPos */
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = wPos */
    },
    // char_data
    /* metadata char_data: */
    "QtGui.QVector4D\0" /* = full message name */
    /* field char_data: */
    "xPos\0yPos\0zPos\0wPos\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering QVector4D::staticPropertyOrdering = {
    &qt_protobuf_QVector4D_metadata.data
};

void QVector4D::registerTypes()
{
    qRegisterMetaType<QVector4D>();
    qRegisterMetaType<QList<QVector4D>>();
}

QVector4D::QVector4D()
    : QProtobufMessage(&QVector4D::staticMetaObject, &QVector4D::staticPropertyOrdering),
      dptr(new QVector4D_QtProtobufData)
{
}

QVector4D::QVector4D(const QVector4D &other)
    = default;
QVector4D &QVector4D::operator =(const QVector4D &other)
{
    QVector4D temp(other);
    swap(temp);
    return *this;
}
QVector4D::QVector4D(QVector4D &&other) noexcept
    = default;
QVector4D::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
bool comparesEqual(const QVector4D &lhs, const QVector4D &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_xPos == rhs.dptr->m_xPos
        && lhs.dptr->m_yPos == rhs.dptr->m_yPos
        && lhs.dptr->m_zPos == rhs.dptr->m_zPos
        && lhs.dptr->m_wPos == rhs.dptr->m_wPos;
}

float QVector4D::xPos() const
{
    return dptr->m_xPos;
}

float QVector4D::yPos() const
{
    return dptr->m_yPos;
}

float QVector4D::zPos() const
{
    return dptr->m_zPos;
}

float QVector4D::wPos() const
{
    return dptr->m_wPos;
}

void QVector4D::setXPos(float xPos)
{
    if (dptr->m_xPos != xPos ||
        std::signbit(dptr->m_xPos) != std::signbit(xPos)) {
        dptr.detach();
        dptr->m_xPos = xPos;
    }
}

void QVector4D::setYPos(float yPos)
{
    if (dptr->m_yPos != yPos ||
        std::signbit(dptr->m_yPos) != std::signbit(yPos)) {
        dptr.detach();
        dptr->m_yPos = yPos;
    }
}

void QVector4D::setZPos(float zPos)
{
    if (dptr->m_zPos != zPos ||
        std::signbit(dptr->m_zPos) != std::signbit(zPos)) {
        dptr.detach();
        dptr->m_zPos = zPos;
    }
}

void QVector4D::setWPos(float wPos)
{
    if (dptr->m_wPos != wPos ||
        std::signbit(dptr->m_wPos) != std::signbit(wPos)) {
        dptr.detach();
        dptr->m_wPos = wPos;
    }
}


class QTransform_QtProtobufData : public QSharedData
{
public:
    QTransform_QtProtobufData()
        : QSharedData()
    {
    }

    QTransform_QtProtobufData(const QTransform_QtProtobufData &other)
        : QSharedData(other),
          m_m(other.m_m)
    {
    }

    QtProtobuf::doubleList m_m;
};

QTransform::~QTransform() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 5> qt_protobuf_QTransform_uint_data;
    const char qt_protobuf_QTransform_char_data[20];
} qt_protobuf_QTransform_metadata {
    // data
    {
        0, /* = version */
        1, /* = num fields */
        2, /* = field number offset */
        3, /* = property index offset */
        4, /* = field flags offset */
        16, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        17, /* = m */
        19, /* = end-of-string-marker */
        // Field numbers:
        1, /* = m */
        // Property indices:
        0, /* = m */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::Repeated), /* = m */
    },
    // char_data
    /* metadata char_data: */
    "QtGui.QTransform\0" /* = full message name */
    /* field char_data: */
    "m\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering QTransform::staticPropertyOrdering = {
    &qt_protobuf_QTransform_metadata.data
};

void QTransform::registerTypes()
{
    qRegisterMetaType<QTransform>();
    qRegisterMetaType<QList<QTransform>>();
}

QTransform::QTransform()
    : QProtobufMessage(&QTransform::staticMetaObject, &QTransform::staticPropertyOrdering),
      dptr(new QTransform_QtProtobufData)
{
}

QTransform::QTransform(const QTransform &other)
    = default;
QTransform &QTransform::operator =(const QTransform &other)
{
    QTransform temp(other);
    swap(temp);
    return *this;
}
QTransform::QTransform(QTransform &&other) noexcept
    = default;
QTransform::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
bool comparesEqual(const QTransform &lhs, const QTransform &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_m == rhs.dptr->m_m;
}

const QtProtobuf::doubleList &QTransform::m() const &
{
    return dptr->m_m;
}

void QTransform::setM(const QtProtobuf::doubleList &m)
{
    if (dptr->m_m != m) {
        dptr.detach();
        dptr->m_m = m;
    }
}

void QTransform::setM(QtProtobuf::doubleList &&m)
{
    if (dptr->m_m != m) {
        dptr.detach();
        dptr->m_m = std::move(m);
    }
}


class QQuaternion_QtProtobufData : public QSharedData
{
public:
    QQuaternion_QtProtobufData()
        : QSharedData(),
          m_scalar(0.0),
          m_x(0.0),
          m_y(0.0),
          m_z(0.0)
    {
    }

    QQuaternion_QtProtobufData(const QQuaternion_QtProtobufData &other)
        : QSharedData(other),
          m_scalar(other.m_scalar),
          m_x(other.m_x),
          m_y(other.m_y),
          m_z(other.m_z)
    {
    }

    float m_scalar;
    float m_x;
    float m_y;
    float m_z;
};

QQuaternion::~QQuaternion() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 17> qt_protobuf_QQuaternion_uint_data;
    const char qt_protobuf_QQuaternion_char_data[32];
} qt_protobuf_QQuaternion_metadata {
    // data
    {
        0, /* = version */
        4, /* = num fields */
        5, /* = field number offset */
        9, /* = property index offset */
        13, /* = field flags offset */
        17, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        18, /* = scalar */
        25, /* = x */
        27, /* = y */
        29, /* = z */
        31, /* = end-of-string-marker */
        // Field numbers:
        1, /* = scalar */
        2, /* = x */
        3, /* = y */
        4, /* = z */
        // Property indices:
        0, /* = scalar */
        1, /* = x */
        2, /* = y */
        3, /* = z */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = scalar */
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = x */
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = y */
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = z */
    },
    // char_data
    /* metadata char_data: */
    "QtGui.QQuaternion\0" /* = full message name */
    /* field char_data: */
    "scalar\0x\0y\0z\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering QQuaternion::staticPropertyOrdering = {
    &qt_protobuf_QQuaternion_metadata.data
};

void QQuaternion::registerTypes()
{
    qRegisterMetaType<QQuaternion>();
    qRegisterMetaType<QList<QQuaternion>>();
}

QQuaternion::QQuaternion()
    : QProtobufMessage(&QQuaternion::staticMetaObject, &QQuaternion::staticPropertyOrdering),
      dptr(new QQuaternion_QtProtobufData)
{
}

QQuaternion::QQuaternion(const QQuaternion &other)
    = default;
QQuaternion &QQuaternion::operator =(const QQuaternion &other)
{
    QQuaternion temp(other);
    swap(temp);
    return *this;
}
QQuaternion::QQuaternion(QQuaternion &&other) noexcept
    = default;
QQuaternion::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
bool comparesEqual(const QQuaternion &lhs, const QQuaternion &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_scalar == rhs.dptr->m_scalar
        && lhs.dptr->m_x == rhs.dptr->m_x
        && lhs.dptr->m_y == rhs.dptr->m_y
        && lhs.dptr->m_z == rhs.dptr->m_z;
}

float QQuaternion::scalar() const
{
    return dptr->m_scalar;
}

float QQuaternion::x() const
{
    return dptr->m_x;
}

float QQuaternion::y() const
{
    return dptr->m_y;
}

float QQuaternion::z() const
{
    return dptr->m_z;
}

void QQuaternion::setScalar(float scalar)
{
    if (dptr->m_scalar != scalar ||
        std::signbit(dptr->m_scalar) != std::signbit(scalar)) {
        dptr.detach();
        dptr->m_scalar = scalar;
    }
}

void QQuaternion::setX(float x)
{
    if (dptr->m_x != x ||
        std::signbit(dptr->m_x) != std::signbit(x)) {
        dptr.detach();
        dptr->m_x = x;
    }
}

void QQuaternion::setY(float y)
{
    if (dptr->m_y != y ||
        std::signbit(dptr->m_y) != std::signbit(y)) {
        dptr.detach();
        dptr->m_y = y;
    }
}

void QQuaternion::setZ(float z)
{
    if (dptr->m_z != z ||
        std::signbit(dptr->m_z) != std::signbit(z)) {
        dptr.detach();
        dptr->m_z = z;
    }
}


class QImage_QtProtobufData : public QSharedData
{
public:
    QImage_QtProtobufData()
        : QSharedData()
    {
    }

    QImage_QtProtobufData(const QImage_QtProtobufData &other)
        : QSharedData(other),
          m_data(other.m_data),
          m_format(other.m_format)
    {
    }

    QByteArray m_data;
    QString m_format;
};

QImage::~QImage() = default;

static constexpr struct {
    QtProtobufPrivate::QProtobufPropertyOrdering::Data data;
    const std::array<uint, 9> qt_protobuf_QImage_uint_data;
    const char qt_protobuf_QImage_char_data[26];
} qt_protobuf_QImage_metadata {
    // data
    {
        0, /* = version */
        2, /* = num fields */
        3, /* = field number offset */
        5, /* = property index offset */
        7, /* = field flags offset */
        12, /* = message full name length */
    },
    // uint_data
    {
        // JSON name offsets:
        13, /* = data */
        18, /* = format */
        25, /* = end-of-string-marker */
        // Field numbers:
        1, /* = data */
        2, /* = format */
        // Property indices:
        0, /* = data */
        1, /* = format */
        // Field flags:
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = data */
        uint(QtProtobufPrivate::FieldFlag::NoFlags), /* = format */
    },
    // char_data
    /* metadata char_data: */
    "QtGui.QImage\0" /* = full message name */
    /* field char_data: */
    "data\0format\0"
};

const QtProtobufPrivate::QProtobufPropertyOrdering QImage::staticPropertyOrdering = {
    &qt_protobuf_QImage_metadata.data
};

void QImage::registerTypes()
{
    qRegisterMetaType<QImage>();
    qRegisterMetaType<QList<QImage>>();
}

QImage::QImage()
    : QProtobufMessage(&QImage::staticMetaObject, &QImage::staticPropertyOrdering),
      dptr(new QImage_QtProtobufData)
{
}

QImage::QImage(const QImage &other)
    = default;
QImage &QImage::operator =(const QImage &other)
{
    QImage temp(other);
    swap(temp);
    return *this;
}
QImage::QImage(QImage &&other) noexcept
    = default;
QImage::operator QVariant() const
{
    return QVariant::fromValue(*this);
}
bool comparesEqual(const QImage &lhs, const QImage &rhs) noexcept
{
    return operator ==(static_cast<const QProtobufMessage&>(lhs),
                       static_cast<const QProtobufMessage&>(rhs))
        && lhs.dptr->m_data == rhs.dptr->m_data
        && lhs.dptr->m_format == rhs.dptr->m_format;
}

const QByteArray &QImage::data() const &
{
    return dptr->m_data;
}

const QString &QImage::format() const &
{
    return dptr->m_format;
}

void QImage::setData(const QByteArray &data)
{
    if (dptr->m_data != data) {
        dptr.detach();
        dptr->m_data = data;
    }
}

void QImage::setData(QByteArray &&data)
{
    if (dptr->m_data != data) {
        dptr.detach();
        dptr->m_data = std::move(data);
    }
}

void QImage::setFormat(const QString &format)
{
    if (dptr->m_format != format) {
        dptr.detach();
        dptr->m_format = format;
    }
}

void QImage::setFormat(QString &&format)
{
    if (dptr->m_format != format) {
        dptr.detach();
        dptr->m_format = std::move(format);
    }
}

} // namespace QtProtobufPrivate::QtGui
QT_END_NAMESPACE

#include "moc_QtGui.qpb.cpp"
