/work/qtbase/src/gui/.moc/moc_qscreen.cpp

Source (jump to first uncovered line)
/****************************************************************************
** Meta object code from reading C++ file 'qscreen.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.0)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include <memory>
#include "../../../../../src/qt/qtbase/src/gui/kernel/qscreen.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'qscreen.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.15.0. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

QT_BEGIN_MOC_NAMESPACE
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_QScreen_t {
    QByteArrayData data[39];
    char stringdata0[616];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_QScreen_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QScreen_t qt_meta_stringdata_QScreen = {
    {
QT_MOC_LITERAL(0, 0, 7), // "QScreen"
QT_MOC_LITERAL(1, 8, 15), // "geometryChanged"
QT_MOC_LITERAL(2, 24, 0), // ""
QT_MOC_LITERAL(3, 25, 8), // "geometry"
QT_MOC_LITERAL(4, 34, 24), // "availableGeometryChanged"
QT_MOC_LITERAL(5, 59, 19), // "physicalSizeChanged"
QT_MOC_LITERAL(6, 79, 4), // "size"
QT_MOC_LITERAL(7, 84, 26), // "physicalDotsPerInchChanged"
QT_MOC_LITERAL(8, 111, 3), // "dpi"
QT_MOC_LITERAL(9, 115, 25), // "logicalDotsPerInchChanged"
QT_MOC_LITERAL(10, 141, 22), // "virtualGeometryChanged"
QT_MOC_LITERAL(11, 164, 4), // "rect"
QT_MOC_LITERAL(12, 169, 25), // "primaryOrientationChanged"
QT_MOC_LITERAL(13, 195, 21), // "Qt::ScreenOrientation"
QT_MOC_LITERAL(14, 217, 11), // "orientation"
QT_MOC_LITERAL(15, 229, 18), // "orientationChanged"
QT_MOC_LITERAL(16, 248, 18), // "refreshRateChanged"
QT_MOC_LITERAL(17, 267, 11), // "refreshRate"
QT_MOC_LITERAL(18, 279, 4), // "name"
QT_MOC_LITERAL(19, 284, 12), // "manufacturer"
QT_MOC_LITERAL(20, 297, 5), // "model"
QT_MOC_LITERAL(21, 303, 12), // "serialNumber"
QT_MOC_LITERAL(22, 316, 5), // "depth"
QT_MOC_LITERAL(23, 322, 13), // "availableSize"
QT_MOC_LITERAL(24, 336, 11), // "virtualSize"
QT_MOC_LITERAL(25, 348, 20), // "availableVirtualSize"
QT_MOC_LITERAL(26, 369, 17), // "availableGeometry"
QT_MOC_LITERAL(27, 387, 15), // "virtualGeometry"
QT_MOC_LITERAL(28, 403, 24), // "availableVirtualGeometry"
QT_MOC_LITERAL(29, 428, 12), // "physicalSize"
QT_MOC_LITERAL(30, 441, 20), // "physicalDotsPerInchX"
QT_MOC_LITERAL(31, 462, 20), // "physicalDotsPerInchY"
QT_MOC_LITERAL(32, 483, 19), // "physicalDotsPerInch"
QT_MOC_LITERAL(33, 503, 19), // "logicalDotsPerInchX"
QT_MOC_LITERAL(34, 523, 19), // "logicalDotsPerInchY"
QT_MOC_LITERAL(35, 543, 18), // "logicalDotsPerInch"
QT_MOC_LITERAL(36, 562, 16), // "devicePixelRatio"
QT_MOC_LITERAL(37, 579, 18), // "primaryOrientation"
QT_MOC_LITERAL(38, 598, 17) // "nativeOrientation"

    },
    "QScreen\0geometryChanged\0\0geometry\0"
    "availableGeometryChanged\0physicalSizeChanged\0"
    "size\0physicalDotsPerInchChanged\0dpi\0"
    "logicalDotsPerInchChanged\0"
    "virtualGeometryChanged\0rect\0"
    "primaryOrientationChanged\0"
    "Qt::ScreenOrientation\0orientation\0"
    "orientationChanged\0refreshRateChanged\0"
    "refreshRate\0name\0manufacturer\0model\0"
    "serialNumber\0depth\0availableSize\0"
    "virtualSize\0availableVirtualSize\0"
    "availableGeometry\0virtualGeometry\0"
    "availableVirtualGeometry\0physicalSize\0"
    "physicalDotsPerInchX\0physicalDotsPerInchY\0"
    "physicalDotsPerInch\0logicalDotsPerInchX\0"
    "logicalDotsPerInchY\0logicalDotsPerInch\0"
    "devicePixelRatio\0primaryOrientation\0"
    "nativeOrientation"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QScreen[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       9,   14, // methods
      25,   86, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       9,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,   59,    2, 0x06 /* Public */,
       4,    1,   62,    2, 0x06 /* Public */,
       5,    1,   65,    2, 0x06 /* Public */,
       7,    1,   68,    2, 0x06 /* Public */,
       9,    1,   71,    2, 0x06 /* Public */,
      10,    1,   74,    2, 0x06 /* Public */,
      12,    1,   77,    2, 0x06 /* Public */,
      15,    1,   80,    2, 0x06 /* Public */,
      16,    1,   83,    2, 0x06 /* Public */,

 // signals: parameters
    QMetaType::Void, QMetaType::QRect,    3,
    QMetaType::Void, QMetaType::QRect,    3,
    QMetaType::Void, QMetaType::QSizeF,    6,
    QMetaType::Void, QMetaType::QReal,    8,
    QMetaType::Void, QMetaType::QReal,    8,
    QMetaType::Void, QMetaType::QRect,   11,
    QMetaType::Void, 0x80000000 | 13,   14,
    QMetaType::Void, 0x80000000 | 13,   14,
    QMetaType::Void, QMetaType::QReal,   17,

 // properties: name, type, flags
      18, QMetaType::QString, 0x00095401,
      19, QMetaType::QString, 0x00095401,
      20, QMetaType::QString, 0x00095401,
      21, QMetaType::QString, 0x00095401,
      22, QMetaType::Int, 0x00095401,
       6, QMetaType::QSize, 0x00495001,
      23, QMetaType::QSize, 0x00495001,
      24, QMetaType::QSize, 0x00495001,
      25, QMetaType::QSize, 0x00495001,
       3, QMetaType::QRect, 0x00495001,
      26, QMetaType::QRect, 0x00495001,
      27, QMetaType::QRect, 0x00495001,
      28, QMetaType::QRect, 0x00495001,
      29, QMetaType::QSizeF, 0x00495001,
      30, QMetaType::QReal, 0x00495001,
      31, QMetaType::QReal, 0x00495001,
      32, QMetaType::QReal, 0x00495001,
      33, QMetaType::QReal, 0x00495001,
      34, QMetaType::QReal, 0x00495001,
      35, QMetaType::QReal, 0x00495001,
      36, QMetaType::QReal, 0x00495001,
      37, 0x80000000 | 13, 0x00495009,
      14, 0x80000000 | 13, 0x00495009,
      38, 0x80000000 | 13, 0x00095009,
      17, QMetaType::QReal, 0x00495001,

 // properties: notify_signal_id
       0,
       0,
       0,
       0,
       0,
       0,
       1,
       5,
       5,
       0,
       1,
       5,
       5,
       2,
       3,
       3,
       3,
       4,
       4,
       4,
       3,
       6,
       7,
       0,
       8,

       0        // eod
};

void QScreen::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<QScreen *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->geometryChanged((*reinterpret_cast< const QRect(*)>(_a[1]))); break;
        case 1: _t->availableGeometryChanged((*reinterpret_cast< const QRect(*)>(_a[1]))); break;
        case 2: _t->physicalSizeChanged((*reinterpret_cast< const QSizeF(*)>(_a[1]))); break;
        case 3: _t->physicalDotsPerInchChanged((*reinterpret_cast< qreal(*)>(_a[1]))); break;
        case 4: _t->logicalDotsPerInchChanged((*reinterpret_cast< qreal(*)>(_a[1]))); break;
        case 5: _t->virtualGeometryChanged((*reinterpret_cast< const QRect(*)>(_a[1]))); break;
        case 6: _t->primaryOrientationChanged((*reinterpret_cast< Qt::ScreenOrientation(*)>(_a[1]))); break;
        case 7: _t->orientationChanged((*reinterpret_cast< Qt::ScreenOrientation(*)>(_a[1]))); break;
        case 8: _t->refreshRateChanged((*reinterpret_cast< qreal(*)>(_a[1]))); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (QScreen::*)(const QRect & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QScreen::geometryChanged)) {
                *result = 0;
                return;
            }
        }
        {
            using _t = void (QScreen::*)(const QRect & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QScreen::availableGeometryChanged)) {
                *result = 1;
                return;
            }
        }
        {
            using _t = void (QScreen::*)(const QSizeF & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QScreen::physicalSizeChanged)) {
                *result = 2;
                return;
            }
        }
        {
            using _t = void (QScreen::*)(qreal );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QScreen::physicalDotsPerInchChanged)) {
                *result = 3;
                return;
            }
        }
        {
            using _t = void (QScreen::*)(qreal );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QScreen::logicalDotsPerInchChanged)) {
                *result = 4;
                return;
            }
        }
        {
            using _t = void (QScreen::*)(const QRect & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QScreen::virtualGeometryChanged)) {
                *result = 5;
                return;
            }
        }
        {
            using _t = void (QScreen::*)(Qt::ScreenOrientation );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QScreen::primaryOrientationChanged)) {
                *result = 6;
                return;
            }
        }
        {
            using _t = void (QScreen::*)(Qt::ScreenOrientation );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QScreen::orientationChanged)) {
                *result = 7;
                return;
            }
        }
        {
            using _t = void (QScreen::*)(qreal );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QScreen::refreshRateChanged)) {
                *result = 8;
                return;
            }
        }
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        auto *_t = static_cast<QScreen *>(_o);
        Q_UNUSED(_t)
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< QString*>(_v) = _t->name(); break;
        case 1: *reinterpret_cast< QString*>(_v) = _t->manufacturer(); break;
        case 2: *reinterpret_cast< QString*>(_v) = _t->model(); break;
        case 3: *reinterpret_cast< QString*>(_v) = _t->serialNumber(); break;
        case 4: *reinterpret_cast< int*>(_v) = _t->depth(); break;
        case 5: *reinterpret_cast< QSize*>(_v) = _t->size(); break;
        case 6: *reinterpret_cast< QSize*>(_v) = _t->availableSize(); break;
        case 7: *reinterpret_cast< QSize*>(_v) = _t->virtualSize(); break;
        case 8: *reinterpret_cast< QSize*>(_v) = _t->availableVirtualSize(); break;
        case 9: *reinterpret_cast< QRect*>(_v) = _t->geometry(); break;
        case 10: *reinterpret_cast< QRect*>(_v) = _t->availableGeometry(); break;
        case 11: *reinterpret_cast< QRect*>(_v) = _t->virtualGeometry(); break;
        case 12: *reinterpret_cast< QRect*>(_v) = _t->availableVirtualGeometry(); break;
        case 13: *reinterpret_cast< QSizeF*>(_v) = _t->physicalSize(); break;
        case 14: *reinterpret_cast< qreal*>(_v) = _t->physicalDotsPerInchX(); break;
        case 15: *reinterpret_cast< qreal*>(_v) = _t->physicalDotsPerInchY(); break;
        case 16: *reinterpret_cast< qreal*>(_v) = _t->physicalDotsPerInch(); break;
        case 17: *reinterpret_cast< qreal*>(_v) = _t->logicalDotsPerInchX(); break;
        case 18: *reinterpret_cast< qreal*>(_v) = _t->logicalDotsPerInchY(); break;
        case 19: *reinterpret_cast< qreal*>(_v) = _t->logicalDotsPerInch(); break;
        case 20: *reinterpret_cast< qreal*>(_v) = _t->devicePixelRatio(); break;
        case 21: *reinterpret_cast< Qt::ScreenOrientation*>(_v) = _t->primaryOrientation(); break;
        case 22: *reinterpret_cast< Qt::ScreenOrientation*>(_v) = _t->orientation(); break;
        case 23: *reinterpret_cast< Qt::ScreenOrientation*>(_v) = _t->nativeOrientation(); break;
        case 24: *reinterpret_cast< qreal*>(_v) = _t->refreshRate(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

QT_INIT_METAOBJECT const QMetaObject QScreen::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_meta_stringdata_QScreen.data,
    qt_meta_data_QScreen,
    qt_static_metacall,
    nullptr,
    nullptr
} };


const QMetaObject *QScreen::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *QScreen::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QScreen.stringdata0))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int QScreen::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 9)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 9;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 9)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 9;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 25;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 25;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 25;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 25;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 25;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 25;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}

// SIGNAL 0
void QScreen::geometryChanged(const QRect & _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void QScreen::availableGeometryChanged(const QRect & _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void QScreen::physicalSizeChanged(const QSizeF & _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}

// SIGNAL 3
void QScreen::physicalDotsPerInchChanged(qreal _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
}

// SIGNAL 4
void QScreen::logicalDotsPerInchChanged(qreal _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 4, _a);
}

// SIGNAL 5
void QScreen::virtualGeometryChanged(const QRect & _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 5, _a);
}

// SIGNAL 6
void QScreen::primaryOrientationChanged(Qt::ScreenOrientation _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 6, _a);
}

// SIGNAL 7
void QScreen::orientationChanged(Qt::ScreenOrientation _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 7, _a);
}

// SIGNAL 8
void QScreen::refreshRateChanged(qreal _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 8, _a);
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE

Coverage Report

Created: 2020-03-12 16:59

Line	Count	Source (jump to first uncovered line)
1		/****************************************************************************
2		** Meta object code from reading C++ file 'qscreen.h'
3		**
4		** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.0)
5		**
6		** WARNING! All changes made in this file will be lost!
7		*****************************************************************************/
8
9		#include <memory>
10		#include "../../../../../src/qt/qtbase/src/gui/kernel/qscreen.h"
11		#include <QtCore/qbytearray.h>
12		#include <QtCore/qmetatype.h>
13		#if !defined(Q_MOC_OUTPUT_REVISION)
14		#error "The header file 'qscreen.h' doesn't include <QObject>."
15		#elif Q_MOC_OUTPUT_REVISION != 67
16		#error "This file was generated using the moc from 5.15.0. It"
17		#error "cannot be used with the include files from this version of Qt."
18		#error "(The moc has changed too much.)"
19		#endif
20
21		QT_BEGIN_MOC_NAMESPACE
22		QT_WARNING_PUSH
23		QT_WARNING_DISABLE_DEPRECATED
24		struct qt_meta_stringdata_QScreen_t {
25		QByteArrayData data[39];
26		char stringdata0[616];
27		};
28		#define QT_MOC_LITERAL(idx, ofs, len) \
29		Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
30		qptrdiff(offsetof(qt_meta_stringdata_QScreen_t, stringdata0) + ofs \
31		- idx * sizeof(QByteArrayData)) \
32		)
33		static const qt_meta_stringdata_QScreen_t qt_meta_stringdata_QScreen = {
34		{
35		QT_MOC_LITERAL(0, 0, 7), // "QScreen"
36		QT_MOC_LITERAL(1, 8, 15), // "geometryChanged"
37		QT_MOC_LITERAL(2, 24, 0), // ""
38		QT_MOC_LITERAL(3, 25, 8), // "geometry"
39		QT_MOC_LITERAL(4, 34, 24), // "availableGeometryChanged"
40		QT_MOC_LITERAL(5, 59, 19), // "physicalSizeChanged"
41		QT_MOC_LITERAL(6, 79, 4), // "size"
42		QT_MOC_LITERAL(7, 84, 26), // "physicalDotsPerInchChanged"
43		QT_MOC_LITERAL(8, 111, 3), // "dpi"
44		QT_MOC_LITERAL(9, 115, 25), // "logicalDotsPerInchChanged"
45		QT_MOC_LITERAL(10, 141, 22), // "virtualGeometryChanged"
46		QT_MOC_LITERAL(11, 164, 4), // "rect"
47		QT_MOC_LITERAL(12, 169, 25), // "primaryOrientationChanged"
48		QT_MOC_LITERAL(13, 195, 21), // "Qt::ScreenOrientation"
49		QT_MOC_LITERAL(14, 217, 11), // "orientation"
50		QT_MOC_LITERAL(15, 229, 18), // "orientationChanged"
51		QT_MOC_LITERAL(16, 248, 18), // "refreshRateChanged"
52		QT_MOC_LITERAL(17, 267, 11), // "refreshRate"
53		QT_MOC_LITERAL(18, 279, 4), // "name"
54		QT_MOC_LITERAL(19, 284, 12), // "manufacturer"
55		QT_MOC_LITERAL(20, 297, 5), // "model"
56		QT_MOC_LITERAL(21, 303, 12), // "serialNumber"
57		QT_MOC_LITERAL(22, 316, 5), // "depth"
58		QT_MOC_LITERAL(23, 322, 13), // "availableSize"
59		QT_MOC_LITERAL(24, 336, 11), // "virtualSize"
60		QT_MOC_LITERAL(25, 348, 20), // "availableVirtualSize"
61		QT_MOC_LITERAL(26, 369, 17), // "availableGeometry"
62		QT_MOC_LITERAL(27, 387, 15), // "virtualGeometry"
63		QT_MOC_LITERAL(28, 403, 24), // "availableVirtualGeometry"
64		QT_MOC_LITERAL(29, 428, 12), // "physicalSize"
65		QT_MOC_LITERAL(30, 441, 20), // "physicalDotsPerInchX"
66		QT_MOC_LITERAL(31, 462, 20), // "physicalDotsPerInchY"
67		QT_MOC_LITERAL(32, 483, 19), // "physicalDotsPerInch"
68		QT_MOC_LITERAL(33, 503, 19), // "logicalDotsPerInchX"
69		QT_MOC_LITERAL(34, 523, 19), // "logicalDotsPerInchY"
70		QT_MOC_LITERAL(35, 543, 18), // "logicalDotsPerInch"
71		QT_MOC_LITERAL(36, 562, 16), // "devicePixelRatio"
72		QT_MOC_LITERAL(37, 579, 18), // "primaryOrientation"
73		QT_MOC_LITERAL(38, 598, 17) // "nativeOrientation"
74
75		},
76		"QScreen\0geometryChanged\0\0geometry\0"
77		"availableGeometryChanged\0physicalSizeChanged\0"
78		"size\0physicalDotsPerInchChanged\0dpi\0"
79		"logicalDotsPerInchChanged\0"
80		"virtualGeometryChanged\0rect\0"
81		"primaryOrientationChanged\0"
82		"Qt::ScreenOrientation\0orientation\0"
83		"orientationChanged\0refreshRateChanged\0"
84		"refreshRate\0name\0manufacturer\0model\0"
85		"serialNumber\0depth\0availableSize\0"
86		"virtualSize\0availableVirtualSize\0"
87		"availableGeometry\0virtualGeometry\0"
88		"availableVirtualGeometry\0physicalSize\0"
89		"physicalDotsPerInchX\0physicalDotsPerInchY\0"
90		"physicalDotsPerInch\0logicalDotsPerInchX\0"
91		"logicalDotsPerInchY\0logicalDotsPerInch\0"
92		"devicePixelRatio\0primaryOrientation\0"
93		"nativeOrientation"
94		};
95		#undef QT_MOC_LITERAL
96
97		static const uint qt_meta_data_QScreen[] = {
98
99		// content:
100		8, // revision
101		0, // classname
102		0, 0, // classinfo
103		9, 14, // methods
104		25, 86, // properties
105		0, 0, // enums/sets
106		0, 0, // constructors
107		0, // flags
108		9, // signalCount
109
110		// signals: name, argc, parameters, tag, flags
111		1, 1, 59, 2, 0x06 /* Public */,
112		4, 1, 62, 2, 0x06 /* Public */,
113		5, 1, 65, 2, 0x06 /* Public */,
114		7, 1, 68, 2, 0x06 /* Public */,
115		9, 1, 71, 2, 0x06 /* Public */,
116		10, 1, 74, 2, 0x06 /* Public */,
117		12, 1, 77, 2, 0x06 /* Public */,
118		15, 1, 80, 2, 0x06 /* Public */,
119		16, 1, 83, 2, 0x06 /* Public */,
120
121		// signals: parameters
122		QMetaType::Void, QMetaType::QRect, 3,
123		QMetaType::Void, QMetaType::QRect, 3,
124		QMetaType::Void, QMetaType::QSizeF, 6,
125		QMetaType::Void, QMetaType::QReal, 8,
126		QMetaType::Void, QMetaType::QReal, 8,
127		QMetaType::Void, QMetaType::QRect, 11,
128		QMetaType::Void, 0x80000000 \| 13, 14,
129		QMetaType::Void, 0x80000000 \| 13, 14,
130		QMetaType::Void, QMetaType::QReal, 17,
131
132		// properties: name, type, flags
133		18, QMetaType::QString, 0x00095401,
134		19, QMetaType::QString, 0x00095401,
135		20, QMetaType::QString, 0x00095401,
136		21, QMetaType::QString, 0x00095401,
137		22, QMetaType::Int, 0x00095401,
138		6, QMetaType::QSize, 0x00495001,
139		23, QMetaType::QSize, 0x00495001,
140		24, QMetaType::QSize, 0x00495001,
141		25, QMetaType::QSize, 0x00495001,
142		3, QMetaType::QRect, 0x00495001,
143		26, QMetaType::QRect, 0x00495001,
144		27, QMetaType::QRect, 0x00495001,
145		28, QMetaType::QRect, 0x00495001,
146		29, QMetaType::QSizeF, 0x00495001,
147		30, QMetaType::QReal, 0x00495001,
148		31, QMetaType::QReal, 0x00495001,
149		32, QMetaType::QReal, 0x00495001,
150		33, QMetaType::QReal, 0x00495001,
151		34, QMetaType::QReal, 0x00495001,
152		35, QMetaType::QReal, 0x00495001,
153		36, QMetaType::QReal, 0x00495001,
154		37, 0x80000000 \| 13, 0x00495009,
155		14, 0x80000000 \| 13, 0x00495009,
156		38, 0x80000000 \| 13, 0x00095009,
157		17, QMetaType::QReal, 0x00495001,
158
159		// properties: notify_signal_id
160		0,
161		0,
162		0,
163		0,
164		0,
165		0,
166		1,
167		5,
168		5,
169		0,
170		1,
171		5,
172		5,
173		2,
174		3,
175		3,
176		3,
177		4,
178		4,
179		4,
180		3,
181		6,
182		7,
183		0,
184		8,
185
186		0 // eod
187		};
188
189		void QScreen::qt_static_metacall(QObject _o, QMetaObject::Call _c, int _id, void *_a)
190	0	{
191	0	if (_c == QMetaObject::InvokeMetaMethod) {
192	0	auto _t = static_cast<QScreen >(_o);
193	0	Q_UNUSED(_t)
194	0	switch (_id) {
195	0	case 0: _t->geometryChanged((reinterpret_cast< const QRect()>(_a[1]))); break;
196	0	case 1: _t->availableGeometryChanged((reinterpret_cast< const QRect()>(_a[1]))); break;
197	0	case 2: _t->physicalSizeChanged((reinterpret_cast< const QSizeF()>(_a[1]))); break;
198	0	case 3: _t->physicalDotsPerInchChanged((reinterpret_cast< qreal()>(_a[1]))); break;
199	0	case 4: _t->logicalDotsPerInchChanged((reinterpret_cast< qreal()>(_a[1]))); break;
200	0	case 5: _t->virtualGeometryChanged((reinterpret_cast< const QRect()>(_a[1]))); break;
201	0	case 6: _t->primaryOrientationChanged((reinterpret_cast< Qt::ScreenOrientation()>(_a[1]))); break;
202	0	case 7: _t->orientationChanged((reinterpret_cast< Qt::ScreenOrientation()>(_a[1]))); break;
203	0	case 8: _t->refreshRateChanged((reinterpret_cast< qreal()>(_a[1]))); break;
204	0	default: ;
205	0	}
206	0	} else if (_c == QMetaObject::IndexOfMethod) {
207	0	int result = reinterpret_cast<int >(_a[0]);
208	0	{
209	0	using _t = void (QScreen::*)(const QRect & );
210	0	if (reinterpret_cast<_t >(_a[1]) == static_cast<_t>(&QScreen::geometryChanged)) {
211	0	*result = 0;
212	0	return;
213	0	}
214	0	}
215	0	{
216	0	using _t = void (QScreen::*)(const QRect & );
217	0	if (reinterpret_cast<_t >(_a[1]) == static_cast<_t>(&QScreen::availableGeometryChanged)) {
218	0	*result = 1;
219	0	return;
220	0	}
221	0	}
222	0	{
223	0	using _t = void (QScreen::*)(const QSizeF & );
224	0	if (reinterpret_cast<_t >(_a[1]) == static_cast<_t>(&QScreen::physicalSizeChanged)) {
225	0	*result = 2;
226	0	return;
227	0	}
228	0	}
229	0	{
230	0	using _t = void (QScreen::*)(qreal );
231	0	if (reinterpret_cast<_t >(_a[1]) == static_cast<_t>(&QScreen::physicalDotsPerInchChanged)) {
232	0	*result = 3;
233	0	return;
234	0	}
235	0	}
236	0	{
237	0	using _t = void (QScreen::*)(qreal );
238	0	if (reinterpret_cast<_t >(_a[1]) == static_cast<_t>(&QScreen::logicalDotsPerInchChanged)) {
239	0	*result = 4;
240	0	return;
241	0	}
242	0	}
243	0	{
244	0	using _t = void (QScreen::*)(const QRect & );
245	0	if (reinterpret_cast<_t >(_a[1]) == static_cast<_t>(&QScreen::virtualGeometryChanged)) {
246	0	*result = 5;
247	0	return;
248	0	}
249	0	}
250	0	{
251	0	using _t = void (QScreen::*)(Qt::ScreenOrientation );
252	0	if (reinterpret_cast<_t >(_a[1]) == static_cast<_t>(&QScreen::primaryOrientationChanged)) {
253	0	*result = 6;
254	0	return;
255	0	}
256	0	}
257	0	{
258	0	using _t = void (QScreen::*)(Qt::ScreenOrientation );
259	0	if (reinterpret_cast<_t >(_a[1]) == static_cast<_t>(&QScreen::orientationChanged)) {
260	0	*result = 7;
261	0	return;
262	0	}
263	0	}
264	0	{
265	0	using _t = void (QScreen::*)(qreal );
266	0	if (reinterpret_cast<_t >(_a[1]) == static_cast<_t>(&QScreen::refreshRateChanged)) {
267	0	*result = 8;
268	0	return;
269	0	}
270	0	}
271	0	}
272	0	#ifndef QT_NO_PROPERTIES
273	0	else if (_c == QMetaObject::ReadProperty) {
274	0	auto _t = static_cast<QScreen >(_o);
275	0	Q_UNUSED(_t)
276	0	void *_v = _a[0];
277	0	switch (_id) {
278	0	case 0: reinterpret_cast< QString>(_v) = _t->name(); break;
279	0	case 1: reinterpret_cast< QString>(_v) = _t->manufacturer(); break;
280	0	case 2: reinterpret_cast< QString>(_v) = _t->model(); break;
281	0	case 3: reinterpret_cast< QString>(_v) = _t->serialNumber(); break;
282	0	case 4: reinterpret_cast< int>(_v) = _t->depth(); break;
283	0	case 5: reinterpret_cast< QSize>(_v) = _t->size(); break;
284	0	case 6: reinterpret_cast< QSize>(_v) = _t->availableSize(); break;
285	0	case 7: reinterpret_cast< QSize>(_v) = _t->virtualSize(); break;
286	0	case 8: reinterpret_cast< QSize>(_v) = _t->availableVirtualSize(); break;
287	0	case 9: reinterpret_cast< QRect>(_v) = _t->geometry(); break;
288	0	case 10: reinterpret_cast< QRect>(_v) = _t->availableGeometry(); break;
289	0	case 11: reinterpret_cast< QRect>(_v) = _t->virtualGeometry(); break;
290	0	case 12: reinterpret_cast< QRect>(_v) = _t->availableVirtualGeometry(); break;
291	0	case 13: reinterpret_cast< QSizeF>(_v) = _t->physicalSize(); break;
292	0	case 14: reinterpret_cast< qreal>(_v) = _t->physicalDotsPerInchX(); break;
293	0	case 15: reinterpret_cast< qreal>(_v) = _t->physicalDotsPerInchY(); break;
294	0	case 16: reinterpret_cast< qreal>(_v) = _t->physicalDotsPerInch(); break;
295	0	case 17: reinterpret_cast< qreal>(_v) = _t->logicalDotsPerInchX(); break;
296	0	case 18: reinterpret_cast< qreal>(_v) = _t->logicalDotsPerInchY(); break;
297	0	case 19: reinterpret_cast< qreal>(_v) = _t->logicalDotsPerInch(); break;
298	0	case 20: reinterpret_cast< qreal>(_v) = _t->devicePixelRatio(); break;
299	0	case 21: reinterpret_cast< Qt::ScreenOrientation>(_v) = _t->primaryOrientation(); break;
300	0	case 22: reinterpret_cast< Qt::ScreenOrientation>(_v) = _t->orientation(); break;
301	0	case 23: reinterpret_cast< Qt::ScreenOrientation>(_v) = _t->nativeOrientation(); break;
302	0	case 24: reinterpret_cast< qreal>(_v) = _t->refreshRate(); break;
303	0	default: break;
304	0	}
305	0	} else if (_c == QMetaObject::WriteProperty) {
306	0	} else if (_c == QMetaObject::ResetProperty) {
307	0	}
308	0	#endif // QT_NO_PROPERTIES
309	0	}
310
311		QT_INIT_METAOBJECT const QMetaObject QScreen::staticMetaObject = { {
312		QMetaObject::SuperData::link<QObject::staticMetaObject>(),
313		qt_meta_stringdata_QScreen.data,
314		qt_meta_data_QScreen,
315		qt_static_metacall,
316		nullptr,
317		nullptr
318		} };
319
320
321		const QMetaObject *QScreen::metaObject() const
322	0	{
323	0	return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
324	0	}
325
326		void QScreen::qt_metacast(const char _clname)
327	0	{
328	0	if (!_clname) return nullptr;
329	0	if (!strcmp(_clname, qt_meta_stringdata_QScreen.stringdata0))
330	0	return static_cast<void*>(this);
331	0	return QObject::qt_metacast(_clname);
332	0	}
333
334		int QScreen::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
335	0	{
336	0	_id = QObject::qt_metacall(_c, _id, _a);
337	0	if (_id < 0)
338	0	return _id;
339	0	if (_c == QMetaObject::InvokeMetaMethod) {
340	0	if (_id < 9)
341	0	qt_static_metacall(this, _c, _id, _a);
342	0	_id -= 9;
343	0	} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
344	0	if (_id < 9)
345	0	reinterpret_cast<int>(_a[0]) = -1;
346	0	_id -= 9;
347	0	}
348	0	#ifndef QT_NO_PROPERTIES
349	0	else if (_c == QMetaObject::ReadProperty \|\| _c == QMetaObject::WriteProperty
350	0	\|\| _c == QMetaObject::ResetProperty \|\| _c == QMetaObject::RegisterPropertyMetaType) {
351	0	qt_static_metacall(this, _c, _id, _a);
352	0	_id -= 25;
353	0	} else if (_c == QMetaObject::QueryPropertyDesignable) {
354	0	_id -= 25;
355	0	} else if (_c == QMetaObject::QueryPropertyScriptable) {
356	0	_id -= 25;
357	0	} else if (_c == QMetaObject::QueryPropertyStored) {
358	0	_id -= 25;
359	0	} else if (_c == QMetaObject::QueryPropertyEditable) {
360	0	_id -= 25;
361	0	} else if (_c == QMetaObject::QueryPropertyUser) {
362	0	_id -= 25;
363	0	}
364	0	#endif // QT_NO_PROPERTIES
365	0	return _id;
366	0	}
367
368		// SIGNAL 0
369		void QScreen::geometryChanged(const QRect & _t1)
370	0	{
371	0	void _a[] = { nullptr, const_cast<void>(reinterpret_cast<const void*>(std::addressof(_t1))) };
372	0	QMetaObject::activate(this, &staticMetaObject, 0, _a);
373	0	}
374
375		// SIGNAL 1
376		void QScreen::availableGeometryChanged(const QRect & _t1)
377	0	{
378	0	void _a[] = { nullptr, const_cast<void>(reinterpret_cast<const void*>(std::addressof(_t1))) };
379	0	QMetaObject::activate(this, &staticMetaObject, 1, _a);
380	0	}
381
382		// SIGNAL 2
383		void QScreen::physicalSizeChanged(const QSizeF & _t1)
384	0	{
385	0	void _a[] = { nullptr, const_cast<void>(reinterpret_cast<const void*>(std::addressof(_t1))) };
386	0	QMetaObject::activate(this, &staticMetaObject, 2, _a);
387	0	}
388
389		// SIGNAL 3
390		void QScreen::physicalDotsPerInchChanged(qreal _t1)
391	0	{
392	0	void _a[] = { nullptr, const_cast<void>(reinterpret_cast<const void*>(std::addressof(_t1))) };
393	0	QMetaObject::activate(this, &staticMetaObject, 3, _a);
394	0	}
395
396		// SIGNAL 4
397		void QScreen::logicalDotsPerInchChanged(qreal _t1)
398	0	{
399	0	void _a[] = { nullptr, const_cast<void>(reinterpret_cast<const void*>(std::addressof(_t1))) };
400	0	QMetaObject::activate(this, &staticMetaObject, 4, _a);
401	0	}
402
403		// SIGNAL 5
404		void QScreen::virtualGeometryChanged(const QRect & _t1)
405	0	{
406	0	void _a[] = { nullptr, const_cast<void>(reinterpret_cast<const void*>(std::addressof(_t1))) };
407	0	QMetaObject::activate(this, &staticMetaObject, 5, _a);
408	0	}
409
410		// SIGNAL 6
411		void QScreen::primaryOrientationChanged(Qt::ScreenOrientation _t1)
412	0	{
413	0	void _a[] = { nullptr, const_cast<void>(reinterpret_cast<const void*>(std::addressof(_t1))) };
414	0	QMetaObject::activate(this, &staticMetaObject, 6, _a);
415	0	}
416
417		// SIGNAL 7
418		void QScreen::orientationChanged(Qt::ScreenOrientation _t1)
419	0	{
420	0	void _a[] = { nullptr, const_cast<void>(reinterpret_cast<const void*>(std::addressof(_t1))) };
421	0	QMetaObject::activate(this, &staticMetaObject, 7, _a);
422	0	}
423
424		// SIGNAL 8
425		void QScreen::refreshRateChanged(qreal _t1)
426	0	{
427	0	void _a[] = { nullptr, const_cast<void>(reinterpret_cast<const void*>(std::addressof(_t1))) };
428	0	QMetaObject::activate(this, &staticMetaObject, 8, _a);
429	0	}
430		QT_WARNING_POP
431		QT_END_MOC_NAMESPACE