GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: plugins/pyqcustomplot/pyqcustomplot_autogen/MWXTG7G72Q/moc_qcustomplot.cpp Lines: 0 2267 0.0 %
Date: 2023-03-14 11:04:37 Branches: 0 2117 0.0 %

Line Branch Exec Source
1
/****************************************************************************
2
** Meta object code from reading C++ file 'qcustomplot.h'
3
**
4
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.12.8)
5
**
6
** WARNING! All changes made in this file will be lost!
7
*****************************************************************************/
8
9
#include "qcustomplot.h"
10
#include <QtCore/qbytearray.h>
11
#include <QtCore/qmetatype.h>
12
#include <QtCore/QList>
13
#include <QtCore/QVector>
14
#if !defined(Q_MOC_OUTPUT_REVISION)
15
#error "The header file 'qcustomplot.h' doesn't include <QObject>."
16
#elif Q_MOC_OUTPUT_REVISION != 67
17
#error "This file was generated using the moc from 5.12.8. It"
18
#error "cannot be used with the include files from this version of Qt."
19
#error "(The moc has changed too much.)"
20
#endif
21
22
QT_BEGIN_MOC_NAMESPACE
23
QT_WARNING_PUSH
24
QT_WARNING_DISABLE_DEPRECATED
25
struct qt_meta_stringdata_QCPScatterStyle_t {
26
    QByteArrayData data[20];
27
    char stringdata0[209];
28
};
29
#define QT_MOC_LITERAL(idx, ofs, len) \
30
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
31
    qptrdiff(offsetof(qt_meta_stringdata_QCPScatterStyle_t, stringdata0) + ofs \
32
        - idx * sizeof(QByteArrayData)) \
33
    )
34
static const qt_meta_stringdata_QCPScatterStyle_t qt_meta_stringdata_QCPScatterStyle = {
35
    {
36
QT_MOC_LITERAL(0, 0, 15), // "QCPScatterStyle"
37
QT_MOC_LITERAL(1, 16, 12), // "ScatterShape"
38
QT_MOC_LITERAL(2, 29, 6), // "ssNone"
39
QT_MOC_LITERAL(3, 36, 5), // "ssDot"
40
QT_MOC_LITERAL(4, 42, 7), // "ssCross"
41
QT_MOC_LITERAL(5, 50, 6), // "ssPlus"
42
QT_MOC_LITERAL(6, 57, 8), // "ssCircle"
43
QT_MOC_LITERAL(7, 66, 6), // "ssDisc"
44
QT_MOC_LITERAL(8, 73, 8), // "ssSquare"
45
QT_MOC_LITERAL(9, 82, 9), // "ssDiamond"
46
QT_MOC_LITERAL(10, 92, 6), // "ssStar"
47
QT_MOC_LITERAL(11, 99, 10), // "ssTriangle"
48
QT_MOC_LITERAL(12, 110, 18), // "ssTriangleInverted"
49
QT_MOC_LITERAL(13, 129, 13), // "ssCrossSquare"
50
QT_MOC_LITERAL(14, 143, 12), // "ssPlusSquare"
51
QT_MOC_LITERAL(15, 156, 13), // "ssCrossCircle"
52
QT_MOC_LITERAL(16, 170, 12), // "ssPlusCircle"
53
QT_MOC_LITERAL(17, 183, 7), // "ssPeace"
54
QT_MOC_LITERAL(18, 191, 8), // "ssPixmap"
55
QT_MOC_LITERAL(19, 200, 8) // "ssCustom"
56
57
    },
58
    "QCPScatterStyle\0ScatterShape\0ssNone\0"
59
    "ssDot\0ssCross\0ssPlus\0ssCircle\0ssDisc\0"
60
    "ssSquare\0ssDiamond\0ssStar\0ssTriangle\0"
61
    "ssTriangleInverted\0ssCrossSquare\0"
62
    "ssPlusSquare\0ssCrossCircle\0ssPlusCircle\0"
63
    "ssPeace\0ssPixmap\0ssCustom"
64
};
65
#undef QT_MOC_LITERAL
66
67
static const uint qt_meta_data_QCPScatterStyle[] = {
68
69
 // content:
70
       8,       // revision
71
       0,       // classname
72
       0,    0, // classinfo
73
       0,    0, // methods
74
       0,    0, // properties
75
       1,   14, // enums/sets
76
       0,    0, // constructors
77
       4,       // flags
78
       0,       // signalCount
79
80
 // enums: name, alias, flags, count, data
81
       1,    1, 0x0,   18,   19,
82
83
 // enum data: key, value
84
       2, uint(QCPScatterStyle::ssNone),
85
       3, uint(QCPScatterStyle::ssDot),
86
       4, uint(QCPScatterStyle::ssCross),
87
       5, uint(QCPScatterStyle::ssPlus),
88
       6, uint(QCPScatterStyle::ssCircle),
89
       7, uint(QCPScatterStyle::ssDisc),
90
       8, uint(QCPScatterStyle::ssSquare),
91
       9, uint(QCPScatterStyle::ssDiamond),
92
      10, uint(QCPScatterStyle::ssStar),
93
      11, uint(QCPScatterStyle::ssTriangle),
94
      12, uint(QCPScatterStyle::ssTriangleInverted),
95
      13, uint(QCPScatterStyle::ssCrossSquare),
96
      14, uint(QCPScatterStyle::ssPlusSquare),
97
      15, uint(QCPScatterStyle::ssCrossCircle),
98
      16, uint(QCPScatterStyle::ssPlusCircle),
99
      17, uint(QCPScatterStyle::ssPeace),
100
      18, uint(QCPScatterStyle::ssPixmap),
101
      19, uint(QCPScatterStyle::ssCustom),
102
103
       0        // eod
104
};
105
106
QT_INIT_METAOBJECT const QMetaObject QCPScatterStyle::staticMetaObject = { {
107
    nullptr,
108
    qt_meta_stringdata_QCPScatterStyle.data,
109
    qt_meta_data_QCPScatterStyle,
110
    nullptr,
111
    nullptr,
112
    nullptr
113
} };
114
115
struct qt_meta_stringdata_QCPPainter_t {
116
    QByteArrayData data[7];
117
    char stringdata0[85];
118
};
119
#define QT_MOC_LITERAL(idx, ofs, len) \
120
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
121
    qptrdiff(offsetof(qt_meta_stringdata_QCPPainter_t, stringdata0) + ofs \
122
        - idx * sizeof(QByteArrayData)) \
123
    )
124
static const qt_meta_stringdata_QCPPainter_t qt_meta_stringdata_QCPPainter = {
125
    {
126
QT_MOC_LITERAL(0, 0, 10), // "QCPPainter"
127
QT_MOC_LITERAL(1, 11, 11), // "PainterMode"
128
QT_MOC_LITERAL(2, 23, 9), // "pmDefault"
129
QT_MOC_LITERAL(3, 33, 12), // "pmVectorized"
130
QT_MOC_LITERAL(4, 46, 11), // "pmNoCaching"
131
QT_MOC_LITERAL(5, 58, 13), // "pmNonCosmetic"
132
QT_MOC_LITERAL(6, 72, 12) // "PainterModes"
133
134
    },
135
    "QCPPainter\0PainterMode\0pmDefault\0"
136
    "pmVectorized\0pmNoCaching\0pmNonCosmetic\0"
137
    "PainterModes"
138
};
139
#undef QT_MOC_LITERAL
140
141
static const uint qt_meta_data_QCPPainter[] = {
142
143
 // content:
144
       8,       // revision
145
       0,       // classname
146
       0,    0, // classinfo
147
       0,    0, // methods
148
       0,    0, // properties
149
       2,   14, // enums/sets
150
       0,    0, // constructors
151
       4,       // flags
152
       0,       // signalCount
153
154
 // enums: name, alias, flags, count, data
155
       1,    1, 0x1,    4,   24,
156
       6,    1, 0x1,    4,   32,
157
158
 // enum data: key, value
159
       2, uint(QCPPainter::pmDefault),
160
       3, uint(QCPPainter::pmVectorized),
161
       4, uint(QCPPainter::pmNoCaching),
162
       5, uint(QCPPainter::pmNonCosmetic),
163
       2, uint(QCPPainter::pmDefault),
164
       3, uint(QCPPainter::pmVectorized),
165
       4, uint(QCPPainter::pmNoCaching),
166
       5, uint(QCPPainter::pmNonCosmetic),
167
168
       0        // eod
169
};
170
171
QT_INIT_METAOBJECT const QMetaObject QCPPainter::staticMetaObject = { {
172
    &QPainter::staticMetaObject,
173
    qt_meta_stringdata_QCPPainter.data,
174
    qt_meta_data_QCPPainter,
175
    nullptr,
176
    nullptr,
177
    nullptr
178
} };
179
180
struct qt_meta_stringdata_QCPLayer_t {
181
    QByteArrayData data[8];
182
    char stringdata0[82];
183
};
184
#define QT_MOC_LITERAL(idx, ofs, len) \
185
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
186
    qptrdiff(offsetof(qt_meta_stringdata_QCPLayer_t, stringdata0) + ofs \
187
        - idx * sizeof(QByteArrayData)) \
188
    )
189
static const qt_meta_stringdata_QCPLayer_t qt_meta_stringdata_QCPLayer = {
190
    {
191
QT_MOC_LITERAL(0, 0, 8), // "QCPLayer"
192
QT_MOC_LITERAL(1, 9, 10), // "parentPlot"
193
QT_MOC_LITERAL(2, 20, 12), // "QCustomPlot*"
194
QT_MOC_LITERAL(3, 33, 4), // "name"
195
QT_MOC_LITERAL(4, 38, 5), // "index"
196
QT_MOC_LITERAL(5, 44, 8), // "children"
197
QT_MOC_LITERAL(6, 53, 20), // "QList<QCPLayerable*>"
198
QT_MOC_LITERAL(7, 74, 7) // "visible"
199
200
    },
201
    "QCPLayer\0parentPlot\0QCustomPlot*\0name\0"
202
    "index\0children\0QList<QCPLayerable*>\0"
203
    "visible"
204
};
205
#undef QT_MOC_LITERAL
206
207
static const uint qt_meta_data_QCPLayer[] = {
208
209
 // content:
210
       8,       // revision
211
       0,       // classname
212
       0,    0, // classinfo
213
       0,    0, // methods
214
       5,   14, // properties
215
       0,    0, // enums/sets
216
       0,    0, // constructors
217
       0,       // flags
218
       0,       // signalCount
219
220
 // properties: name, type, flags
221
       1, 0x80000000 | 2, 0x00095009,
222
       3, QMetaType::QString, 0x00095001,
223
       4, QMetaType::Int, 0x00095001,
224
       5, 0x80000000 | 6, 0x00095009,
225
       7, QMetaType::Bool, 0x00095103,
226
227
       0        // eod
228
};
229
230
void QCPLayer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
231
{
232
    if (_c == QMetaObject::RegisterPropertyMetaType) {
233
        switch (_id) {
234
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
235
        case 0:
236
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCustomPlot* >(); break;
237
        case 3:
238
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<QCPLayerable*> >(); break;
239
        }
240
    }
241
242
#ifndef QT_NO_PROPERTIES
243
    else if (_c == QMetaObject::ReadProperty) {
244
        auto *_t = static_cast<QCPLayer *>(_o);
245
        Q_UNUSED(_t)
246
        void *_v = _a[0];
247
        switch (_id) {
248
        case 0: *reinterpret_cast< QCustomPlot**>(_v) = _t->parentPlot(); break;
249
        case 1: *reinterpret_cast< QString*>(_v) = _t->name(); break;
250
        case 2: *reinterpret_cast< int*>(_v) = _t->index(); break;
251
        case 3: *reinterpret_cast< QList<QCPLayerable*>*>(_v) = _t->children(); break;
252
        case 4: *reinterpret_cast< bool*>(_v) = _t->visible(); break;
253
        default: break;
254
        }
255
    } else if (_c == QMetaObject::WriteProperty) {
256
        auto *_t = static_cast<QCPLayer *>(_o);
257
        Q_UNUSED(_t)
258
        void *_v = _a[0];
259
        switch (_id) {
260
        case 4: _t->setVisible(*reinterpret_cast< bool*>(_v)); break;
261
        default: break;
262
        }
263
    } else if (_c == QMetaObject::ResetProperty) {
264
    }
265
#endif // QT_NO_PROPERTIES
266
    Q_UNUSED(_o);
267
}
268
269
QT_INIT_METAOBJECT const QMetaObject QCPLayer::staticMetaObject = { {
270
    &QObject::staticMetaObject,
271
    qt_meta_stringdata_QCPLayer.data,
272
    qt_meta_data_QCPLayer,
273
    qt_static_metacall,
274
    nullptr,
275
    nullptr
276
} };
277
278
279
const QMetaObject *QCPLayer::metaObject() const
280
{
281
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
282
}
283
284
void *QCPLayer::qt_metacast(const char *_clname)
285
{
286
    if (!_clname) return nullptr;
287
    if (!strcmp(_clname, qt_meta_stringdata_QCPLayer.stringdata0))
288
        return static_cast<void*>(this);
289
    return QObject::qt_metacast(_clname);
290
}
291
292
int QCPLayer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
293
{
294
    _id = QObject::qt_metacall(_c, _id, _a);
295
    if (_id < 0)
296
        return _id;
297
298
#ifndef QT_NO_PROPERTIES
299
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
300
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
301
        qt_static_metacall(this, _c, _id, _a);
302
        _id -= 5;
303
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
304
        _id -= 5;
305
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
306
        _id -= 5;
307
    } else if (_c == QMetaObject::QueryPropertyStored) {
308
        _id -= 5;
309
    } else if (_c == QMetaObject::QueryPropertyEditable) {
310
        _id -= 5;
311
    } else if (_c == QMetaObject::QueryPropertyUser) {
312
        _id -= 5;
313
    }
314
#endif // QT_NO_PROPERTIES
315
    return _id;
316
}
317
struct qt_meta_stringdata_QCPLayerable_t {
318
    QByteArrayData data[13];
319
    char stringdata0[135];
320
};
321
#define QT_MOC_LITERAL(idx, ofs, len) \
322
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
323
    qptrdiff(offsetof(qt_meta_stringdata_QCPLayerable_t, stringdata0) + ofs \
324
        - idx * sizeof(QByteArrayData)) \
325
    )
326
static const qt_meta_stringdata_QCPLayerable_t qt_meta_stringdata_QCPLayerable = {
327
    {
328
QT_MOC_LITERAL(0, 0, 12), // "QCPLayerable"
329
QT_MOC_LITERAL(1, 13, 12), // "layerChanged"
330
QT_MOC_LITERAL(2, 26, 0), // ""
331
QT_MOC_LITERAL(3, 27, 9), // "QCPLayer*"
332
QT_MOC_LITERAL(4, 37, 8), // "newLayer"
333
QT_MOC_LITERAL(5, 46, 8), // "setLayer"
334
QT_MOC_LITERAL(6, 55, 5), // "layer"
335
QT_MOC_LITERAL(7, 61, 7), // "visible"
336
QT_MOC_LITERAL(8, 69, 10), // "parentPlot"
337
QT_MOC_LITERAL(9, 80, 12), // "QCustomPlot*"
338
QT_MOC_LITERAL(10, 93, 15), // "parentLayerable"
339
QT_MOC_LITERAL(11, 109, 13), // "QCPLayerable*"
340
QT_MOC_LITERAL(12, 123, 11) // "antialiased"
341
342
    },
343
    "QCPLayerable\0layerChanged\0\0QCPLayer*\0"
344
    "newLayer\0setLayer\0layer\0visible\0"
345
    "parentPlot\0QCustomPlot*\0parentLayerable\0"
346
    "QCPLayerable*\0antialiased"
347
};
348
#undef QT_MOC_LITERAL
349
350
static const uint qt_meta_data_QCPLayerable[] = {
351
352
 // content:
353
       8,       // revision
354
       0,       // classname
355
       0,    0, // classinfo
356
       2,   14, // methods
357
       5,   30, // properties
358
       0,    0, // enums/sets
359
       0,    0, // constructors
360
       0,       // flags
361
       1,       // signalCount
362
363
 // signals: name, argc, parameters, tag, flags
364
       1,    1,   24,    2, 0x06 /* Public */,
365
366
 // slots: name, argc, parameters, tag, flags
367
       5,    1,   27,    2, 0x0a /* Public */,
368
369
 // signals: parameters
370
    QMetaType::Void, 0x80000000 | 3,    4,
371
372
 // slots: parameters
373
    QMetaType::Bool, 0x80000000 | 3,    6,
374
375
 // properties: name, type, flags
376
       7, QMetaType::Bool, 0x00095103,
377
       8, 0x80000000 | 9, 0x00095009,
378
      10, 0x80000000 | 11, 0x00095009,
379
       6, 0x80000000 | 3, 0x0049510b,
380
      12, QMetaType::Bool, 0x00095103,
381
382
 // properties: notify_signal_id
383
       0,
384
       0,
385
       0,
386
       0,
387
       0,
388
389
       0        // eod
390
};
391
392
void QCPLayerable::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
393
{
394
    if (_c == QMetaObject::InvokeMetaMethod) {
395
        auto *_t = static_cast<QCPLayerable *>(_o);
396
        Q_UNUSED(_t)
397
        switch (_id) {
398
        case 0: _t->layerChanged((*reinterpret_cast< QCPLayer*(*)>(_a[1]))); break;
399
        case 1: { bool _r = _t->setLayer((*reinterpret_cast< QCPLayer*(*)>(_a[1])));
400
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = std::move(_r); }  break;
401
        default: ;
402
        }
403
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
404
        switch (_id) {
405
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
406
        case 0:
407
            switch (*reinterpret_cast<int*>(_a[1])) {
408
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
409
            case 0:
410
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayer* >(); break;
411
            }
412
            break;
413
        case 1:
414
            switch (*reinterpret_cast<int*>(_a[1])) {
415
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
416
            case 0:
417
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayer* >(); break;
418
            }
419
            break;
420
        }
421
    } else if (_c == QMetaObject::IndexOfMethod) {
422
        int *result = reinterpret_cast<int *>(_a[0]);
423
        {
424
            using _t = void (QCPLayerable::*)(QCPLayer * );
425
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPLayerable::layerChanged)) {
426
                *result = 0;
427
                return;
428
            }
429
        }
430
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
431
        switch (_id) {
432
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
433
        case 3:
434
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayer* >(); break;
435
        case 2:
436
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayerable* >(); break;
437
        case 1:
438
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCustomPlot* >(); break;
439
        }
440
    }
441
442
#ifndef QT_NO_PROPERTIES
443
    else if (_c == QMetaObject::ReadProperty) {
444
        auto *_t = static_cast<QCPLayerable *>(_o);
445
        Q_UNUSED(_t)
446
        void *_v = _a[0];
447
        switch (_id) {
448
        case 0: *reinterpret_cast< bool*>(_v) = _t->visible(); break;
449
        case 1: *reinterpret_cast< QCustomPlot**>(_v) = _t->parentPlot(); break;
450
        case 2: *reinterpret_cast< QCPLayerable**>(_v) = _t->parentLayerable(); break;
451
        case 3: *reinterpret_cast< QCPLayer**>(_v) = _t->layer(); break;
452
        case 4: *reinterpret_cast< bool*>(_v) = _t->antialiased(); break;
453
        default: break;
454
        }
455
    } else if (_c == QMetaObject::WriteProperty) {
456
        auto *_t = static_cast<QCPLayerable *>(_o);
457
        Q_UNUSED(_t)
458
        void *_v = _a[0];
459
        switch (_id) {
460
        case 0: _t->setVisible(*reinterpret_cast< bool*>(_v)); break;
461
        case 3: _t->setLayer(*reinterpret_cast< QCPLayer**>(_v)); break;
462
        case 4: _t->setAntialiased(*reinterpret_cast< bool*>(_v)); break;
463
        default: break;
464
        }
465
    } else if (_c == QMetaObject::ResetProperty) {
466
    }
467
#endif // QT_NO_PROPERTIES
468
}
469
470
QT_INIT_METAOBJECT const QMetaObject QCPLayerable::staticMetaObject = { {
471
    &QObject::staticMetaObject,
472
    qt_meta_stringdata_QCPLayerable.data,
473
    qt_meta_data_QCPLayerable,
474
    qt_static_metacall,
475
    nullptr,
476
    nullptr
477
} };
478
479
480
const QMetaObject *QCPLayerable::metaObject() const
481
{
482
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
483
}
484
485
void *QCPLayerable::qt_metacast(const char *_clname)
486
{
487
    if (!_clname) return nullptr;
488
    if (!strcmp(_clname, qt_meta_stringdata_QCPLayerable.stringdata0))
489
        return static_cast<void*>(this);
490
    return QObject::qt_metacast(_clname);
491
}
492
493
int QCPLayerable::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
494
{
495
    _id = QObject::qt_metacall(_c, _id, _a);
496
    if (_id < 0)
497
        return _id;
498
    if (_c == QMetaObject::InvokeMetaMethod) {
499
        if (_id < 2)
500
            qt_static_metacall(this, _c, _id, _a);
501
        _id -= 2;
502
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
503
        if (_id < 2)
504
            qt_static_metacall(this, _c, _id, _a);
505
        _id -= 2;
506
    }
507
#ifndef QT_NO_PROPERTIES
508
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
509
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
510
        qt_static_metacall(this, _c, _id, _a);
511
        _id -= 5;
512
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
513
        _id -= 5;
514
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
515
        _id -= 5;
516
    } else if (_c == QMetaObject::QueryPropertyStored) {
517
        _id -= 5;
518
    } else if (_c == QMetaObject::QueryPropertyEditable) {
519
        _id -= 5;
520
    } else if (_c == QMetaObject::QueryPropertyUser) {
521
        _id -= 5;
522
    }
523
#endif // QT_NO_PROPERTIES
524
    return _id;
525
}
526
527
// SIGNAL 0
528
void QCPLayerable::layerChanged(QCPLayer * _t1)
529
{
530
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
531
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
532
}
533
struct qt_meta_stringdata_QCPMarginGroup_t {
534
    QByteArrayData data[1];
535
    char stringdata0[15];
536
};
537
#define QT_MOC_LITERAL(idx, ofs, len) \
538
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
539
    qptrdiff(offsetof(qt_meta_stringdata_QCPMarginGroup_t, stringdata0) + ofs \
540
        - idx * sizeof(QByteArrayData)) \
541
    )
542
static const qt_meta_stringdata_QCPMarginGroup_t qt_meta_stringdata_QCPMarginGroup = {
543
    {
544
QT_MOC_LITERAL(0, 0, 14) // "QCPMarginGroup"
545
546
    },
547
    "QCPMarginGroup"
548
};
549
#undef QT_MOC_LITERAL
550
551
static const uint qt_meta_data_QCPMarginGroup[] = {
552
553
 // content:
554
       8,       // revision
555
       0,       // classname
556
       0,    0, // classinfo
557
       0,    0, // methods
558
       0,    0, // properties
559
       0,    0, // enums/sets
560
       0,    0, // constructors
561
       0,       // flags
562
       0,       // signalCount
563
564
       0        // eod
565
};
566
567
void QCPMarginGroup::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
568
{
569
    Q_UNUSED(_o);
570
    Q_UNUSED(_id);
571
    Q_UNUSED(_c);
572
    Q_UNUSED(_a);
573
}
574
575
QT_INIT_METAOBJECT const QMetaObject QCPMarginGroup::staticMetaObject = { {
576
    &QObject::staticMetaObject,
577
    qt_meta_stringdata_QCPMarginGroup.data,
578
    qt_meta_data_QCPMarginGroup,
579
    qt_static_metacall,
580
    nullptr,
581
    nullptr
582
} };
583
584
585
const QMetaObject *QCPMarginGroup::metaObject() const
586
{
587
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
588
}
589
590
void *QCPMarginGroup::qt_metacast(const char *_clname)
591
{
592
    if (!_clname) return nullptr;
593
    if (!strcmp(_clname, qt_meta_stringdata_QCPMarginGroup.stringdata0))
594
        return static_cast<void*>(this);
595
    return QObject::qt_metacast(_clname);
596
}
597
598
int QCPMarginGroup::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
599
{
600
    _id = QObject::qt_metacall(_c, _id, _a);
601
    return _id;
602
}
603
struct qt_meta_stringdata_QCPLayoutElement_t {
604
    QByteArrayData data[14];
605
    char stringdata0[151];
606
};
607
#define QT_MOC_LITERAL(idx, ofs, len) \
608
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
609
    qptrdiff(offsetof(qt_meta_stringdata_QCPLayoutElement_t, stringdata0) + ofs \
610
        - idx * sizeof(QByteArrayData)) \
611
    )
612
static const qt_meta_stringdata_QCPLayoutElement_t qt_meta_stringdata_QCPLayoutElement = {
613
    {
614
QT_MOC_LITERAL(0, 0, 16), // "QCPLayoutElement"
615
QT_MOC_LITERAL(1, 17, 6), // "layout"
616
QT_MOC_LITERAL(2, 24, 10), // "QCPLayout*"
617
QT_MOC_LITERAL(3, 35, 4), // "rect"
618
QT_MOC_LITERAL(4, 40, 9), // "outerRect"
619
QT_MOC_LITERAL(5, 50, 7), // "margins"
620
QT_MOC_LITERAL(6, 58, 8), // "QMargins"
621
QT_MOC_LITERAL(7, 67, 14), // "minimumMargins"
622
QT_MOC_LITERAL(8, 82, 11), // "minimumSize"
623
QT_MOC_LITERAL(9, 94, 11), // "maximumSize"
624
QT_MOC_LITERAL(10, 106, 11), // "UpdatePhase"
625
QT_MOC_LITERAL(11, 118, 13), // "upPreparation"
626
QT_MOC_LITERAL(12, 132, 9), // "upMargins"
627
QT_MOC_LITERAL(13, 142, 8) // "upLayout"
628
629
    },
630
    "QCPLayoutElement\0layout\0QCPLayout*\0"
631
    "rect\0outerRect\0margins\0QMargins\0"
632
    "minimumMargins\0minimumSize\0maximumSize\0"
633
    "UpdatePhase\0upPreparation\0upMargins\0"
634
    "upLayout"
635
};
636
#undef QT_MOC_LITERAL
637
638
static const uint qt_meta_data_QCPLayoutElement[] = {
639
640
 // content:
641
       8,       // revision
642
       0,       // classname
643
       0,    0, // classinfo
644
       0,    0, // methods
645
       7,   14, // properties
646
       1,   35, // enums/sets
647
       0,    0, // constructors
648
       0,       // flags
649
       0,       // signalCount
650
651
 // properties: name, type, flags
652
       1, 0x80000000 | 2, 0x00095009,
653
       3, QMetaType::QRect, 0x00095001,
654
       4, QMetaType::QRect, 0x00095103,
655
       5, 0x80000000 | 6, 0x0009510b,
656
       7, 0x80000000 | 6, 0x0009510b,
657
       8, QMetaType::QSize, 0x00095103,
658
       9, QMetaType::QSize, 0x00095103,
659
660
 // enums: name, alias, flags, count, data
661
      10,   10, 0x0,    3,   40,
662
663
 // enum data: key, value
664
      11, uint(QCPLayoutElement::upPreparation),
665
      12, uint(QCPLayoutElement::upMargins),
666
      13, uint(QCPLayoutElement::upLayout),
667
668
       0        // eod
669
};
670
671
void QCPLayoutElement::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
672
{
673
    if (_c == QMetaObject::RegisterPropertyMetaType) {
674
        switch (_id) {
675
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
676
        case 0:
677
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayout* >(); break;
678
        }
679
    }
680
681
#ifndef QT_NO_PROPERTIES
682
    else if (_c == QMetaObject::ReadProperty) {
683
        auto *_t = static_cast<QCPLayoutElement *>(_o);
684
        Q_UNUSED(_t)
685
        void *_v = _a[0];
686
        switch (_id) {
687
        case 0: *reinterpret_cast< QCPLayout**>(_v) = _t->layout(); break;
688
        case 1: *reinterpret_cast< QRect*>(_v) = _t->rect(); break;
689
        case 2: *reinterpret_cast< QRect*>(_v) = _t->outerRect(); break;
690
        case 3: *reinterpret_cast< QMargins*>(_v) = _t->margins(); break;
691
        case 4: *reinterpret_cast< QMargins*>(_v) = _t->minimumMargins(); break;
692
        case 5: *reinterpret_cast< QSize*>(_v) = _t->minimumSize(); break;
693
        case 6: *reinterpret_cast< QSize*>(_v) = _t->maximumSize(); break;
694
        default: break;
695
        }
696
    } else if (_c == QMetaObject::WriteProperty) {
697
        auto *_t = static_cast<QCPLayoutElement *>(_o);
698
        Q_UNUSED(_t)
699
        void *_v = _a[0];
700
        switch (_id) {
701
        case 2: _t->setOuterRect(*reinterpret_cast< QRect*>(_v)); break;
702
        case 3: _t->setMargins(*reinterpret_cast< QMargins*>(_v)); break;
703
        case 4: _t->setMinimumMargins(*reinterpret_cast< QMargins*>(_v)); break;
704
        case 5: _t->setMinimumSize(*reinterpret_cast< QSize*>(_v)); break;
705
        case 6: _t->setMaximumSize(*reinterpret_cast< QSize*>(_v)); break;
706
        default: break;
707
        }
708
    } else if (_c == QMetaObject::ResetProperty) {
709
    }
710
#endif // QT_NO_PROPERTIES
711
    Q_UNUSED(_o);
712
}
713
714
QT_INIT_METAOBJECT const QMetaObject QCPLayoutElement::staticMetaObject = { {
715
    &QCPLayerable::staticMetaObject,
716
    qt_meta_stringdata_QCPLayoutElement.data,
717
    qt_meta_data_QCPLayoutElement,
718
    qt_static_metacall,
719
    nullptr,
720
    nullptr
721
} };
722
723
724
const QMetaObject *QCPLayoutElement::metaObject() const
725
{
726
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
727
}
728
729
void *QCPLayoutElement::qt_metacast(const char *_clname)
730
{
731
    if (!_clname) return nullptr;
732
    if (!strcmp(_clname, qt_meta_stringdata_QCPLayoutElement.stringdata0))
733
        return static_cast<void*>(this);
734
    return QCPLayerable::qt_metacast(_clname);
735
}
736
737
int QCPLayoutElement::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
738
{
739
    _id = QCPLayerable::qt_metacall(_c, _id, _a);
740
    if (_id < 0)
741
        return _id;
742
743
#ifndef QT_NO_PROPERTIES
744
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
745
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
746
        qt_static_metacall(this, _c, _id, _a);
747
        _id -= 7;
748
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
749
        _id -= 7;
750
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
751
        _id -= 7;
752
    } else if (_c == QMetaObject::QueryPropertyStored) {
753
        _id -= 7;
754
    } else if (_c == QMetaObject::QueryPropertyEditable) {
755
        _id -= 7;
756
    } else if (_c == QMetaObject::QueryPropertyUser) {
757
        _id -= 7;
758
    }
759
#endif // QT_NO_PROPERTIES
760
    return _id;
761
}
762
struct qt_meta_stringdata_QCPLayout_t {
763
    QByteArrayData data[1];
764
    char stringdata0[10];
765
};
766
#define QT_MOC_LITERAL(idx, ofs, len) \
767
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
768
    qptrdiff(offsetof(qt_meta_stringdata_QCPLayout_t, stringdata0) + ofs \
769
        - idx * sizeof(QByteArrayData)) \
770
    )
771
static const qt_meta_stringdata_QCPLayout_t qt_meta_stringdata_QCPLayout = {
772
    {
773
QT_MOC_LITERAL(0, 0, 9) // "QCPLayout"
774
775
    },
776
    "QCPLayout"
777
};
778
#undef QT_MOC_LITERAL
779
780
static const uint qt_meta_data_QCPLayout[] = {
781
782
 // content:
783
       8,       // revision
784
       0,       // classname
785
       0,    0, // classinfo
786
       0,    0, // methods
787
       0,    0, // properties
788
       0,    0, // enums/sets
789
       0,    0, // constructors
790
       0,       // flags
791
       0,       // signalCount
792
793
       0        // eod
794
};
795
796
void QCPLayout::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
797
{
798
    Q_UNUSED(_o);
799
    Q_UNUSED(_id);
800
    Q_UNUSED(_c);
801
    Q_UNUSED(_a);
802
}
803
804
QT_INIT_METAOBJECT const QMetaObject QCPLayout::staticMetaObject = { {
805
    &QCPLayoutElement::staticMetaObject,
806
    qt_meta_stringdata_QCPLayout.data,
807
    qt_meta_data_QCPLayout,
808
    qt_static_metacall,
809
    nullptr,
810
    nullptr
811
} };
812
813
814
const QMetaObject *QCPLayout::metaObject() const
815
{
816
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
817
}
818
819
void *QCPLayout::qt_metacast(const char *_clname)
820
{
821
    if (!_clname) return nullptr;
822
    if (!strcmp(_clname, qt_meta_stringdata_QCPLayout.stringdata0))
823
        return static_cast<void*>(this);
824
    return QCPLayoutElement::qt_metacast(_clname);
825
}
826
827
int QCPLayout::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
828
{
829
    _id = QCPLayoutElement::qt_metacall(_c, _id, _a);
830
    return _id;
831
}
832
struct qt_meta_stringdata_QCPLayoutGrid_t {
833
    QByteArrayData data[8];
834
    char stringdata0[113];
835
};
836
#define QT_MOC_LITERAL(idx, ofs, len) \
837
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
838
    qptrdiff(offsetof(qt_meta_stringdata_QCPLayoutGrid_t, stringdata0) + ofs \
839
        - idx * sizeof(QByteArrayData)) \
840
    )
841
static const qt_meta_stringdata_QCPLayoutGrid_t qt_meta_stringdata_QCPLayoutGrid = {
842
    {
843
QT_MOC_LITERAL(0, 0, 13), // "QCPLayoutGrid"
844
QT_MOC_LITERAL(1, 14, 8), // "rowCount"
845
QT_MOC_LITERAL(2, 23, 11), // "columnCount"
846
QT_MOC_LITERAL(3, 35, 20), // "columnStretchFactors"
847
QT_MOC_LITERAL(4, 56, 13), // "QList<double>"
848
QT_MOC_LITERAL(5, 70, 17), // "rowStretchFactors"
849
QT_MOC_LITERAL(6, 88, 13), // "columnSpacing"
850
QT_MOC_LITERAL(7, 102, 10) // "rowSpacing"
851
852
    },
853
    "QCPLayoutGrid\0rowCount\0columnCount\0"
854
    "columnStretchFactors\0QList<double>\0"
855
    "rowStretchFactors\0columnSpacing\0"
856
    "rowSpacing"
857
};
858
#undef QT_MOC_LITERAL
859
860
static const uint qt_meta_data_QCPLayoutGrid[] = {
861
862
 // content:
863
       8,       // revision
864
       0,       // classname
865
       0,    0, // classinfo
866
       0,    0, // methods
867
       6,   14, // properties
868
       0,    0, // enums/sets
869
       0,    0, // constructors
870
       0,       // flags
871
       0,       // signalCount
872
873
 // properties: name, type, flags
874
       1, QMetaType::Int, 0x00095001,
875
       2, QMetaType::Int, 0x00095001,
876
       3, 0x80000000 | 4, 0x0009510b,
877
       5, 0x80000000 | 4, 0x0009510b,
878
       6, QMetaType::Int, 0x00095103,
879
       7, QMetaType::Int, 0x00095103,
880
881
       0        // eod
882
};
883
884
void QCPLayoutGrid::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
885
{
886
    if (_c == QMetaObject::RegisterPropertyMetaType) {
887
        switch (_id) {
888
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
889
        case 3:
890
        case 2:
891
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<double> >(); break;
892
        }
893
    }
894
895
#ifndef QT_NO_PROPERTIES
896
    else if (_c == QMetaObject::ReadProperty) {
897
        auto *_t = static_cast<QCPLayoutGrid *>(_o);
898
        Q_UNUSED(_t)
899
        void *_v = _a[0];
900
        switch (_id) {
901
        case 0: *reinterpret_cast< int*>(_v) = _t->rowCount(); break;
902
        case 1: *reinterpret_cast< int*>(_v) = _t->columnCount(); break;
903
        case 2: *reinterpret_cast< QList<double>*>(_v) = _t->columnStretchFactors(); break;
904
        case 3: *reinterpret_cast< QList<double>*>(_v) = _t->rowStretchFactors(); break;
905
        case 4: *reinterpret_cast< int*>(_v) = _t->columnSpacing(); break;
906
        case 5: *reinterpret_cast< int*>(_v) = _t->rowSpacing(); break;
907
        default: break;
908
        }
909
    } else if (_c == QMetaObject::WriteProperty) {
910
        auto *_t = static_cast<QCPLayoutGrid *>(_o);
911
        Q_UNUSED(_t)
912
        void *_v = _a[0];
913
        switch (_id) {
914
        case 2: _t->setColumnStretchFactors(*reinterpret_cast< QList<double>*>(_v)); break;
915
        case 3: _t->setRowStretchFactors(*reinterpret_cast< QList<double>*>(_v)); break;
916
        case 4: _t->setColumnSpacing(*reinterpret_cast< int*>(_v)); break;
917
        case 5: _t->setRowSpacing(*reinterpret_cast< int*>(_v)); break;
918
        default: break;
919
        }
920
    } else if (_c == QMetaObject::ResetProperty) {
921
    }
922
#endif // QT_NO_PROPERTIES
923
    Q_UNUSED(_o);
924
}
925
926
QT_INIT_METAOBJECT const QMetaObject QCPLayoutGrid::staticMetaObject = { {
927
    &QCPLayout::staticMetaObject,
928
    qt_meta_stringdata_QCPLayoutGrid.data,
929
    qt_meta_data_QCPLayoutGrid,
930
    qt_static_metacall,
931
    nullptr,
932
    nullptr
933
} };
934
935
936
const QMetaObject *QCPLayoutGrid::metaObject() const
937
{
938
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
939
}
940
941
void *QCPLayoutGrid::qt_metacast(const char *_clname)
942
{
943
    if (!_clname) return nullptr;
944
    if (!strcmp(_clname, qt_meta_stringdata_QCPLayoutGrid.stringdata0))
945
        return static_cast<void*>(this);
946
    return QCPLayout::qt_metacast(_clname);
947
}
948
949
int QCPLayoutGrid::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
950
{
951
    _id = QCPLayout::qt_metacall(_c, _id, _a);
952
    if (_id < 0)
953
        return _id;
954
955
#ifndef QT_NO_PROPERTIES
956
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
957
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
958
        qt_static_metacall(this, _c, _id, _a);
959
        _id -= 6;
960
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
961
        _id -= 6;
962
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
963
        _id -= 6;
964
    } else if (_c == QMetaObject::QueryPropertyStored) {
965
        _id -= 6;
966
    } else if (_c == QMetaObject::QueryPropertyEditable) {
967
        _id -= 6;
968
    } else if (_c == QMetaObject::QueryPropertyUser) {
969
        _id -= 6;
970
    }
971
#endif // QT_NO_PROPERTIES
972
    return _id;
973
}
974
struct qt_meta_stringdata_QCPLayoutInset_t {
975
    QByteArrayData data[1];
976
    char stringdata0[15];
977
};
978
#define QT_MOC_LITERAL(idx, ofs, len) \
979
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
980
    qptrdiff(offsetof(qt_meta_stringdata_QCPLayoutInset_t, stringdata0) + ofs \
981
        - idx * sizeof(QByteArrayData)) \
982
    )
983
static const qt_meta_stringdata_QCPLayoutInset_t qt_meta_stringdata_QCPLayoutInset = {
984
    {
985
QT_MOC_LITERAL(0, 0, 14) // "QCPLayoutInset"
986
987
    },
988
    "QCPLayoutInset"
989
};
990
#undef QT_MOC_LITERAL
991
992
static const uint qt_meta_data_QCPLayoutInset[] = {
993
994
 // content:
995
       8,       // revision
996
       0,       // classname
997
       0,    0, // classinfo
998
       0,    0, // methods
999
       0,    0, // properties
1000
       0,    0, // enums/sets
1001
       0,    0, // constructors
1002
       0,       // flags
1003
       0,       // signalCount
1004
1005
       0        // eod
1006
};
1007
1008
void QCPLayoutInset::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
1009
{
1010
    Q_UNUSED(_o);
1011
    Q_UNUSED(_id);
1012
    Q_UNUSED(_c);
1013
    Q_UNUSED(_a);
1014
}
1015
1016
QT_INIT_METAOBJECT const QMetaObject QCPLayoutInset::staticMetaObject = { {
1017
    &QCPLayout::staticMetaObject,
1018
    qt_meta_stringdata_QCPLayoutInset.data,
1019
    qt_meta_data_QCPLayoutInset,
1020
    qt_static_metacall,
1021
    nullptr,
1022
    nullptr
1023
} };
1024
1025
1026
const QMetaObject *QCPLayoutInset::metaObject() const
1027
{
1028
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
1029
}
1030
1031
void *QCPLayoutInset::qt_metacast(const char *_clname)
1032
{
1033
    if (!_clname) return nullptr;
1034
    if (!strcmp(_clname, qt_meta_stringdata_QCPLayoutInset.stringdata0))
1035
        return static_cast<void*>(this);
1036
    return QCPLayout::qt_metacast(_clname);
1037
}
1038
1039
int QCPLayoutInset::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
1040
{
1041
    _id = QCPLayout::qt_metacall(_c, _id, _a);
1042
    return _id;
1043
}
1044
struct qt_meta_stringdata_QCPLineEnding_t {
1045
    QByteArrayData data[12];
1046
    char stringdata0[124];
1047
};
1048
#define QT_MOC_LITERAL(idx, ofs, len) \
1049
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
1050
    qptrdiff(offsetof(qt_meta_stringdata_QCPLineEnding_t, stringdata0) + ofs \
1051
        - idx * sizeof(QByteArrayData)) \
1052
    )
1053
static const qt_meta_stringdata_QCPLineEnding_t qt_meta_stringdata_QCPLineEnding = {
1054
    {
1055
QT_MOC_LITERAL(0, 0, 13), // "QCPLineEnding"
1056
QT_MOC_LITERAL(1, 14, 11), // "EndingStyle"
1057
QT_MOC_LITERAL(2, 26, 6), // "esNone"
1058
QT_MOC_LITERAL(3, 33, 11), // "esFlatArrow"
1059
QT_MOC_LITERAL(4, 45, 12), // "esSpikeArrow"
1060
QT_MOC_LITERAL(5, 58, 11), // "esLineArrow"
1061
QT_MOC_LITERAL(6, 70, 6), // "esDisc"
1062
QT_MOC_LITERAL(7, 77, 8), // "esSquare"
1063
QT_MOC_LITERAL(8, 86, 9), // "esDiamond"
1064
QT_MOC_LITERAL(9, 96, 5), // "esBar"
1065
QT_MOC_LITERAL(10, 102, 9), // "esHalfBar"
1066
QT_MOC_LITERAL(11, 112, 11) // "esSkewedBar"
1067
1068
    },
1069
    "QCPLineEnding\0EndingStyle\0esNone\0"
1070
    "esFlatArrow\0esSpikeArrow\0esLineArrow\0"
1071
    "esDisc\0esSquare\0esDiamond\0esBar\0"
1072
    "esHalfBar\0esSkewedBar"
1073
};
1074
#undef QT_MOC_LITERAL
1075
1076
static const uint qt_meta_data_QCPLineEnding[] = {
1077
1078
 // content:
1079
       8,       // revision
1080
       0,       // classname
1081
       0,    0, // classinfo
1082
       0,    0, // methods
1083
       0,    0, // properties
1084
       1,   14, // enums/sets
1085
       0,    0, // constructors
1086
       4,       // flags
1087
       0,       // signalCount
1088
1089
 // enums: name, alias, flags, count, data
1090
       1,    1, 0x0,   10,   19,
1091
1092
 // enum data: key, value
1093
       2, uint(QCPLineEnding::esNone),
1094
       3, uint(QCPLineEnding::esFlatArrow),
1095
       4, uint(QCPLineEnding::esSpikeArrow),
1096
       5, uint(QCPLineEnding::esLineArrow),
1097
       6, uint(QCPLineEnding::esDisc),
1098
       7, uint(QCPLineEnding::esSquare),
1099
       8, uint(QCPLineEnding::esDiamond),
1100
       9, uint(QCPLineEnding::esBar),
1101
      10, uint(QCPLineEnding::esHalfBar),
1102
      11, uint(QCPLineEnding::esSkewedBar),
1103
1104
       0        // eod
1105
};
1106
1107
QT_INIT_METAOBJECT const QMetaObject QCPLineEnding::staticMetaObject = { {
1108
    nullptr,
1109
    qt_meta_stringdata_QCPLineEnding.data,
1110
    qt_meta_data_QCPLineEnding,
1111
    nullptr,
1112
    nullptr,
1113
    nullptr
1114
} };
1115
1116
struct qt_meta_stringdata_QCPGrid_t {
1117
    QByteArrayData data[7];
1118
    char stringdata0[89];
1119
};
1120
#define QT_MOC_LITERAL(idx, ofs, len) \
1121
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
1122
    qptrdiff(offsetof(qt_meta_stringdata_QCPGrid_t, stringdata0) + ofs \
1123
        - idx * sizeof(QByteArrayData)) \
1124
    )
1125
static const qt_meta_stringdata_QCPGrid_t qt_meta_stringdata_QCPGrid = {
1126
    {
1127
QT_MOC_LITERAL(0, 0, 7), // "QCPGrid"
1128
QT_MOC_LITERAL(1, 8, 14), // "subGridVisible"
1129
QT_MOC_LITERAL(2, 23, 18), // "antialiasedSubGrid"
1130
QT_MOC_LITERAL(3, 42, 19), // "antialiasedZeroLine"
1131
QT_MOC_LITERAL(4, 62, 3), // "pen"
1132
QT_MOC_LITERAL(5, 66, 10), // "subGridPen"
1133
QT_MOC_LITERAL(6, 77, 11) // "zeroLinePen"
1134
1135
    },
1136
    "QCPGrid\0subGridVisible\0antialiasedSubGrid\0"
1137
    "antialiasedZeroLine\0pen\0subGridPen\0"
1138
    "zeroLinePen"
1139
};
1140
#undef QT_MOC_LITERAL
1141
1142
static const uint qt_meta_data_QCPGrid[] = {
1143
1144
 // content:
1145
       8,       // revision
1146
       0,       // classname
1147
       0,    0, // classinfo
1148
       0,    0, // methods
1149
       6,   14, // properties
1150
       0,    0, // enums/sets
1151
       0,    0, // constructors
1152
       0,       // flags
1153
       0,       // signalCount
1154
1155
 // properties: name, type, flags
1156
       1, QMetaType::Bool, 0x00095103,
1157
       2, QMetaType::Bool, 0x00095103,
1158
       3, QMetaType::Bool, 0x00095103,
1159
       4, QMetaType::QPen, 0x00095103,
1160
       5, QMetaType::QPen, 0x00095103,
1161
       6, QMetaType::QPen, 0x00095103,
1162
1163
       0        // eod
1164
};
1165
1166
void QCPGrid::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
1167
{
1168
1169
#ifndef QT_NO_PROPERTIES
1170
    if (_c == QMetaObject::ReadProperty) {
1171
        auto *_t = static_cast<QCPGrid *>(_o);
1172
        Q_UNUSED(_t)
1173
        void *_v = _a[0];
1174
        switch (_id) {
1175
        case 0: *reinterpret_cast< bool*>(_v) = _t->subGridVisible(); break;
1176
        case 1: *reinterpret_cast< bool*>(_v) = _t->antialiasedSubGrid(); break;
1177
        case 2: *reinterpret_cast< bool*>(_v) = _t->antialiasedZeroLine(); break;
1178
        case 3: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
1179
        case 4: *reinterpret_cast< QPen*>(_v) = _t->subGridPen(); break;
1180
        case 5: *reinterpret_cast< QPen*>(_v) = _t->zeroLinePen(); break;
1181
        default: break;
1182
        }
1183
    } else if (_c == QMetaObject::WriteProperty) {
1184
        auto *_t = static_cast<QCPGrid *>(_o);
1185
        Q_UNUSED(_t)
1186
        void *_v = _a[0];
1187
        switch (_id) {
1188
        case 0: _t->setSubGridVisible(*reinterpret_cast< bool*>(_v)); break;
1189
        case 1: _t->setAntialiasedSubGrid(*reinterpret_cast< bool*>(_v)); break;
1190
        case 2: _t->setAntialiasedZeroLine(*reinterpret_cast< bool*>(_v)); break;
1191
        case 3: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
1192
        case 4: _t->setSubGridPen(*reinterpret_cast< QPen*>(_v)); break;
1193
        case 5: _t->setZeroLinePen(*reinterpret_cast< QPen*>(_v)); break;
1194
        default: break;
1195
        }
1196
    } else if (_c == QMetaObject::ResetProperty) {
1197
    }
1198
#endif // QT_NO_PROPERTIES
1199
    Q_UNUSED(_o);
1200
    Q_UNUSED(_id);
1201
    Q_UNUSED(_c);
1202
    Q_UNUSED(_a);
1203
}
1204
1205
QT_INIT_METAOBJECT const QMetaObject QCPGrid::staticMetaObject = { {
1206
    &QCPLayerable::staticMetaObject,
1207
    qt_meta_stringdata_QCPGrid.data,
1208
    qt_meta_data_QCPGrid,
1209
    qt_static_metacall,
1210
    nullptr,
1211
    nullptr
1212
} };
1213
1214
1215
const QMetaObject *QCPGrid::metaObject() const
1216
{
1217
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
1218
}
1219
1220
void *QCPGrid::qt_metacast(const char *_clname)
1221
{
1222
    if (!_clname) return nullptr;
1223
    if (!strcmp(_clname, qt_meta_stringdata_QCPGrid.stringdata0))
1224
        return static_cast<void*>(this);
1225
    return QCPLayerable::qt_metacast(_clname);
1226
}
1227
1228
int QCPGrid::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
1229
{
1230
    _id = QCPLayerable::qt_metacall(_c, _id, _a);
1231
    if (_id < 0)
1232
        return _id;
1233
1234
#ifndef QT_NO_PROPERTIES
1235
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
1236
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
1237
        qt_static_metacall(this, _c, _id, _a);
1238
        _id -= 6;
1239
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
1240
        _id -= 6;
1241
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
1242
        _id -= 6;
1243
    } else if (_c == QMetaObject::QueryPropertyStored) {
1244
        _id -= 6;
1245
    } else if (_c == QMetaObject::QueryPropertyEditable) {
1246
        _id -= 6;
1247
    } else if (_c == QMetaObject::QueryPropertyUser) {
1248
        _id -= 6;
1249
    }
1250
#endif // QT_NO_PROPERTIES
1251
    return _id;
1252
}
1253
struct qt_meta_stringdata_QCPAxis_t {
1254
    QByteArrayData data[97];
1255
    char stringdata0[1196];
1256
};
1257
#define QT_MOC_LITERAL(idx, ofs, len) \
1258
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
1259
    qptrdiff(offsetof(qt_meta_stringdata_QCPAxis_t, stringdata0) + ofs \
1260
        - idx * sizeof(QByteArrayData)) \
1261
    )
1262
static const qt_meta_stringdata_QCPAxis_t qt_meta_stringdata_QCPAxis = {
1263
    {
1264
QT_MOC_LITERAL(0, 0, 7), // "QCPAxis"
1265
QT_MOC_LITERAL(1, 8, 12), // "ticksRequest"
1266
QT_MOC_LITERAL(2, 21, 0), // ""
1267
QT_MOC_LITERAL(3, 22, 12), // "rangeChanged"
1268
QT_MOC_LITERAL(4, 35, 8), // "QCPRange"
1269
QT_MOC_LITERAL(5, 44, 8), // "newRange"
1270
QT_MOC_LITERAL(6, 53, 8), // "oldRange"
1271
QT_MOC_LITERAL(7, 62, 16), // "scaleTypeChanged"
1272
QT_MOC_LITERAL(8, 79, 18), // "QCPAxis::ScaleType"
1273
QT_MOC_LITERAL(9, 98, 9), // "scaleType"
1274
QT_MOC_LITERAL(10, 108, 16), // "selectionChanged"
1275
QT_MOC_LITERAL(11, 125, 24), // "QCPAxis::SelectableParts"
1276
QT_MOC_LITERAL(12, 150, 5), // "parts"
1277
QT_MOC_LITERAL(13, 156, 17), // "selectableChanged"
1278
QT_MOC_LITERAL(14, 174, 12), // "setScaleType"
1279
QT_MOC_LITERAL(15, 187, 4), // "type"
1280
QT_MOC_LITERAL(16, 192, 8), // "setRange"
1281
QT_MOC_LITERAL(17, 201, 5), // "range"
1282
QT_MOC_LITERAL(18, 207, 18), // "setSelectableParts"
1283
QT_MOC_LITERAL(19, 226, 15), // "selectableParts"
1284
QT_MOC_LITERAL(20, 242, 16), // "setSelectedParts"
1285
QT_MOC_LITERAL(21, 259, 13), // "selectedParts"
1286
QT_MOC_LITERAL(22, 273, 8), // "axisType"
1287
QT_MOC_LITERAL(23, 282, 8), // "AxisType"
1288
QT_MOC_LITERAL(24, 291, 8), // "axisRect"
1289
QT_MOC_LITERAL(25, 300, 12), // "QCPAxisRect*"
1290
QT_MOC_LITERAL(26, 313, 9), // "ScaleType"
1291
QT_MOC_LITERAL(27, 323, 12), // "scaleLogBase"
1292
QT_MOC_LITERAL(28, 336, 13), // "rangeReversed"
1293
QT_MOC_LITERAL(29, 350, 9), // "autoTicks"
1294
QT_MOC_LITERAL(30, 360, 13), // "autoTickCount"
1295
QT_MOC_LITERAL(31, 374, 14), // "autoTickLabels"
1296
QT_MOC_LITERAL(32, 389, 12), // "autoTickStep"
1297
QT_MOC_LITERAL(33, 402, 12), // "autoSubTicks"
1298
QT_MOC_LITERAL(34, 415, 5), // "ticks"
1299
QT_MOC_LITERAL(35, 421, 10), // "tickLabels"
1300
QT_MOC_LITERAL(36, 432, 16), // "tickLabelPadding"
1301
QT_MOC_LITERAL(37, 449, 13), // "tickLabelType"
1302
QT_MOC_LITERAL(38, 463, 9), // "LabelType"
1303
QT_MOC_LITERAL(39, 473, 13), // "tickLabelFont"
1304
QT_MOC_LITERAL(40, 487, 14), // "tickLabelColor"
1305
QT_MOC_LITERAL(41, 502, 17), // "tickLabelRotation"
1306
QT_MOC_LITERAL(42, 520, 13), // "tickLabelSide"
1307
QT_MOC_LITERAL(43, 534, 9), // "LabelSide"
1308
QT_MOC_LITERAL(44, 544, 14), // "dateTimeFormat"
1309
QT_MOC_LITERAL(45, 559, 12), // "dateTimeSpec"
1310
QT_MOC_LITERAL(46, 572, 12), // "Qt::TimeSpec"
1311
QT_MOC_LITERAL(47, 585, 12), // "numberFormat"
1312
QT_MOC_LITERAL(48, 598, 15), // "numberPrecision"
1313
QT_MOC_LITERAL(49, 614, 8), // "tickStep"
1314
QT_MOC_LITERAL(50, 623, 10), // "tickVector"
1315
QT_MOC_LITERAL(51, 634, 15), // "QVector<double>"
1316
QT_MOC_LITERAL(52, 650, 16), // "tickVectorLabels"
1317
QT_MOC_LITERAL(53, 667, 16), // "QVector<QString>"
1318
QT_MOC_LITERAL(54, 684, 12), // "tickLengthIn"
1319
QT_MOC_LITERAL(55, 697, 13), // "tickLengthOut"
1320
QT_MOC_LITERAL(56, 711, 12), // "subTickCount"
1321
QT_MOC_LITERAL(57, 724, 15), // "subTickLengthIn"
1322
QT_MOC_LITERAL(58, 740, 16), // "subTickLengthOut"
1323
QT_MOC_LITERAL(59, 757, 7), // "basePen"
1324
QT_MOC_LITERAL(60, 765, 7), // "tickPen"
1325
QT_MOC_LITERAL(61, 773, 10), // "subTickPen"
1326
QT_MOC_LITERAL(62, 784, 9), // "labelFont"
1327
QT_MOC_LITERAL(63, 794, 10), // "labelColor"
1328
QT_MOC_LITERAL(64, 805, 5), // "label"
1329
QT_MOC_LITERAL(65, 811, 12), // "labelPadding"
1330
QT_MOC_LITERAL(66, 824, 7), // "padding"
1331
QT_MOC_LITERAL(67, 832, 6), // "offset"
1332
QT_MOC_LITERAL(68, 839, 15), // "SelectableParts"
1333
QT_MOC_LITERAL(69, 855, 21), // "selectedTickLabelFont"
1334
QT_MOC_LITERAL(70, 877, 17), // "selectedLabelFont"
1335
QT_MOC_LITERAL(71, 895, 22), // "selectedTickLabelColor"
1336
QT_MOC_LITERAL(72, 918, 18), // "selectedLabelColor"
1337
QT_MOC_LITERAL(73, 937, 15), // "selectedBasePen"
1338
QT_MOC_LITERAL(74, 953, 15), // "selectedTickPen"
1339
QT_MOC_LITERAL(75, 969, 18), // "selectedSubTickPen"
1340
QT_MOC_LITERAL(76, 988, 11), // "lowerEnding"
1341
QT_MOC_LITERAL(77, 1000, 13), // "QCPLineEnding"
1342
QT_MOC_LITERAL(78, 1014, 11), // "upperEnding"
1343
QT_MOC_LITERAL(79, 1026, 4), // "grid"
1344
QT_MOC_LITERAL(80, 1031, 8), // "QCPGrid*"
1345
QT_MOC_LITERAL(81, 1040, 6), // "atLeft"
1346
QT_MOC_LITERAL(82, 1047, 7), // "atRight"
1347
QT_MOC_LITERAL(83, 1055, 5), // "atTop"
1348
QT_MOC_LITERAL(84, 1061, 8), // "atBottom"
1349
QT_MOC_LITERAL(85, 1070, 9), // "AxisTypes"
1350
QT_MOC_LITERAL(86, 1080, 8), // "ltNumber"
1351
QT_MOC_LITERAL(87, 1089, 10), // "ltDateTime"
1352
QT_MOC_LITERAL(88, 1100, 8), // "lsInside"
1353
QT_MOC_LITERAL(89, 1109, 9), // "lsOutside"
1354
QT_MOC_LITERAL(90, 1119, 8), // "stLinear"
1355
QT_MOC_LITERAL(91, 1128, 13), // "stLogarithmic"
1356
QT_MOC_LITERAL(92, 1142, 14), // "SelectablePart"
1357
QT_MOC_LITERAL(93, 1157, 6), // "spNone"
1358
QT_MOC_LITERAL(94, 1164, 6), // "spAxis"
1359
QT_MOC_LITERAL(95, 1171, 12), // "spTickLabels"
1360
QT_MOC_LITERAL(96, 1184, 11) // "spAxisLabel"
1361
1362
    },
1363
    "QCPAxis\0ticksRequest\0\0rangeChanged\0"
1364
    "QCPRange\0newRange\0oldRange\0scaleTypeChanged\0"
1365
    "QCPAxis::ScaleType\0scaleType\0"
1366
    "selectionChanged\0QCPAxis::SelectableParts\0"
1367
    "parts\0selectableChanged\0setScaleType\0"
1368
    "type\0setRange\0range\0setSelectableParts\0"
1369
    "selectableParts\0setSelectedParts\0"
1370
    "selectedParts\0axisType\0AxisType\0"
1371
    "axisRect\0QCPAxisRect*\0ScaleType\0"
1372
    "scaleLogBase\0rangeReversed\0autoTicks\0"
1373
    "autoTickCount\0autoTickLabels\0autoTickStep\0"
1374
    "autoSubTicks\0ticks\0tickLabels\0"
1375
    "tickLabelPadding\0tickLabelType\0LabelType\0"
1376
    "tickLabelFont\0tickLabelColor\0"
1377
    "tickLabelRotation\0tickLabelSide\0"
1378
    "LabelSide\0dateTimeFormat\0dateTimeSpec\0"
1379
    "Qt::TimeSpec\0numberFormat\0numberPrecision\0"
1380
    "tickStep\0tickVector\0QVector<double>\0"
1381
    "tickVectorLabels\0QVector<QString>\0"
1382
    "tickLengthIn\0tickLengthOut\0subTickCount\0"
1383
    "subTickLengthIn\0subTickLengthOut\0"
1384
    "basePen\0tickPen\0subTickPen\0labelFont\0"
1385
    "labelColor\0label\0labelPadding\0padding\0"
1386
    "offset\0SelectableParts\0selectedTickLabelFont\0"
1387
    "selectedLabelFont\0selectedTickLabelColor\0"
1388
    "selectedLabelColor\0selectedBasePen\0"
1389
    "selectedTickPen\0selectedSubTickPen\0"
1390
    "lowerEnding\0QCPLineEnding\0upperEnding\0"
1391
    "grid\0QCPGrid*\0atLeft\0atRight\0atTop\0"
1392
    "atBottom\0AxisTypes\0ltNumber\0ltDateTime\0"
1393
    "lsInside\0lsOutside\0stLinear\0stLogarithmic\0"
1394
    "SelectablePart\0spNone\0spAxis\0spTickLabels\0"
1395
    "spAxisLabel"
1396
};
1397
#undef QT_MOC_LITERAL
1398
1399
static const uint qt_meta_data_QCPAxis[] = {
1400
1401
 // content:
1402
       8,       // revision
1403
       0,       // classname
1404
       0,    0, // classinfo
1405
      10,   14, // methods
1406
      52,   94, // properties
1407
       7,  302, // enums/sets
1408
       0,    0, // constructors
1409
       0,       // flags
1410
       6,       // signalCount
1411
1412
 // signals: name, argc, parameters, tag, flags
1413
       1,    0,   64,    2, 0x06 /* Public */,
1414
       3,    1,   65,    2, 0x06 /* Public */,
1415
       3,    2,   68,    2, 0x06 /* Public */,
1416
       7,    1,   73,    2, 0x06 /* Public */,
1417
      10,    1,   76,    2, 0x06 /* Public */,
1418
      13,    1,   79,    2, 0x06 /* Public */,
1419
1420
 // slots: name, argc, parameters, tag, flags
1421
      14,    1,   82,    2, 0x0a /* Public */,
1422
      16,    1,   85,    2, 0x0a /* Public */,
1423
      18,    1,   88,    2, 0x0a /* Public */,
1424
      20,    1,   91,    2, 0x0a /* Public */,
1425
1426
 // signals: parameters
1427
    QMetaType::Void,
1428
    QMetaType::Void, 0x80000000 | 4,    5,
1429
    QMetaType::Void, 0x80000000 | 4, 0x80000000 | 4,    5,    6,
1430
    QMetaType::Void, 0x80000000 | 8,    9,
1431
    QMetaType::Void, 0x80000000 | 11,   12,
1432
    QMetaType::Void, 0x80000000 | 11,   12,
1433
1434
 // slots: parameters
1435
    QMetaType::Void, 0x80000000 | 8,   15,
1436
    QMetaType::Void, 0x80000000 | 4,   17,
1437
    QMetaType::Void, 0x80000000 | 11,   19,
1438
    QMetaType::Void, 0x80000000 | 11,   21,
1439
1440
 // properties: name, type, flags
1441
      22, 0x80000000 | 23, 0x00095009,
1442
      24, 0x80000000 | 25, 0x00095009,
1443
       9, 0x80000000 | 26, 0x0049510b,
1444
      27, QMetaType::Double, 0x00095103,
1445
      17, 0x80000000 | 4, 0x0049510b,
1446
      28, QMetaType::Bool, 0x00095103,
1447
      29, QMetaType::Bool, 0x00095103,
1448
      30, QMetaType::Int, 0x00095103,
1449
      31, QMetaType::Bool, 0x00095103,
1450
      32, QMetaType::Bool, 0x00095103,
1451
      33, QMetaType::Bool, 0x00095103,
1452
      34, QMetaType::Bool, 0x00095103,
1453
      35, QMetaType::Bool, 0x00095103,
1454
      36, QMetaType::Int, 0x00095103,
1455
      37, 0x80000000 | 38, 0x0009510b,
1456
      39, QMetaType::QFont, 0x00095103,
1457
      40, QMetaType::QColor, 0x00095103,
1458
      41, QMetaType::Double, 0x00095103,
1459
      42, 0x80000000 | 43, 0x0009510b,
1460
      44, QMetaType::QString, 0x00095103,
1461
      45, 0x80000000 | 46, 0x0009510b,
1462
      47, QMetaType::QString, 0x00095103,
1463
      48, QMetaType::Int, 0x00095103,
1464
      49, QMetaType::Double, 0x00095103,
1465
      50, 0x80000000 | 51, 0x0009510b,
1466
      52, 0x80000000 | 53, 0x0009510b,
1467
      54, QMetaType::Int, 0x00095103,
1468
      55, QMetaType::Int, 0x00095103,
1469
      56, QMetaType::Int, 0x00095103,
1470
      57, QMetaType::Int, 0x00095103,
1471
      58, QMetaType::Int, 0x00095103,
1472
      59, QMetaType::QPen, 0x00095103,
1473
      60, QMetaType::QPen, 0x00095103,
1474
      61, QMetaType::QPen, 0x00095103,
1475
      62, QMetaType::QFont, 0x00095103,
1476
      63, QMetaType::QColor, 0x00095103,
1477
      64, QMetaType::QString, 0x00095103,
1478
      65, QMetaType::Int, 0x00095103,
1479
      66, QMetaType::Int, 0x00095103,
1480
      67, QMetaType::Int, 0x00095103,
1481
      21, 0x80000000 | 68, 0x0049510b,
1482
      19, 0x80000000 | 68, 0x0049510b,
1483
      69, QMetaType::QFont, 0x00095103,
1484
      70, QMetaType::QFont, 0x00095103,
1485
      71, QMetaType::QColor, 0x00095103,
1486
      72, QMetaType::QColor, 0x00095103,
1487
      73, QMetaType::QPen, 0x00095103,
1488
      74, QMetaType::QPen, 0x00095103,
1489
      75, QMetaType::QPen, 0x00095103,
1490
      76, 0x80000000 | 77, 0x0009510b,
1491
      78, 0x80000000 | 77, 0x0009510b,
1492
      79, 0x80000000 | 80, 0x00095009,
1493
1494
 // properties: notify_signal_id
1495
       0,
1496
       0,
1497
       3,
1498
       0,
1499
       1,
1500
       0,
1501
       0,
1502
       0,
1503
       0,
1504
       0,
1505
       0,
1506
       0,
1507
       0,
1508
       0,
1509
       0,
1510
       0,
1511
       0,
1512
       0,
1513
       0,
1514
       0,
1515
       0,
1516
       0,
1517
       0,
1518
       0,
1519
       0,
1520
       0,
1521
       0,
1522
       0,
1523
       0,
1524
       0,
1525
       0,
1526
       0,
1527
       0,
1528
       0,
1529
       0,
1530
       0,
1531
       0,
1532
       0,
1533
       0,
1534
       0,
1535
       4,
1536
       5,
1537
       0,
1538
       0,
1539
       0,
1540
       0,
1541
       0,
1542
       0,
1543
       0,
1544
       0,
1545
       0,
1546
       0,
1547
1548
 // enums: name, alias, flags, count, data
1549
      23,   23, 0x1,    4,  337,
1550
      85,   23, 0x1,    4,  345,
1551
      38,   38, 0x0,    2,  353,
1552
      43,   43, 0x0,    2,  357,
1553
      26,   26, 0x0,    2,  361,
1554
      92,   92, 0x1,    4,  365,
1555
      68,   92, 0x1,    4,  373,
1556
1557
 // enum data: key, value
1558
      81, uint(QCPAxis::atLeft),
1559
      82, uint(QCPAxis::atRight),
1560
      83, uint(QCPAxis::atTop),
1561
      84, uint(QCPAxis::atBottom),
1562
      81, uint(QCPAxis::atLeft),
1563
      82, uint(QCPAxis::atRight),
1564
      83, uint(QCPAxis::atTop),
1565
      84, uint(QCPAxis::atBottom),
1566
      86, uint(QCPAxis::ltNumber),
1567
      87, uint(QCPAxis::ltDateTime),
1568
      88, uint(QCPAxis::lsInside),
1569
      89, uint(QCPAxis::lsOutside),
1570
      90, uint(QCPAxis::stLinear),
1571
      91, uint(QCPAxis::stLogarithmic),
1572
      93, uint(QCPAxis::spNone),
1573
      94, uint(QCPAxis::spAxis),
1574
      95, uint(QCPAxis::spTickLabels),
1575
      96, uint(QCPAxis::spAxisLabel),
1576
      93, uint(QCPAxis::spNone),
1577
      94, uint(QCPAxis::spAxis),
1578
      95, uint(QCPAxis::spTickLabels),
1579
      96, uint(QCPAxis::spAxisLabel),
1580
1581
       0        // eod
1582
};
1583
1584
void QCPAxis::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
1585
{
1586
    if (_c == QMetaObject::InvokeMetaMethod) {
1587
        auto *_t = static_cast<QCPAxis *>(_o);
1588
        Q_UNUSED(_t)
1589
        switch (_id) {
1590
        case 0: _t->ticksRequest(); break;
1591
        case 1: _t->rangeChanged((*reinterpret_cast< const QCPRange(*)>(_a[1]))); break;
1592
        case 2: _t->rangeChanged((*reinterpret_cast< const QCPRange(*)>(_a[1])),(*reinterpret_cast< const QCPRange(*)>(_a[2]))); break;
1593
        case 3: _t->scaleTypeChanged((*reinterpret_cast< QCPAxis::ScaleType(*)>(_a[1]))); break;
1594
        case 4: _t->selectionChanged((*reinterpret_cast< const QCPAxis::SelectableParts(*)>(_a[1]))); break;
1595
        case 5: _t->selectableChanged((*reinterpret_cast< const QCPAxis::SelectableParts(*)>(_a[1]))); break;
1596
        case 6: _t->setScaleType((*reinterpret_cast< QCPAxis::ScaleType(*)>(_a[1]))); break;
1597
        case 7: _t->setRange((*reinterpret_cast< const QCPRange(*)>(_a[1]))); break;
1598
        case 8: _t->setSelectableParts((*reinterpret_cast< const QCPAxis::SelectableParts(*)>(_a[1]))); break;
1599
        case 9: _t->setSelectedParts((*reinterpret_cast< const QCPAxis::SelectableParts(*)>(_a[1]))); break;
1600
        default: ;
1601
        }
1602
    } else if (_c == QMetaObject::IndexOfMethod) {
1603
        int *result = reinterpret_cast<int *>(_a[0]);
1604
        {
1605
            using _t = void (QCPAxis::*)();
1606
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAxis::ticksRequest)) {
1607
                *result = 0;
1608
                return;
1609
            }
1610
        }
1611
        {
1612
            using _t = void (QCPAxis::*)(const QCPRange & );
1613
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAxis::rangeChanged)) {
1614
                *result = 1;
1615
                return;
1616
            }
1617
        }
1618
        {
1619
            using _t = void (QCPAxis::*)(const QCPRange & , const QCPRange & );
1620
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAxis::rangeChanged)) {
1621
                *result = 2;
1622
                return;
1623
            }
1624
        }
1625
        {
1626
            using _t = void (QCPAxis::*)(QCPAxis::ScaleType );
1627
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAxis::scaleTypeChanged)) {
1628
                *result = 3;
1629
                return;
1630
            }
1631
        }
1632
        {
1633
            using _t = void (QCPAxis::*)(const QCPAxis::SelectableParts & );
1634
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAxis::selectionChanged)) {
1635
                *result = 4;
1636
                return;
1637
            }
1638
        }
1639
        {
1640
            using _t = void (QCPAxis::*)(const QCPAxis::SelectableParts & );
1641
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAxis::selectableChanged)) {
1642
                *result = 5;
1643
                return;
1644
            }
1645
        }
1646
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
1647
        switch (_id) {
1648
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
1649
        case 1:
1650
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxisRect* >(); break;
1651
        case 51:
1652
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPGrid* >(); break;
1653
        case 25:
1654
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QVector<QString> >(); break;
1655
        case 24:
1656
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QVector<double> >(); break;
1657
        }
1658
    }
1659
1660
#ifndef QT_NO_PROPERTIES
1661
    else if (_c == QMetaObject::ReadProperty) {
1662
        auto *_t = static_cast<QCPAxis *>(_o);
1663
        Q_UNUSED(_t)
1664
        void *_v = _a[0];
1665
        switch (_id) {
1666
        case 0: *reinterpret_cast<int*>(_v) = QFlag(_t->axisType()); break;
1667
        case 1: *reinterpret_cast< QCPAxisRect**>(_v) = _t->axisRect(); break;
1668
        case 2: *reinterpret_cast< ScaleType*>(_v) = _t->scaleType(); break;
1669
        case 3: *reinterpret_cast< double*>(_v) = _t->scaleLogBase(); break;
1670
        case 4: *reinterpret_cast< QCPRange*>(_v) = _t->range(); break;
1671
        case 5: *reinterpret_cast< bool*>(_v) = _t->rangeReversed(); break;
1672
        case 6: *reinterpret_cast< bool*>(_v) = _t->autoTicks(); break;
1673
        case 7: *reinterpret_cast< int*>(_v) = _t->autoTickCount(); break;
1674
        case 8: *reinterpret_cast< bool*>(_v) = _t->autoTickLabels(); break;
1675
        case 9: *reinterpret_cast< bool*>(_v) = _t->autoTickStep(); break;
1676
        case 10: *reinterpret_cast< bool*>(_v) = _t->autoSubTicks(); break;
1677
        case 11: *reinterpret_cast< bool*>(_v) = _t->ticks(); break;
1678
        case 12: *reinterpret_cast< bool*>(_v) = _t->tickLabels(); break;
1679
        case 13: *reinterpret_cast< int*>(_v) = _t->tickLabelPadding(); break;
1680
        case 14: *reinterpret_cast< LabelType*>(_v) = _t->tickLabelType(); break;
1681
        case 15: *reinterpret_cast< QFont*>(_v) = _t->tickLabelFont(); break;
1682
        case 16: *reinterpret_cast< QColor*>(_v) = _t->tickLabelColor(); break;
1683
        case 17: *reinterpret_cast< double*>(_v) = _t->tickLabelRotation(); break;
1684
        case 18: *reinterpret_cast< LabelSide*>(_v) = _t->tickLabelSide(); break;
1685
        case 19: *reinterpret_cast< QString*>(_v) = _t->dateTimeFormat(); break;
1686
        case 20: *reinterpret_cast< Qt::TimeSpec*>(_v) = _t->dateTimeSpec(); break;
1687
        case 21: *reinterpret_cast< QString*>(_v) = _t->numberFormat(); break;
1688
        case 22: *reinterpret_cast< int*>(_v) = _t->numberPrecision(); break;
1689
        case 23: *reinterpret_cast< double*>(_v) = _t->tickStep(); break;
1690
        case 24: *reinterpret_cast< QVector<double>*>(_v) = _t->tickVector(); break;
1691
        case 25: *reinterpret_cast< QVector<QString>*>(_v) = _t->tickVectorLabels(); break;
1692
        case 26: *reinterpret_cast< int*>(_v) = _t->tickLengthIn(); break;
1693
        case 27: *reinterpret_cast< int*>(_v) = _t->tickLengthOut(); break;
1694
        case 28: *reinterpret_cast< int*>(_v) = _t->subTickCount(); break;
1695
        case 29: *reinterpret_cast< int*>(_v) = _t->subTickLengthIn(); break;
1696
        case 30: *reinterpret_cast< int*>(_v) = _t->subTickLengthOut(); break;
1697
        case 31: *reinterpret_cast< QPen*>(_v) = _t->basePen(); break;
1698
        case 32: *reinterpret_cast< QPen*>(_v) = _t->tickPen(); break;
1699
        case 33: *reinterpret_cast< QPen*>(_v) = _t->subTickPen(); break;
1700
        case 34: *reinterpret_cast< QFont*>(_v) = _t->labelFont(); break;
1701
        case 35: *reinterpret_cast< QColor*>(_v) = _t->labelColor(); break;
1702
        case 36: *reinterpret_cast< QString*>(_v) = _t->label(); break;
1703
        case 37: *reinterpret_cast< int*>(_v) = _t->labelPadding(); break;
1704
        case 38: *reinterpret_cast< int*>(_v) = _t->padding(); break;
1705
        case 39: *reinterpret_cast< int*>(_v) = _t->offset(); break;
1706
        case 40: *reinterpret_cast<int*>(_v) = QFlag(_t->selectedParts()); break;
1707
        case 41: *reinterpret_cast<int*>(_v) = QFlag(_t->selectableParts()); break;
1708
        case 42: *reinterpret_cast< QFont*>(_v) = _t->selectedTickLabelFont(); break;
1709
        case 43: *reinterpret_cast< QFont*>(_v) = _t->selectedLabelFont(); break;
1710
        case 44: *reinterpret_cast< QColor*>(_v) = _t->selectedTickLabelColor(); break;
1711
        case 45: *reinterpret_cast< QColor*>(_v) = _t->selectedLabelColor(); break;
1712
        case 46: *reinterpret_cast< QPen*>(_v) = _t->selectedBasePen(); break;
1713
        case 47: *reinterpret_cast< QPen*>(_v) = _t->selectedTickPen(); break;
1714
        case 48: *reinterpret_cast< QPen*>(_v) = _t->selectedSubTickPen(); break;
1715
        case 49: *reinterpret_cast< QCPLineEnding*>(_v) = _t->lowerEnding(); break;
1716
        case 50: *reinterpret_cast< QCPLineEnding*>(_v) = _t->upperEnding(); break;
1717
        case 51: *reinterpret_cast< QCPGrid**>(_v) = _t->grid(); break;
1718
        default: break;
1719
        }
1720
    } else if (_c == QMetaObject::WriteProperty) {
1721
        auto *_t = static_cast<QCPAxis *>(_o);
1722
        Q_UNUSED(_t)
1723
        void *_v = _a[0];
1724
        switch (_id) {
1725
        case 2: _t->setScaleType(*reinterpret_cast< ScaleType*>(_v)); break;
1726
        case 3: _t->setScaleLogBase(*reinterpret_cast< double*>(_v)); break;
1727
        case 4: _t->setRange(*reinterpret_cast< QCPRange*>(_v)); break;
1728
        case 5: _t->setRangeReversed(*reinterpret_cast< bool*>(_v)); break;
1729
        case 6: _t->setAutoTicks(*reinterpret_cast< bool*>(_v)); break;
1730
        case 7: _t->setAutoTickCount(*reinterpret_cast< int*>(_v)); break;
1731
        case 8: _t->setAutoTickLabels(*reinterpret_cast< bool*>(_v)); break;
1732
        case 9: _t->setAutoTickStep(*reinterpret_cast< bool*>(_v)); break;
1733
        case 10: _t->setAutoSubTicks(*reinterpret_cast< bool*>(_v)); break;
1734
        case 11: _t->setTicks(*reinterpret_cast< bool*>(_v)); break;
1735
        case 12: _t->setTickLabels(*reinterpret_cast< bool*>(_v)); break;
1736
        case 13: _t->setTickLabelPadding(*reinterpret_cast< int*>(_v)); break;
1737
        case 14: _t->setTickLabelType(*reinterpret_cast< LabelType*>(_v)); break;
1738
        case 15: _t->setTickLabelFont(*reinterpret_cast< QFont*>(_v)); break;
1739
        case 16: _t->setTickLabelColor(*reinterpret_cast< QColor*>(_v)); break;
1740
        case 17: _t->setTickLabelRotation(*reinterpret_cast< double*>(_v)); break;
1741
        case 18: _t->setTickLabelSide(*reinterpret_cast< LabelSide*>(_v)); break;
1742
        case 19: _t->setDateTimeFormat(*reinterpret_cast< QString*>(_v)); break;
1743
        case 20: _t->setDateTimeSpec(*reinterpret_cast< Qt::TimeSpec*>(_v)); break;
1744
        case 21: _t->setNumberFormat(*reinterpret_cast< QString*>(_v)); break;
1745
        case 22: _t->setNumberPrecision(*reinterpret_cast< int*>(_v)); break;
1746
        case 23: _t->setTickStep(*reinterpret_cast< double*>(_v)); break;
1747
        case 24: _t->setTickVector(*reinterpret_cast< QVector<double>*>(_v)); break;
1748
        case 25: _t->setTickVectorLabels(*reinterpret_cast< QVector<QString>*>(_v)); break;
1749
        case 26: _t->setTickLengthIn(*reinterpret_cast< int*>(_v)); break;
1750
        case 27: _t->setTickLengthOut(*reinterpret_cast< int*>(_v)); break;
1751
        case 28: _t->setSubTickCount(*reinterpret_cast< int*>(_v)); break;
1752
        case 29: _t->setSubTickLengthIn(*reinterpret_cast< int*>(_v)); break;
1753
        case 30: _t->setSubTickLengthOut(*reinterpret_cast< int*>(_v)); break;
1754
        case 31: _t->setBasePen(*reinterpret_cast< QPen*>(_v)); break;
1755
        case 32: _t->setTickPen(*reinterpret_cast< QPen*>(_v)); break;
1756
        case 33: _t->setSubTickPen(*reinterpret_cast< QPen*>(_v)); break;
1757
        case 34: _t->setLabelFont(*reinterpret_cast< QFont*>(_v)); break;
1758
        case 35: _t->setLabelColor(*reinterpret_cast< QColor*>(_v)); break;
1759
        case 36: _t->setLabel(*reinterpret_cast< QString*>(_v)); break;
1760
        case 37: _t->setLabelPadding(*reinterpret_cast< int*>(_v)); break;
1761
        case 38: _t->setPadding(*reinterpret_cast< int*>(_v)); break;
1762
        case 39: _t->setOffset(*reinterpret_cast< int*>(_v)); break;
1763
        case 40: _t->setSelectedParts(QFlag(*reinterpret_cast<int*>(_v))); break;
1764
        case 41: _t->setSelectableParts(QFlag(*reinterpret_cast<int*>(_v))); break;
1765
        case 42: _t->setSelectedTickLabelFont(*reinterpret_cast< QFont*>(_v)); break;
1766
        case 43: _t->setSelectedLabelFont(*reinterpret_cast< QFont*>(_v)); break;
1767
        case 44: _t->setSelectedTickLabelColor(*reinterpret_cast< QColor*>(_v)); break;
1768
        case 45: _t->setSelectedLabelColor(*reinterpret_cast< QColor*>(_v)); break;
1769
        case 46: _t->setSelectedBasePen(*reinterpret_cast< QPen*>(_v)); break;
1770
        case 47: _t->setSelectedTickPen(*reinterpret_cast< QPen*>(_v)); break;
1771
        case 48: _t->setSelectedSubTickPen(*reinterpret_cast< QPen*>(_v)); break;
1772
        case 49: _t->setLowerEnding(*reinterpret_cast< QCPLineEnding*>(_v)); break;
1773
        case 50: _t->setUpperEnding(*reinterpret_cast< QCPLineEnding*>(_v)); break;
1774
        default: break;
1775
        }
1776
    } else if (_c == QMetaObject::ResetProperty) {
1777
    }
1778
#endif // QT_NO_PROPERTIES
1779
}
1780
1781
QT_INIT_METAOBJECT const QMetaObject QCPAxis::staticMetaObject = { {
1782
    &QCPLayerable::staticMetaObject,
1783
    qt_meta_stringdata_QCPAxis.data,
1784
    qt_meta_data_QCPAxis,
1785
    qt_static_metacall,
1786
    nullptr,
1787
    nullptr
1788
} };
1789
1790
1791
const QMetaObject *QCPAxis::metaObject() const
1792
{
1793
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
1794
}
1795
1796
void *QCPAxis::qt_metacast(const char *_clname)
1797
{
1798
    if (!_clname) return nullptr;
1799
    if (!strcmp(_clname, qt_meta_stringdata_QCPAxis.stringdata0))
1800
        return static_cast<void*>(this);
1801
    return QCPLayerable::qt_metacast(_clname);
1802
}
1803
1804
int QCPAxis::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
1805
{
1806
    _id = QCPLayerable::qt_metacall(_c, _id, _a);
1807
    if (_id < 0)
1808
        return _id;
1809
    if (_c == QMetaObject::InvokeMetaMethod) {
1810
        if (_id < 10)
1811
            qt_static_metacall(this, _c, _id, _a);
1812
        _id -= 10;
1813
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
1814
        if (_id < 10)
1815
            *reinterpret_cast<int*>(_a[0]) = -1;
1816
        _id -= 10;
1817
    }
1818
#ifndef QT_NO_PROPERTIES
1819
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
1820
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
1821
        qt_static_metacall(this, _c, _id, _a);
1822
        _id -= 52;
1823
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
1824
        _id -= 52;
1825
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
1826
        _id -= 52;
1827
    } else if (_c == QMetaObject::QueryPropertyStored) {
1828
        _id -= 52;
1829
    } else if (_c == QMetaObject::QueryPropertyEditable) {
1830
        _id -= 52;
1831
    } else if (_c == QMetaObject::QueryPropertyUser) {
1832
        _id -= 52;
1833
    }
1834
#endif // QT_NO_PROPERTIES
1835
    return _id;
1836
}
1837
1838
// SIGNAL 0
1839
void QCPAxis::ticksRequest()
1840
{
1841
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
1842
}
1843
1844
// SIGNAL 1
1845
void QCPAxis::rangeChanged(const QCPRange & _t1)
1846
{
1847
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1848
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
1849
}
1850
1851
// SIGNAL 2
1852
void QCPAxis::rangeChanged(const QCPRange & _t1, const QCPRange & _t2)
1853
{
1854
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
1855
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
1856
}
1857
1858
// SIGNAL 3
1859
void QCPAxis::scaleTypeChanged(QCPAxis::ScaleType _t1)
1860
{
1861
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1862
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
1863
}
1864
1865
// SIGNAL 4
1866
void QCPAxis::selectionChanged(const QCPAxis::SelectableParts & _t1)
1867
{
1868
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1869
    QMetaObject::activate(this, &staticMetaObject, 4, _a);
1870
}
1871
1872
// SIGNAL 5
1873
void QCPAxis::selectableChanged(const QCPAxis::SelectableParts & _t1)
1874
{
1875
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
1876
    QMetaObject::activate(this, &staticMetaObject, 5, _a);
1877
}
1878
struct qt_meta_stringdata_QCPAbstractPlottable_t {
1879
    QByteArrayData data[19];
1880
    char stringdata0[228];
1881
};
1882
#define QT_MOC_LITERAL(idx, ofs, len) \
1883
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
1884
    qptrdiff(offsetof(qt_meta_stringdata_QCPAbstractPlottable_t, stringdata0) + ofs \
1885
        - idx * sizeof(QByteArrayData)) \
1886
    )
1887
static const qt_meta_stringdata_QCPAbstractPlottable_t qt_meta_stringdata_QCPAbstractPlottable = {
1888
    {
1889
QT_MOC_LITERAL(0, 0, 20), // "QCPAbstractPlottable"
1890
QT_MOC_LITERAL(1, 21, 16), // "selectionChanged"
1891
QT_MOC_LITERAL(2, 38, 0), // ""
1892
QT_MOC_LITERAL(3, 39, 8), // "selected"
1893
QT_MOC_LITERAL(4, 48, 17), // "selectableChanged"
1894
QT_MOC_LITERAL(5, 66, 10), // "selectable"
1895
QT_MOC_LITERAL(6, 77, 13), // "setSelectable"
1896
QT_MOC_LITERAL(7, 91, 11), // "setSelected"
1897
QT_MOC_LITERAL(8, 103, 4), // "name"
1898
QT_MOC_LITERAL(9, 108, 15), // "antialiasedFill"
1899
QT_MOC_LITERAL(10, 124, 19), // "antialiasedScatters"
1900
QT_MOC_LITERAL(11, 144, 20), // "antialiasedErrorBars"
1901
QT_MOC_LITERAL(12, 165, 3), // "pen"
1902
QT_MOC_LITERAL(13, 169, 11), // "selectedPen"
1903
QT_MOC_LITERAL(14, 181, 5), // "brush"
1904
QT_MOC_LITERAL(15, 187, 13), // "selectedBrush"
1905
QT_MOC_LITERAL(16, 201, 7), // "keyAxis"
1906
QT_MOC_LITERAL(17, 209, 8), // "QCPAxis*"
1907
QT_MOC_LITERAL(18, 218, 9) // "valueAxis"
1908
1909
    },
1910
    "QCPAbstractPlottable\0selectionChanged\0"
1911
    "\0selected\0selectableChanged\0selectable\0"
1912
    "setSelectable\0setSelected\0name\0"
1913
    "antialiasedFill\0antialiasedScatters\0"
1914
    "antialiasedErrorBars\0pen\0selectedPen\0"
1915
    "brush\0selectedBrush\0keyAxis\0QCPAxis*\0"
1916
    "valueAxis"
1917
};
1918
#undef QT_MOC_LITERAL
1919
1920
static const uint qt_meta_data_QCPAbstractPlottable[] = {
1921
1922
 // content:
1923
       8,       // revision
1924
       0,       // classname
1925
       0,    0, // classinfo
1926
       4,   14, // methods
1927
      12,   46, // properties
1928
       0,    0, // enums/sets
1929
       0,    0, // constructors
1930
       0,       // flags
1931
       2,       // signalCount
1932
1933
 // signals: name, argc, parameters, tag, flags
1934
       1,    1,   34,    2, 0x06 /* Public */,
1935
       4,    1,   37,    2, 0x06 /* Public */,
1936
1937
 // slots: name, argc, parameters, tag, flags
1938
       6,    1,   40,    2, 0x0a /* Public */,
1939
       7,    1,   43,    2, 0x0a /* Public */,
1940
1941
 // signals: parameters
1942
    QMetaType::Void, QMetaType::Bool,    3,
1943
    QMetaType::Void, QMetaType::Bool,    5,
1944
1945
 // slots: parameters
1946
    QMetaType::Void, QMetaType::Bool,    5,
1947
    QMetaType::Void, QMetaType::Bool,    3,
1948
1949
 // properties: name, type, flags
1950
       8, QMetaType::QString, 0x00095103,
1951
       9, QMetaType::Bool, 0x00095103,
1952
      10, QMetaType::Bool, 0x00095103,
1953
      11, QMetaType::Bool, 0x00095103,
1954
      12, QMetaType::QPen, 0x00095103,
1955
      13, QMetaType::QPen, 0x00095103,
1956
      14, QMetaType::QBrush, 0x00095103,
1957
      15, QMetaType::QBrush, 0x00095103,
1958
      16, 0x80000000 | 17, 0x0009510b,
1959
      18, 0x80000000 | 17, 0x0009510b,
1960
       5, QMetaType::Bool, 0x00495103,
1961
       3, QMetaType::Bool, 0x00495103,
1962
1963
 // properties: notify_signal_id
1964
       0,
1965
       0,
1966
       0,
1967
       0,
1968
       0,
1969
       0,
1970
       0,
1971
       0,
1972
       0,
1973
       0,
1974
       1,
1975
       0,
1976
1977
       0        // eod
1978
};
1979
1980
void QCPAbstractPlottable::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
1981
{
1982
    if (_c == QMetaObject::InvokeMetaMethod) {
1983
        auto *_t = static_cast<QCPAbstractPlottable *>(_o);
1984
        Q_UNUSED(_t)
1985
        switch (_id) {
1986
        case 0: _t->selectionChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
1987
        case 1: _t->selectableChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
1988
        case 2: _t->setSelectable((*reinterpret_cast< bool(*)>(_a[1]))); break;
1989
        case 3: _t->setSelected((*reinterpret_cast< bool(*)>(_a[1]))); break;
1990
        default: ;
1991
        }
1992
    } else if (_c == QMetaObject::IndexOfMethod) {
1993
        int *result = reinterpret_cast<int *>(_a[0]);
1994
        {
1995
            using _t = void (QCPAbstractPlottable::*)(bool );
1996
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAbstractPlottable::selectionChanged)) {
1997
                *result = 0;
1998
                return;
1999
            }
2000
        }
2001
        {
2002
            using _t = void (QCPAbstractPlottable::*)(bool );
2003
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAbstractPlottable::selectableChanged)) {
2004
                *result = 1;
2005
                return;
2006
            }
2007
        }
2008
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
2009
        switch (_id) {
2010
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2011
        case 9:
2012
        case 8:
2013
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxis* >(); break;
2014
        }
2015
    }
2016
2017
#ifndef QT_NO_PROPERTIES
2018
    else if (_c == QMetaObject::ReadProperty) {
2019
        auto *_t = static_cast<QCPAbstractPlottable *>(_o);
2020
        Q_UNUSED(_t)
2021
        void *_v = _a[0];
2022
        switch (_id) {
2023
        case 0: *reinterpret_cast< QString*>(_v) = _t->name(); break;
2024
        case 1: *reinterpret_cast< bool*>(_v) = _t->antialiasedFill(); break;
2025
        case 2: *reinterpret_cast< bool*>(_v) = _t->antialiasedScatters(); break;
2026
        case 3: *reinterpret_cast< bool*>(_v) = _t->antialiasedErrorBars(); break;
2027
        case 4: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
2028
        case 5: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
2029
        case 6: *reinterpret_cast< QBrush*>(_v) = _t->brush(); break;
2030
        case 7: *reinterpret_cast< QBrush*>(_v) = _t->selectedBrush(); break;
2031
        case 8: *reinterpret_cast< QCPAxis**>(_v) = _t->keyAxis(); break;
2032
        case 9: *reinterpret_cast< QCPAxis**>(_v) = _t->valueAxis(); break;
2033
        case 10: *reinterpret_cast< bool*>(_v) = _t->selectable(); break;
2034
        case 11: *reinterpret_cast< bool*>(_v) = _t->selected(); break;
2035
        default: break;
2036
        }
2037
    } else if (_c == QMetaObject::WriteProperty) {
2038
        auto *_t = static_cast<QCPAbstractPlottable *>(_o);
2039
        Q_UNUSED(_t)
2040
        void *_v = _a[0];
2041
        switch (_id) {
2042
        case 0: _t->setName(*reinterpret_cast< QString*>(_v)); break;
2043
        case 1: _t->setAntialiasedFill(*reinterpret_cast< bool*>(_v)); break;
2044
        case 2: _t->setAntialiasedScatters(*reinterpret_cast< bool*>(_v)); break;
2045
        case 3: _t->setAntialiasedErrorBars(*reinterpret_cast< bool*>(_v)); break;
2046
        case 4: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
2047
        case 5: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
2048
        case 6: _t->setBrush(*reinterpret_cast< QBrush*>(_v)); break;
2049
        case 7: _t->setSelectedBrush(*reinterpret_cast< QBrush*>(_v)); break;
2050
        case 8: _t->setKeyAxis(*reinterpret_cast< QCPAxis**>(_v)); break;
2051
        case 9: _t->setValueAxis(*reinterpret_cast< QCPAxis**>(_v)); break;
2052
        case 10: _t->setSelectable(*reinterpret_cast< bool*>(_v)); break;
2053
        case 11: _t->setSelected(*reinterpret_cast< bool*>(_v)); break;
2054
        default: break;
2055
        }
2056
    } else if (_c == QMetaObject::ResetProperty) {
2057
    }
2058
#endif // QT_NO_PROPERTIES
2059
}
2060
2061
QT_INIT_METAOBJECT const QMetaObject QCPAbstractPlottable::staticMetaObject = { {
2062
    &QCPLayerable::staticMetaObject,
2063
    qt_meta_stringdata_QCPAbstractPlottable.data,
2064
    qt_meta_data_QCPAbstractPlottable,
2065
    qt_static_metacall,
2066
    nullptr,
2067
    nullptr
2068
} };
2069
2070
2071
const QMetaObject *QCPAbstractPlottable::metaObject() const
2072
{
2073
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
2074
}
2075
2076
void *QCPAbstractPlottable::qt_metacast(const char *_clname)
2077
{
2078
    if (!_clname) return nullptr;
2079
    if (!strcmp(_clname, qt_meta_stringdata_QCPAbstractPlottable.stringdata0))
2080
        return static_cast<void*>(this);
2081
    return QCPLayerable::qt_metacast(_clname);
2082
}
2083
2084
int QCPAbstractPlottable::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
2085
{
2086
    _id = QCPLayerable::qt_metacall(_c, _id, _a);
2087
    if (_id < 0)
2088
        return _id;
2089
    if (_c == QMetaObject::InvokeMetaMethod) {
2090
        if (_id < 4)
2091
            qt_static_metacall(this, _c, _id, _a);
2092
        _id -= 4;
2093
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
2094
        if (_id < 4)
2095
            *reinterpret_cast<int*>(_a[0]) = -1;
2096
        _id -= 4;
2097
    }
2098
#ifndef QT_NO_PROPERTIES
2099
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
2100
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
2101
        qt_static_metacall(this, _c, _id, _a);
2102
        _id -= 12;
2103
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
2104
        _id -= 12;
2105
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
2106
        _id -= 12;
2107
    } else if (_c == QMetaObject::QueryPropertyStored) {
2108
        _id -= 12;
2109
    } else if (_c == QMetaObject::QueryPropertyEditable) {
2110
        _id -= 12;
2111
    } else if (_c == QMetaObject::QueryPropertyUser) {
2112
        _id -= 12;
2113
    }
2114
#endif // QT_NO_PROPERTIES
2115
    return _id;
2116
}
2117
2118
// SIGNAL 0
2119
void QCPAbstractPlottable::selectionChanged(bool _t1)
2120
{
2121
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
2122
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
2123
}
2124
2125
// SIGNAL 1
2126
void QCPAbstractPlottable::selectableChanged(bool _t1)
2127
{
2128
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
2129
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
2130
}
2131
struct qt_meta_stringdata_QCPAbstractItem_t {
2132
    QByteArrayData data[11];
2133
    char stringdata0[139];
2134
};
2135
#define QT_MOC_LITERAL(idx, ofs, len) \
2136
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
2137
    qptrdiff(offsetof(qt_meta_stringdata_QCPAbstractItem_t, stringdata0) + ofs \
2138
        - idx * sizeof(QByteArrayData)) \
2139
    )
2140
static const qt_meta_stringdata_QCPAbstractItem_t qt_meta_stringdata_QCPAbstractItem = {
2141
    {
2142
QT_MOC_LITERAL(0, 0, 15), // "QCPAbstractItem"
2143
QT_MOC_LITERAL(1, 16, 16), // "selectionChanged"
2144
QT_MOC_LITERAL(2, 33, 0), // ""
2145
QT_MOC_LITERAL(3, 34, 8), // "selected"
2146
QT_MOC_LITERAL(4, 43, 17), // "selectableChanged"
2147
QT_MOC_LITERAL(5, 61, 10), // "selectable"
2148
QT_MOC_LITERAL(6, 72, 13), // "setSelectable"
2149
QT_MOC_LITERAL(7, 86, 11), // "setSelected"
2150
QT_MOC_LITERAL(8, 98, 14), // "clipToAxisRect"
2151
QT_MOC_LITERAL(9, 113, 12), // "clipAxisRect"
2152
QT_MOC_LITERAL(10, 126, 12) // "QCPAxisRect*"
2153
2154
    },
2155
    "QCPAbstractItem\0selectionChanged\0\0"
2156
    "selected\0selectableChanged\0selectable\0"
2157
    "setSelectable\0setSelected\0clipToAxisRect\0"
2158
    "clipAxisRect\0QCPAxisRect*"
2159
};
2160
#undef QT_MOC_LITERAL
2161
2162
static const uint qt_meta_data_QCPAbstractItem[] = {
2163
2164
 // content:
2165
       8,       // revision
2166
       0,       // classname
2167
       0,    0, // classinfo
2168
       4,   14, // methods
2169
       4,   46, // properties
2170
       0,    0, // enums/sets
2171
       0,    0, // constructors
2172
       0,       // flags
2173
       2,       // signalCount
2174
2175
 // signals: name, argc, parameters, tag, flags
2176
       1,    1,   34,    2, 0x06 /* Public */,
2177
       4,    1,   37,    2, 0x06 /* Public */,
2178
2179
 // slots: name, argc, parameters, tag, flags
2180
       6,    1,   40,    2, 0x0a /* Public */,
2181
       7,    1,   43,    2, 0x0a /* Public */,
2182
2183
 // signals: parameters
2184
    QMetaType::Void, QMetaType::Bool,    3,
2185
    QMetaType::Void, QMetaType::Bool,    5,
2186
2187
 // slots: parameters
2188
    QMetaType::Void, QMetaType::Bool,    5,
2189
    QMetaType::Void, QMetaType::Bool,    3,
2190
2191
 // properties: name, type, flags
2192
       8, QMetaType::Bool, 0x00095103,
2193
       9, 0x80000000 | 10, 0x0009510b,
2194
       5, QMetaType::Bool, 0x00495103,
2195
       3, QMetaType::Bool, 0x00495103,
2196
2197
 // properties: notify_signal_id
2198
       0,
2199
       0,
2200
       1,
2201
       0,
2202
2203
       0        // eod
2204
};
2205
2206
void QCPAbstractItem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
2207
{
2208
    if (_c == QMetaObject::InvokeMetaMethod) {
2209
        auto *_t = static_cast<QCPAbstractItem *>(_o);
2210
        Q_UNUSED(_t)
2211
        switch (_id) {
2212
        case 0: _t->selectionChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
2213
        case 1: _t->selectableChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
2214
        case 2: _t->setSelectable((*reinterpret_cast< bool(*)>(_a[1]))); break;
2215
        case 3: _t->setSelected((*reinterpret_cast< bool(*)>(_a[1]))); break;
2216
        default: ;
2217
        }
2218
    } else if (_c == QMetaObject::IndexOfMethod) {
2219
        int *result = reinterpret_cast<int *>(_a[0]);
2220
        {
2221
            using _t = void (QCPAbstractItem::*)(bool );
2222
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAbstractItem::selectionChanged)) {
2223
                *result = 0;
2224
                return;
2225
            }
2226
        }
2227
        {
2228
            using _t = void (QCPAbstractItem::*)(bool );
2229
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAbstractItem::selectableChanged)) {
2230
                *result = 1;
2231
                return;
2232
            }
2233
        }
2234
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
2235
        switch (_id) {
2236
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2237
        case 1:
2238
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxisRect* >(); break;
2239
        }
2240
    }
2241
2242
#ifndef QT_NO_PROPERTIES
2243
    else if (_c == QMetaObject::ReadProperty) {
2244
        auto *_t = static_cast<QCPAbstractItem *>(_o);
2245
        Q_UNUSED(_t)
2246
        void *_v = _a[0];
2247
        switch (_id) {
2248
        case 0: *reinterpret_cast< bool*>(_v) = _t->clipToAxisRect(); break;
2249
        case 1: *reinterpret_cast< QCPAxisRect**>(_v) = _t->clipAxisRect(); break;
2250
        case 2: *reinterpret_cast< bool*>(_v) = _t->selectable(); break;
2251
        case 3: *reinterpret_cast< bool*>(_v) = _t->selected(); break;
2252
        default: break;
2253
        }
2254
    } else if (_c == QMetaObject::WriteProperty) {
2255
        auto *_t = static_cast<QCPAbstractItem *>(_o);
2256
        Q_UNUSED(_t)
2257
        void *_v = _a[0];
2258
        switch (_id) {
2259
        case 0: _t->setClipToAxisRect(*reinterpret_cast< bool*>(_v)); break;
2260
        case 1: _t->setClipAxisRect(*reinterpret_cast< QCPAxisRect**>(_v)); break;
2261
        case 2: _t->setSelectable(*reinterpret_cast< bool*>(_v)); break;
2262
        case 3: _t->setSelected(*reinterpret_cast< bool*>(_v)); break;
2263
        default: break;
2264
        }
2265
    } else if (_c == QMetaObject::ResetProperty) {
2266
    }
2267
#endif // QT_NO_PROPERTIES
2268
}
2269
2270
QT_INIT_METAOBJECT const QMetaObject QCPAbstractItem::staticMetaObject = { {
2271
    &QCPLayerable::staticMetaObject,
2272
    qt_meta_stringdata_QCPAbstractItem.data,
2273
    qt_meta_data_QCPAbstractItem,
2274
    qt_static_metacall,
2275
    nullptr,
2276
    nullptr
2277
} };
2278
2279
2280
const QMetaObject *QCPAbstractItem::metaObject() const
2281
{
2282
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
2283
}
2284
2285
void *QCPAbstractItem::qt_metacast(const char *_clname)
2286
{
2287
    if (!_clname) return nullptr;
2288
    if (!strcmp(_clname, qt_meta_stringdata_QCPAbstractItem.stringdata0))
2289
        return static_cast<void*>(this);
2290
    return QCPLayerable::qt_metacast(_clname);
2291
}
2292
2293
int QCPAbstractItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
2294
{
2295
    _id = QCPLayerable::qt_metacall(_c, _id, _a);
2296
    if (_id < 0)
2297
        return _id;
2298
    if (_c == QMetaObject::InvokeMetaMethod) {
2299
        if (_id < 4)
2300
            qt_static_metacall(this, _c, _id, _a);
2301
        _id -= 4;
2302
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
2303
        if (_id < 4)
2304
            *reinterpret_cast<int*>(_a[0]) = -1;
2305
        _id -= 4;
2306
    }
2307
#ifndef QT_NO_PROPERTIES
2308
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
2309
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
2310
        qt_static_metacall(this, _c, _id, _a);
2311
        _id -= 4;
2312
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
2313
        _id -= 4;
2314
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
2315
        _id -= 4;
2316
    } else if (_c == QMetaObject::QueryPropertyStored) {
2317
        _id -= 4;
2318
    } else if (_c == QMetaObject::QueryPropertyEditable) {
2319
        _id -= 4;
2320
    } else if (_c == QMetaObject::QueryPropertyUser) {
2321
        _id -= 4;
2322
    }
2323
#endif // QT_NO_PROPERTIES
2324
    return _id;
2325
}
2326
2327
// SIGNAL 0
2328
void QCPAbstractItem::selectionChanged(bool _t1)
2329
{
2330
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
2331
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
2332
}
2333
2334
// SIGNAL 1
2335
void QCPAbstractItem::selectableChanged(bool _t1)
2336
{
2337
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
2338
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
2339
}
2340
struct qt_meta_stringdata_QCustomPlot_t {
2341
    QByteArrayData data[57];
2342
    char stringdata0[801];
2343
};
2344
#define QT_MOC_LITERAL(idx, ofs, len) \
2345
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
2346
    qptrdiff(offsetof(qt_meta_stringdata_QCustomPlot_t, stringdata0) + ofs \
2347
        - idx * sizeof(QByteArrayData)) \
2348
    )
2349
static const qt_meta_stringdata_QCustomPlot_t qt_meta_stringdata_QCustomPlot = {
2350
    {
2351
QT_MOC_LITERAL(0, 0, 11), // "QCustomPlot"
2352
QT_MOC_LITERAL(1, 12, 16), // "mouseDoubleClick"
2353
QT_MOC_LITERAL(2, 29, 0), // ""
2354
QT_MOC_LITERAL(3, 30, 12), // "QMouseEvent*"
2355
QT_MOC_LITERAL(4, 43, 5), // "event"
2356
QT_MOC_LITERAL(5, 49, 10), // "mousePress"
2357
QT_MOC_LITERAL(6, 60, 9), // "mouseMove"
2358
QT_MOC_LITERAL(7, 70, 12), // "mouseRelease"
2359
QT_MOC_LITERAL(8, 83, 10), // "mouseWheel"
2360
QT_MOC_LITERAL(9, 94, 12), // "QWheelEvent*"
2361
QT_MOC_LITERAL(10, 107, 14), // "plottableClick"
2362
QT_MOC_LITERAL(11, 122, 21), // "QCPAbstractPlottable*"
2363
QT_MOC_LITERAL(12, 144, 9), // "plottable"
2364
QT_MOC_LITERAL(13, 154, 20), // "plottableDoubleClick"
2365
QT_MOC_LITERAL(14, 175, 9), // "itemClick"
2366
QT_MOC_LITERAL(15, 185, 16), // "QCPAbstractItem*"
2367
QT_MOC_LITERAL(16, 202, 4), // "item"
2368
QT_MOC_LITERAL(17, 207, 15), // "itemDoubleClick"
2369
QT_MOC_LITERAL(18, 223, 9), // "axisClick"
2370
QT_MOC_LITERAL(19, 233, 8), // "QCPAxis*"
2371
QT_MOC_LITERAL(20, 242, 4), // "axis"
2372
QT_MOC_LITERAL(21, 247, 23), // "QCPAxis::SelectablePart"
2373
QT_MOC_LITERAL(22, 271, 4), // "part"
2374
QT_MOC_LITERAL(23, 276, 15), // "axisDoubleClick"
2375
QT_MOC_LITERAL(24, 292, 11), // "legendClick"
2376
QT_MOC_LITERAL(25, 304, 10), // "QCPLegend*"
2377
QT_MOC_LITERAL(26, 315, 6), // "legend"
2378
QT_MOC_LITERAL(27, 322, 22), // "QCPAbstractLegendItem*"
2379
QT_MOC_LITERAL(28, 345, 17), // "legendDoubleClick"
2380
QT_MOC_LITERAL(29, 363, 10), // "titleClick"
2381
QT_MOC_LITERAL(30, 374, 13), // "QCPPlotTitle*"
2382
QT_MOC_LITERAL(31, 388, 5), // "title"
2383
QT_MOC_LITERAL(32, 394, 16), // "titleDoubleClick"
2384
QT_MOC_LITERAL(33, 411, 22), // "selectionChangedByUser"
2385
QT_MOC_LITERAL(34, 434, 12), // "beforeReplot"
2386
QT_MOC_LITERAL(35, 447, 11), // "afterReplot"
2387
QT_MOC_LITERAL(36, 459, 11), // "rescaleAxes"
2388
QT_MOC_LITERAL(37, 471, 21), // "onlyVisiblePlottables"
2389
QT_MOC_LITERAL(38, 493, 11), // "deselectAll"
2390
QT_MOC_LITERAL(39, 505, 6), // "replot"
2391
QT_MOC_LITERAL(40, 512, 28), // "QCustomPlot::RefreshPriority"
2392
QT_MOC_LITERAL(41, 541, 15), // "refreshPriority"
2393
QT_MOC_LITERAL(42, 557, 8), // "viewport"
2394
QT_MOC_LITERAL(43, 566, 10), // "background"
2395
QT_MOC_LITERAL(44, 577, 16), // "backgroundScaled"
2396
QT_MOC_LITERAL(45, 594, 20), // "backgroundScaledMode"
2397
QT_MOC_LITERAL(46, 615, 19), // "Qt::AspectRatioMode"
2398
QT_MOC_LITERAL(47, 635, 10), // "plotLayout"
2399
QT_MOC_LITERAL(48, 646, 14), // "QCPLayoutGrid*"
2400
QT_MOC_LITERAL(49, 661, 24), // "autoAddPlottableToLegend"
2401
QT_MOC_LITERAL(50, 686, 18), // "selectionTolerance"
2402
QT_MOC_LITERAL(51, 705, 20), // "noAntialiasingOnDrag"
2403
QT_MOC_LITERAL(52, 726, 19), // "multiSelectModifier"
2404
QT_MOC_LITERAL(53, 746, 20), // "Qt::KeyboardModifier"
2405
QT_MOC_LITERAL(54, 767, 15), // "LayerInsertMode"
2406
QT_MOC_LITERAL(55, 783, 8), // "limBelow"
2407
QT_MOC_LITERAL(56, 792, 8) // "limAbove"
2408
2409
    },
2410
    "QCustomPlot\0mouseDoubleClick\0\0"
2411
    "QMouseEvent*\0event\0mousePress\0mouseMove\0"
2412
    "mouseRelease\0mouseWheel\0QWheelEvent*\0"
2413
    "plottableClick\0QCPAbstractPlottable*\0"
2414
    "plottable\0plottableDoubleClick\0itemClick\0"
2415
    "QCPAbstractItem*\0item\0itemDoubleClick\0"
2416
    "axisClick\0QCPAxis*\0axis\0QCPAxis::SelectablePart\0"
2417
    "part\0axisDoubleClick\0legendClick\0"
2418
    "QCPLegend*\0legend\0QCPAbstractLegendItem*\0"
2419
    "legendDoubleClick\0titleClick\0QCPPlotTitle*\0"
2420
    "title\0titleDoubleClick\0selectionChangedByUser\0"
2421
    "beforeReplot\0afterReplot\0rescaleAxes\0"
2422
    "onlyVisiblePlottables\0deselectAll\0"
2423
    "replot\0QCustomPlot::RefreshPriority\0"
2424
    "refreshPriority\0viewport\0background\0"
2425
    "backgroundScaled\0backgroundScaledMode\0"
2426
    "Qt::AspectRatioMode\0plotLayout\0"
2427
    "QCPLayoutGrid*\0autoAddPlottableToLegend\0"
2428
    "selectionTolerance\0noAntialiasingOnDrag\0"
2429
    "multiSelectModifier\0Qt::KeyboardModifier\0"
2430
    "LayerInsertMode\0limBelow\0limAbove"
2431
};
2432
#undef QT_MOC_LITERAL
2433
2434
static const uint qt_meta_data_QCustomPlot[] = {
2435
2436
 // content:
2437
       8,       // revision
2438
       0,       // classname
2439
       0,    0, // classinfo
2440
      23,   14, // methods
2441
       9,  214, // properties
2442
       1,  241, // enums/sets
2443
       0,    0, // constructors
2444
       0,       // flags
2445
      18,       // signalCount
2446
2447
 // signals: name, argc, parameters, tag, flags
2448
       1,    1,  129,    2, 0x06 /* Public */,
2449
       5,    1,  132,    2, 0x06 /* Public */,
2450
       6,    1,  135,    2, 0x06 /* Public */,
2451
       7,    1,  138,    2, 0x06 /* Public */,
2452
       8,    1,  141,    2, 0x06 /* Public */,
2453
      10,    2,  144,    2, 0x06 /* Public */,
2454
      13,    2,  149,    2, 0x06 /* Public */,
2455
      14,    2,  154,    2, 0x06 /* Public */,
2456
      17,    2,  159,    2, 0x06 /* Public */,
2457
      18,    3,  164,    2, 0x06 /* Public */,
2458
      23,    3,  171,    2, 0x06 /* Public */,
2459
      24,    3,  178,    2, 0x06 /* Public */,
2460
      28,    3,  185,    2, 0x06 /* Public */,
2461
      29,    2,  192,    2, 0x06 /* Public */,
2462
      32,    2,  197,    2, 0x06 /* Public */,
2463
      33,    0,  202,    2, 0x06 /* Public */,
2464
      34,    0,  203,    2, 0x06 /* Public */,
2465
      35,    0,  204,    2, 0x06 /* Public */,
2466
2467
 // slots: name, argc, parameters, tag, flags
2468
      36,    1,  205,    2, 0x0a /* Public */,
2469
      36,    0,  208,    2, 0x2a /* Public | MethodCloned */,
2470
      38,    0,  209,    2, 0x0a /* Public */,
2471
      39,    1,  210,    2, 0x0a /* Public */,
2472
      39,    0,  213,    2, 0x2a /* Public | MethodCloned */,
2473
2474
 // signals: parameters
2475
    QMetaType::Void, 0x80000000 | 3,    4,
2476
    QMetaType::Void, 0x80000000 | 3,    4,
2477
    QMetaType::Void, 0x80000000 | 3,    4,
2478
    QMetaType::Void, 0x80000000 | 3,    4,
2479
    QMetaType::Void, 0x80000000 | 9,    4,
2480
    QMetaType::Void, 0x80000000 | 11, 0x80000000 | 3,   12,    4,
2481
    QMetaType::Void, 0x80000000 | 11, 0x80000000 | 3,   12,    4,
2482
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 3,   16,    4,
2483
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 3,   16,    4,
2484
    QMetaType::Void, 0x80000000 | 19, 0x80000000 | 21, 0x80000000 | 3,   20,   22,    4,
2485
    QMetaType::Void, 0x80000000 | 19, 0x80000000 | 21, 0x80000000 | 3,   20,   22,    4,
2486
    QMetaType::Void, 0x80000000 | 25, 0x80000000 | 27, 0x80000000 | 3,   26,   16,    4,
2487
    QMetaType::Void, 0x80000000 | 25, 0x80000000 | 27, 0x80000000 | 3,   26,   16,    4,
2488
    QMetaType::Void, 0x80000000 | 3, 0x80000000 | 30,    4,   31,
2489
    QMetaType::Void, 0x80000000 | 3, 0x80000000 | 30,    4,   31,
2490
    QMetaType::Void,
2491
    QMetaType::Void,
2492
    QMetaType::Void,
2493
2494
 // slots: parameters
2495
    QMetaType::Void, QMetaType::Bool,   37,
2496
    QMetaType::Void,
2497
    QMetaType::Void,
2498
    QMetaType::Void, 0x80000000 | 40,   41,
2499
    QMetaType::Void,
2500
2501
 // properties: name, type, flags
2502
      42, QMetaType::QRect, 0x00095103,
2503
      43, QMetaType::QPixmap, 0x00095103,
2504
      44, QMetaType::Bool, 0x00095103,
2505
      45, 0x80000000 | 46, 0x0009510b,
2506
      47, 0x80000000 | 48, 0x00095009,
2507
      49, QMetaType::Bool, 0x00095103,
2508
      50, QMetaType::Int, 0x00095103,
2509
      51, QMetaType::Bool, 0x00095103,
2510
      52, 0x80000000 | 53, 0x0009510b,
2511
2512
 // enums: name, alias, flags, count, data
2513
      54,   54, 0x0,    2,  246,
2514
2515
 // enum data: key, value
2516
      55, uint(QCustomPlot::limBelow),
2517
      56, uint(QCustomPlot::limAbove),
2518
2519
       0        // eod
2520
};
2521
2522
void QCustomPlot::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
2523
{
2524
    if (_c == QMetaObject::InvokeMetaMethod) {
2525
        auto *_t = static_cast<QCustomPlot *>(_o);
2526
        Q_UNUSED(_t)
2527
        switch (_id) {
2528
        case 0: _t->mouseDoubleClick((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
2529
        case 1: _t->mousePress((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
2530
        case 2: _t->mouseMove((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
2531
        case 3: _t->mouseRelease((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
2532
        case 4: _t->mouseWheel((*reinterpret_cast< QWheelEvent*(*)>(_a[1]))); break;
2533
        case 5: _t->plottableClick((*reinterpret_cast< QCPAbstractPlottable*(*)>(_a[1])),(*reinterpret_cast< QMouseEvent*(*)>(_a[2]))); break;
2534
        case 6: _t->plottableDoubleClick((*reinterpret_cast< QCPAbstractPlottable*(*)>(_a[1])),(*reinterpret_cast< QMouseEvent*(*)>(_a[2]))); break;
2535
        case 7: _t->itemClick((*reinterpret_cast< QCPAbstractItem*(*)>(_a[1])),(*reinterpret_cast< QMouseEvent*(*)>(_a[2]))); break;
2536
        case 8: _t->itemDoubleClick((*reinterpret_cast< QCPAbstractItem*(*)>(_a[1])),(*reinterpret_cast< QMouseEvent*(*)>(_a[2]))); break;
2537
        case 9: _t->axisClick((*reinterpret_cast< QCPAxis*(*)>(_a[1])),(*reinterpret_cast< QCPAxis::SelectablePart(*)>(_a[2])),(*reinterpret_cast< QMouseEvent*(*)>(_a[3]))); break;
2538
        case 10: _t->axisDoubleClick((*reinterpret_cast< QCPAxis*(*)>(_a[1])),(*reinterpret_cast< QCPAxis::SelectablePart(*)>(_a[2])),(*reinterpret_cast< QMouseEvent*(*)>(_a[3]))); break;
2539
        case 11: _t->legendClick((*reinterpret_cast< QCPLegend*(*)>(_a[1])),(*reinterpret_cast< QCPAbstractLegendItem*(*)>(_a[2])),(*reinterpret_cast< QMouseEvent*(*)>(_a[3]))); break;
2540
        case 12: _t->legendDoubleClick((*reinterpret_cast< QCPLegend*(*)>(_a[1])),(*reinterpret_cast< QCPAbstractLegendItem*(*)>(_a[2])),(*reinterpret_cast< QMouseEvent*(*)>(_a[3]))); break;
2541
        case 13: _t->titleClick((*reinterpret_cast< QMouseEvent*(*)>(_a[1])),(*reinterpret_cast< QCPPlotTitle*(*)>(_a[2]))); break;
2542
        case 14: _t->titleDoubleClick((*reinterpret_cast< QMouseEvent*(*)>(_a[1])),(*reinterpret_cast< QCPPlotTitle*(*)>(_a[2]))); break;
2543
        case 15: _t->selectionChangedByUser(); break;
2544
        case 16: _t->beforeReplot(); break;
2545
        case 17: _t->afterReplot(); break;
2546
        case 18: _t->rescaleAxes((*reinterpret_cast< bool(*)>(_a[1]))); break;
2547
        case 19: _t->rescaleAxes(); break;
2548
        case 20: _t->deselectAll(); break;
2549
        case 21: _t->replot((*reinterpret_cast< QCustomPlot::RefreshPriority(*)>(_a[1]))); break;
2550
        case 22: _t->replot(); break;
2551
        default: ;
2552
        }
2553
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
2554
        switch (_id) {
2555
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2556
        case 5:
2557
            switch (*reinterpret_cast<int*>(_a[1])) {
2558
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2559
            case 0:
2560
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAbstractPlottable* >(); break;
2561
            }
2562
            break;
2563
        case 6:
2564
            switch (*reinterpret_cast<int*>(_a[1])) {
2565
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2566
            case 0:
2567
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAbstractPlottable* >(); break;
2568
            }
2569
            break;
2570
        case 7:
2571
            switch (*reinterpret_cast<int*>(_a[1])) {
2572
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2573
            case 0:
2574
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAbstractItem* >(); break;
2575
            }
2576
            break;
2577
        case 8:
2578
            switch (*reinterpret_cast<int*>(_a[1])) {
2579
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2580
            case 0:
2581
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAbstractItem* >(); break;
2582
            }
2583
            break;
2584
        case 9:
2585
            switch (*reinterpret_cast<int*>(_a[1])) {
2586
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2587
            case 0:
2588
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxis* >(); break;
2589
            case 1:
2590
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxis::SelectablePart >(); break;
2591
            }
2592
            break;
2593
        case 10:
2594
            switch (*reinterpret_cast<int*>(_a[1])) {
2595
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2596
            case 0:
2597
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxis* >(); break;
2598
            case 1:
2599
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxis::SelectablePart >(); break;
2600
            }
2601
            break;
2602
        case 11:
2603
            switch (*reinterpret_cast<int*>(_a[1])) {
2604
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2605
            case 1:
2606
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAbstractLegendItem* >(); break;
2607
            case 0:
2608
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLegend* >(); break;
2609
            }
2610
            break;
2611
        case 12:
2612
            switch (*reinterpret_cast<int*>(_a[1])) {
2613
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2614
            case 1:
2615
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAbstractLegendItem* >(); break;
2616
            case 0:
2617
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLegend* >(); break;
2618
            }
2619
            break;
2620
        case 13:
2621
            switch (*reinterpret_cast<int*>(_a[1])) {
2622
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2623
            case 1:
2624
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPPlotTitle* >(); break;
2625
            }
2626
            break;
2627
        case 14:
2628
            switch (*reinterpret_cast<int*>(_a[1])) {
2629
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2630
            case 1:
2631
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPPlotTitle* >(); break;
2632
            }
2633
            break;
2634
        }
2635
    } else if (_c == QMetaObject::IndexOfMethod) {
2636
        int *result = reinterpret_cast<int *>(_a[0]);
2637
        {
2638
            using _t = void (QCustomPlot::*)(QMouseEvent * );
2639
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::mouseDoubleClick)) {
2640
                *result = 0;
2641
                return;
2642
            }
2643
        }
2644
        {
2645
            using _t = void (QCustomPlot::*)(QMouseEvent * );
2646
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::mousePress)) {
2647
                *result = 1;
2648
                return;
2649
            }
2650
        }
2651
        {
2652
            using _t = void (QCustomPlot::*)(QMouseEvent * );
2653
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::mouseMove)) {
2654
                *result = 2;
2655
                return;
2656
            }
2657
        }
2658
        {
2659
            using _t = void (QCustomPlot::*)(QMouseEvent * );
2660
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::mouseRelease)) {
2661
                *result = 3;
2662
                return;
2663
            }
2664
        }
2665
        {
2666
            using _t = void (QCustomPlot::*)(QWheelEvent * );
2667
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::mouseWheel)) {
2668
                *result = 4;
2669
                return;
2670
            }
2671
        }
2672
        {
2673
            using _t = void (QCustomPlot::*)(QCPAbstractPlottable * , QMouseEvent * );
2674
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::plottableClick)) {
2675
                *result = 5;
2676
                return;
2677
            }
2678
        }
2679
        {
2680
            using _t = void (QCustomPlot::*)(QCPAbstractPlottable * , QMouseEvent * );
2681
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::plottableDoubleClick)) {
2682
                *result = 6;
2683
                return;
2684
            }
2685
        }
2686
        {
2687
            using _t = void (QCustomPlot::*)(QCPAbstractItem * , QMouseEvent * );
2688
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::itemClick)) {
2689
                *result = 7;
2690
                return;
2691
            }
2692
        }
2693
        {
2694
            using _t = void (QCustomPlot::*)(QCPAbstractItem * , QMouseEvent * );
2695
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::itemDoubleClick)) {
2696
                *result = 8;
2697
                return;
2698
            }
2699
        }
2700
        {
2701
            using _t = void (QCustomPlot::*)(QCPAxis * , QCPAxis::SelectablePart , QMouseEvent * );
2702
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::axisClick)) {
2703
                *result = 9;
2704
                return;
2705
            }
2706
        }
2707
        {
2708
            using _t = void (QCustomPlot::*)(QCPAxis * , QCPAxis::SelectablePart , QMouseEvent * );
2709
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::axisDoubleClick)) {
2710
                *result = 10;
2711
                return;
2712
            }
2713
        }
2714
        {
2715
            using _t = void (QCustomPlot::*)(QCPLegend * , QCPAbstractLegendItem * , QMouseEvent * );
2716
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::legendClick)) {
2717
                *result = 11;
2718
                return;
2719
            }
2720
        }
2721
        {
2722
            using _t = void (QCustomPlot::*)(QCPLegend * , QCPAbstractLegendItem * , QMouseEvent * );
2723
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::legendDoubleClick)) {
2724
                *result = 12;
2725
                return;
2726
            }
2727
        }
2728
        {
2729
            using _t = void (QCustomPlot::*)(QMouseEvent * , QCPPlotTitle * );
2730
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::titleClick)) {
2731
                *result = 13;
2732
                return;
2733
            }
2734
        }
2735
        {
2736
            using _t = void (QCustomPlot::*)(QMouseEvent * , QCPPlotTitle * );
2737
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::titleDoubleClick)) {
2738
                *result = 14;
2739
                return;
2740
            }
2741
        }
2742
        {
2743
            using _t = void (QCustomPlot::*)();
2744
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::selectionChangedByUser)) {
2745
                *result = 15;
2746
                return;
2747
            }
2748
        }
2749
        {
2750
            using _t = void (QCustomPlot::*)();
2751
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::beforeReplot)) {
2752
                *result = 16;
2753
                return;
2754
            }
2755
        }
2756
        {
2757
            using _t = void (QCustomPlot::*)();
2758
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::afterReplot)) {
2759
                *result = 17;
2760
                return;
2761
            }
2762
        }
2763
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
2764
        switch (_id) {
2765
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2766
        case 4:
2767
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayoutGrid* >(); break;
2768
        }
2769
    }
2770
2771
#ifndef QT_NO_PROPERTIES
2772
    else if (_c == QMetaObject::ReadProperty) {
2773
        auto *_t = static_cast<QCustomPlot *>(_o);
2774
        Q_UNUSED(_t)
2775
        void *_v = _a[0];
2776
        switch (_id) {
2777
        case 0: *reinterpret_cast< QRect*>(_v) = _t->viewport(); break;
2778
        case 1: *reinterpret_cast< QPixmap*>(_v) = _t->background(); break;
2779
        case 2: *reinterpret_cast< bool*>(_v) = _t->backgroundScaled(); break;
2780
        case 3: *reinterpret_cast< Qt::AspectRatioMode*>(_v) = _t->backgroundScaledMode(); break;
2781
        case 4: *reinterpret_cast< QCPLayoutGrid**>(_v) = _t->plotLayout(); break;
2782
        case 5: *reinterpret_cast< bool*>(_v) = _t->autoAddPlottableToLegend(); break;
2783
        case 6: *reinterpret_cast< int*>(_v) = _t->selectionTolerance(); break;
2784
        case 7: *reinterpret_cast< bool*>(_v) = _t->noAntialiasingOnDrag(); break;
2785
        case 8: *reinterpret_cast< Qt::KeyboardModifier*>(_v) = _t->multiSelectModifier(); break;
2786
        default: break;
2787
        }
2788
    } else if (_c == QMetaObject::WriteProperty) {
2789
        auto *_t = static_cast<QCustomPlot *>(_o);
2790
        Q_UNUSED(_t)
2791
        void *_v = _a[0];
2792
        switch (_id) {
2793
        case 0: _t->setViewport(*reinterpret_cast< QRect*>(_v)); break;
2794
        case 1: _t->setBackground(*reinterpret_cast< QPixmap*>(_v)); break;
2795
        case 2: _t->setBackgroundScaled(*reinterpret_cast< bool*>(_v)); break;
2796
        case 3: _t->setBackgroundScaledMode(*reinterpret_cast< Qt::AspectRatioMode*>(_v)); break;
2797
        case 5: _t->setAutoAddPlottableToLegend(*reinterpret_cast< bool*>(_v)); break;
2798
        case 6: _t->setSelectionTolerance(*reinterpret_cast< int*>(_v)); break;
2799
        case 7: _t->setNoAntialiasingOnDrag(*reinterpret_cast< bool*>(_v)); break;
2800
        case 8: _t->setMultiSelectModifier(*reinterpret_cast< Qt::KeyboardModifier*>(_v)); break;
2801
        default: break;
2802
        }
2803
    } else if (_c == QMetaObject::ResetProperty) {
2804
    }
2805
#endif // QT_NO_PROPERTIES
2806
}
2807
2808
QT_INIT_METAOBJECT const QMetaObject QCustomPlot::staticMetaObject = { {
2809
    &QWidget::staticMetaObject,
2810
    qt_meta_stringdata_QCustomPlot.data,
2811
    qt_meta_data_QCustomPlot,
2812
    qt_static_metacall,
2813
    nullptr,
2814
    nullptr
2815
} };
2816
2817
2818
const QMetaObject *QCustomPlot::metaObject() const
2819
{
2820
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
2821
}
2822
2823
void *QCustomPlot::qt_metacast(const char *_clname)
2824
{
2825
    if (!_clname) return nullptr;
2826
    if (!strcmp(_clname, qt_meta_stringdata_QCustomPlot.stringdata0))
2827
        return static_cast<void*>(this);
2828
    return QWidget::qt_metacast(_clname);
2829
}
2830
2831
int QCustomPlot::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
2832
{
2833
    _id = QWidget::qt_metacall(_c, _id, _a);
2834
    if (_id < 0)
2835
        return _id;
2836
    if (_c == QMetaObject::InvokeMetaMethod) {
2837
        if (_id < 23)
2838
            qt_static_metacall(this, _c, _id, _a);
2839
        _id -= 23;
2840
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
2841
        if (_id < 23)
2842
            qt_static_metacall(this, _c, _id, _a);
2843
        _id -= 23;
2844
    }
2845
#ifndef QT_NO_PROPERTIES
2846
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
2847
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
2848
        qt_static_metacall(this, _c, _id, _a);
2849
        _id -= 9;
2850
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
2851
        _id -= 9;
2852
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
2853
        _id -= 9;
2854
    } else if (_c == QMetaObject::QueryPropertyStored) {
2855
        _id -= 9;
2856
    } else if (_c == QMetaObject::QueryPropertyEditable) {
2857
        _id -= 9;
2858
    } else if (_c == QMetaObject::QueryPropertyUser) {
2859
        _id -= 9;
2860
    }
2861
#endif // QT_NO_PROPERTIES
2862
    return _id;
2863
}
2864
2865
// SIGNAL 0
2866
void QCustomPlot::mouseDoubleClick(QMouseEvent * _t1)
2867
{
2868
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
2869
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
2870
}
2871
2872
// SIGNAL 1
2873
void QCustomPlot::mousePress(QMouseEvent * _t1)
2874
{
2875
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
2876
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
2877
}
2878
2879
// SIGNAL 2
2880
void QCustomPlot::mouseMove(QMouseEvent * _t1)
2881
{
2882
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
2883
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
2884
}
2885
2886
// SIGNAL 3
2887
void QCustomPlot::mouseRelease(QMouseEvent * _t1)
2888
{
2889
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
2890
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
2891
}
2892
2893
// SIGNAL 4
2894
void QCustomPlot::mouseWheel(QWheelEvent * _t1)
2895
{
2896
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
2897
    QMetaObject::activate(this, &staticMetaObject, 4, _a);
2898
}
2899
2900
// SIGNAL 5
2901
void QCustomPlot::plottableClick(QCPAbstractPlottable * _t1, QMouseEvent * _t2)
2902
{
2903
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
2904
    QMetaObject::activate(this, &staticMetaObject, 5, _a);
2905
}
2906
2907
// SIGNAL 6
2908
void QCustomPlot::plottableDoubleClick(QCPAbstractPlottable * _t1, QMouseEvent * _t2)
2909
{
2910
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
2911
    QMetaObject::activate(this, &staticMetaObject, 6, _a);
2912
}
2913
2914
// SIGNAL 7
2915
void QCustomPlot::itemClick(QCPAbstractItem * _t1, QMouseEvent * _t2)
2916
{
2917
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
2918
    QMetaObject::activate(this, &staticMetaObject, 7, _a);
2919
}
2920
2921
// SIGNAL 8
2922
void QCustomPlot::itemDoubleClick(QCPAbstractItem * _t1, QMouseEvent * _t2)
2923
{
2924
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
2925
    QMetaObject::activate(this, &staticMetaObject, 8, _a);
2926
}
2927
2928
// SIGNAL 9
2929
void QCustomPlot::axisClick(QCPAxis * _t1, QCPAxis::SelectablePart _t2, QMouseEvent * _t3)
2930
{
2931
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
2932
    QMetaObject::activate(this, &staticMetaObject, 9, _a);
2933
}
2934
2935
// SIGNAL 10
2936
void QCustomPlot::axisDoubleClick(QCPAxis * _t1, QCPAxis::SelectablePart _t2, QMouseEvent * _t3)
2937
{
2938
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
2939
    QMetaObject::activate(this, &staticMetaObject, 10, _a);
2940
}
2941
2942
// SIGNAL 11
2943
void QCustomPlot::legendClick(QCPLegend * _t1, QCPAbstractLegendItem * _t2, QMouseEvent * _t3)
2944
{
2945
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
2946
    QMetaObject::activate(this, &staticMetaObject, 11, _a);
2947
}
2948
2949
// SIGNAL 12
2950
void QCustomPlot::legendDoubleClick(QCPLegend * _t1, QCPAbstractLegendItem * _t2, QMouseEvent * _t3)
2951
{
2952
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
2953
    QMetaObject::activate(this, &staticMetaObject, 12, _a);
2954
}
2955
2956
// SIGNAL 13
2957
void QCustomPlot::titleClick(QMouseEvent * _t1, QCPPlotTitle * _t2)
2958
{
2959
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
2960
    QMetaObject::activate(this, &staticMetaObject, 13, _a);
2961
}
2962
2963
// SIGNAL 14
2964
void QCustomPlot::titleDoubleClick(QMouseEvent * _t1, QCPPlotTitle * _t2)
2965
{
2966
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
2967
    QMetaObject::activate(this, &staticMetaObject, 14, _a);
2968
}
2969
2970
// SIGNAL 15
2971
void QCustomPlot::selectionChangedByUser()
2972
{
2973
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
2974
}
2975
2976
// SIGNAL 16
2977
void QCustomPlot::beforeReplot()
2978
{
2979
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
2980
}
2981
2982
// SIGNAL 17
2983
void QCustomPlot::afterReplot()
2984
{
2985
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
2986
}
2987
struct qt_meta_stringdata_QCPColorGradient_t {
2988
    QByteArrayData data[17];
2989
    char stringdata0[164];
2990
};
2991
#define QT_MOC_LITERAL(idx, ofs, len) \
2992
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
2993
    qptrdiff(offsetof(qt_meta_stringdata_QCPColorGradient_t, stringdata0) + ofs \
2994
        - idx * sizeof(QByteArrayData)) \
2995
    )
2996
static const qt_meta_stringdata_QCPColorGradient_t qt_meta_stringdata_QCPColorGradient = {
2997
    {
2998
QT_MOC_LITERAL(0, 0, 16), // "QCPColorGradient"
2999
QT_MOC_LITERAL(1, 17, 18), // "ColorInterpolation"
3000
QT_MOC_LITERAL(2, 36, 5), // "ciRGB"
3001
QT_MOC_LITERAL(3, 42, 5), // "ciHSV"
3002
QT_MOC_LITERAL(4, 48, 14), // "GradientPreset"
3003
QT_MOC_LITERAL(5, 63, 11), // "gpGrayscale"
3004
QT_MOC_LITERAL(6, 75, 5), // "gpHot"
3005
QT_MOC_LITERAL(7, 81, 6), // "gpCold"
3006
QT_MOC_LITERAL(8, 88, 7), // "gpNight"
3007
QT_MOC_LITERAL(9, 96, 7), // "gpCandy"
3008
QT_MOC_LITERAL(10, 104, 11), // "gpGeography"
3009
QT_MOC_LITERAL(11, 116, 5), // "gpIon"
3010
QT_MOC_LITERAL(12, 122, 9), // "gpThermal"
3011
QT_MOC_LITERAL(13, 132, 7), // "gpPolar"
3012
QT_MOC_LITERAL(14, 140, 10), // "gpSpectrum"
3013
QT_MOC_LITERAL(15, 151, 5), // "gpJet"
3014
QT_MOC_LITERAL(16, 157, 6) // "gpHues"
3015
3016
    },
3017
    "QCPColorGradient\0ColorInterpolation\0"
3018
    "ciRGB\0ciHSV\0GradientPreset\0gpGrayscale\0"
3019
    "gpHot\0gpCold\0gpNight\0gpCandy\0gpGeography\0"
3020
    "gpIon\0gpThermal\0gpPolar\0gpSpectrum\0"
3021
    "gpJet\0gpHues"
3022
};
3023
#undef QT_MOC_LITERAL
3024
3025
static const uint qt_meta_data_QCPColorGradient[] = {
3026
3027
 // content:
3028
       8,       // revision
3029
       0,       // classname
3030
       0,    0, // classinfo
3031
       0,    0, // methods
3032
       0,    0, // properties
3033
       2,   14, // enums/sets
3034
       0,    0, // constructors
3035
       4,       // flags
3036
       0,       // signalCount
3037
3038
 // enums: name, alias, flags, count, data
3039
       1,    1, 0x0,    2,   24,
3040
       4,    4, 0x0,   12,   28,
3041
3042
 // enum data: key, value
3043
       2, uint(QCPColorGradient::ciRGB),
3044
       3, uint(QCPColorGradient::ciHSV),
3045
       5, uint(QCPColorGradient::gpGrayscale),
3046
       6, uint(QCPColorGradient::gpHot),
3047
       7, uint(QCPColorGradient::gpCold),
3048
       8, uint(QCPColorGradient::gpNight),
3049
       9, uint(QCPColorGradient::gpCandy),
3050
      10, uint(QCPColorGradient::gpGeography),
3051
      11, uint(QCPColorGradient::gpIon),
3052
      12, uint(QCPColorGradient::gpThermal),
3053
      13, uint(QCPColorGradient::gpPolar),
3054
      14, uint(QCPColorGradient::gpSpectrum),
3055
      15, uint(QCPColorGradient::gpJet),
3056
      16, uint(QCPColorGradient::gpHues),
3057
3058
       0        // eod
3059
};
3060
3061
QT_INIT_METAOBJECT const QMetaObject QCPColorGradient::staticMetaObject = { {
3062
    nullptr,
3063
    qt_meta_stringdata_QCPColorGradient.data,
3064
    qt_meta_data_QCPColorGradient,
3065
    nullptr,
3066
    nullptr,
3067
    nullptr
3068
} };
3069
3070
struct qt_meta_stringdata_QCPAxisRect_t {
3071
    QByteArrayData data[8];
3072
    char stringdata0[118];
3073
};
3074
#define QT_MOC_LITERAL(idx, ofs, len) \
3075
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
3076
    qptrdiff(offsetof(qt_meta_stringdata_QCPAxisRect_t, stringdata0) + ofs \
3077
        - idx * sizeof(QByteArrayData)) \
3078
    )
3079
static const qt_meta_stringdata_QCPAxisRect_t qt_meta_stringdata_QCPAxisRect = {
3080
    {
3081
QT_MOC_LITERAL(0, 0, 11), // "QCPAxisRect"
3082
QT_MOC_LITERAL(1, 12, 10), // "background"
3083
QT_MOC_LITERAL(2, 23, 16), // "backgroundScaled"
3084
QT_MOC_LITERAL(3, 40, 20), // "backgroundScaledMode"
3085
QT_MOC_LITERAL(4, 61, 19), // "Qt::AspectRatioMode"
3086
QT_MOC_LITERAL(5, 81, 9), // "rangeDrag"
3087
QT_MOC_LITERAL(6, 91, 16), // "Qt::Orientations"
3088
QT_MOC_LITERAL(7, 108, 9) // "rangeZoom"
3089
3090
    },
3091
    "QCPAxisRect\0background\0backgroundScaled\0"
3092
    "backgroundScaledMode\0Qt::AspectRatioMode\0"
3093
    "rangeDrag\0Qt::Orientations\0rangeZoom"
3094
};
3095
#undef QT_MOC_LITERAL
3096
3097
static const uint qt_meta_data_QCPAxisRect[] = {
3098
3099
 // content:
3100
       8,       // revision
3101
       0,       // classname
3102
       0,    0, // classinfo
3103
       0,    0, // methods
3104
       5,   14, // properties
3105
       0,    0, // enums/sets
3106
       0,    0, // constructors
3107
       0,       // flags
3108
       0,       // signalCount
3109
3110
 // properties: name, type, flags
3111
       1, QMetaType::QPixmap, 0x00095103,
3112
       2, QMetaType::Bool, 0x00095103,
3113
       3, 0x80000000 | 4, 0x0009510b,
3114
       5, 0x80000000 | 6, 0x0009510b,
3115
       7, 0x80000000 | 6, 0x0009510b,
3116
3117
       0        // eod
3118
};
3119
3120
void QCPAxisRect::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
3121
{
3122
3123
#ifndef QT_NO_PROPERTIES
3124
    if (_c == QMetaObject::ReadProperty) {
3125
        auto *_t = static_cast<QCPAxisRect *>(_o);
3126
        Q_UNUSED(_t)
3127
        void *_v = _a[0];
3128
        switch (_id) {
3129
        case 0: *reinterpret_cast< QPixmap*>(_v) = _t->background(); break;
3130
        case 1: *reinterpret_cast< bool*>(_v) = _t->backgroundScaled(); break;
3131
        case 2: *reinterpret_cast< Qt::AspectRatioMode*>(_v) = _t->backgroundScaledMode(); break;
3132
        case 3: *reinterpret_cast< Qt::Orientations*>(_v) = _t->rangeDrag(); break;
3133
        case 4: *reinterpret_cast< Qt::Orientations*>(_v) = _t->rangeZoom(); break;
3134
        default: break;
3135
        }
3136
    } else if (_c == QMetaObject::WriteProperty) {
3137
        auto *_t = static_cast<QCPAxisRect *>(_o);
3138
        Q_UNUSED(_t)
3139
        void *_v = _a[0];
3140
        switch (_id) {
3141
        case 0: _t->setBackground(*reinterpret_cast< QPixmap*>(_v)); break;
3142
        case 1: _t->setBackgroundScaled(*reinterpret_cast< bool*>(_v)); break;
3143
        case 2: _t->setBackgroundScaledMode(*reinterpret_cast< Qt::AspectRatioMode*>(_v)); break;
3144
        case 3: _t->setRangeDrag(*reinterpret_cast< Qt::Orientations*>(_v)); break;
3145
        case 4: _t->setRangeZoom(*reinterpret_cast< Qt::Orientations*>(_v)); break;
3146
        default: break;
3147
        }
3148
    } else if (_c == QMetaObject::ResetProperty) {
3149
    }
3150
#endif // QT_NO_PROPERTIES
3151
    Q_UNUSED(_o);
3152
    Q_UNUSED(_id);
3153
    Q_UNUSED(_c);
3154
    Q_UNUSED(_a);
3155
}
3156
3157
QT_INIT_METAOBJECT const QMetaObject QCPAxisRect::staticMetaObject = { {
3158
    &QCPLayoutElement::staticMetaObject,
3159
    qt_meta_stringdata_QCPAxisRect.data,
3160
    qt_meta_data_QCPAxisRect,
3161
    qt_static_metacall,
3162
    nullptr,
3163
    nullptr
3164
} };
3165
3166
3167
const QMetaObject *QCPAxisRect::metaObject() const
3168
{
3169
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
3170
}
3171
3172
void *QCPAxisRect::qt_metacast(const char *_clname)
3173
{
3174
    if (!_clname) return nullptr;
3175
    if (!strcmp(_clname, qt_meta_stringdata_QCPAxisRect.stringdata0))
3176
        return static_cast<void*>(this);
3177
    return QCPLayoutElement::qt_metacast(_clname);
3178
}
3179
3180
int QCPAxisRect::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
3181
{
3182
    _id = QCPLayoutElement::qt_metacall(_c, _id, _a);
3183
    if (_id < 0)
3184
        return _id;
3185
3186
#ifndef QT_NO_PROPERTIES
3187
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
3188
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
3189
        qt_static_metacall(this, _c, _id, _a);
3190
        _id -= 5;
3191
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
3192
        _id -= 5;
3193
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
3194
        _id -= 5;
3195
    } else if (_c == QMetaObject::QueryPropertyStored) {
3196
        _id -= 5;
3197
    } else if (_c == QMetaObject::QueryPropertyEditable) {
3198
        _id -= 5;
3199
    } else if (_c == QMetaObject::QueryPropertyUser) {
3200
        _id -= 5;
3201
    }
3202
#endif // QT_NO_PROPERTIES
3203
    return _id;
3204
}
3205
struct qt_meta_stringdata_QCPAbstractLegendItem_t {
3206
    QByteArrayData data[14];
3207
    char stringdata0[174];
3208
};
3209
#define QT_MOC_LITERAL(idx, ofs, len) \
3210
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
3211
    qptrdiff(offsetof(qt_meta_stringdata_QCPAbstractLegendItem_t, stringdata0) + ofs \
3212
        - idx * sizeof(QByteArrayData)) \
3213
    )
3214
static const qt_meta_stringdata_QCPAbstractLegendItem_t qt_meta_stringdata_QCPAbstractLegendItem = {
3215
    {
3216
QT_MOC_LITERAL(0, 0, 21), // "QCPAbstractLegendItem"
3217
QT_MOC_LITERAL(1, 22, 16), // "selectionChanged"
3218
QT_MOC_LITERAL(2, 39, 0), // ""
3219
QT_MOC_LITERAL(3, 40, 8), // "selected"
3220
QT_MOC_LITERAL(4, 49, 17), // "selectableChanged"
3221
QT_MOC_LITERAL(5, 67, 10), // "selectable"
3222
QT_MOC_LITERAL(6, 78, 13), // "setSelectable"
3223
QT_MOC_LITERAL(7, 92, 11), // "setSelected"
3224
QT_MOC_LITERAL(8, 104, 12), // "parentLegend"
3225
QT_MOC_LITERAL(9, 117, 10), // "QCPLegend*"
3226
QT_MOC_LITERAL(10, 128, 4), // "font"
3227
QT_MOC_LITERAL(11, 133, 9), // "textColor"
3228
QT_MOC_LITERAL(12, 143, 12), // "selectedFont"
3229
QT_MOC_LITERAL(13, 156, 17) // "selectedTextColor"
3230
3231
    },
3232
    "QCPAbstractLegendItem\0selectionChanged\0"
3233
    "\0selected\0selectableChanged\0selectable\0"
3234
    "setSelectable\0setSelected\0parentLegend\0"
3235
    "QCPLegend*\0font\0textColor\0selectedFont\0"
3236
    "selectedTextColor"
3237
};
3238
#undef QT_MOC_LITERAL
3239
3240
static const uint qt_meta_data_QCPAbstractLegendItem[] = {
3241
3242
 // content:
3243
       8,       // revision
3244
       0,       // classname
3245
       0,    0, // classinfo
3246
       4,   14, // methods
3247
       7,   46, // properties
3248
       0,    0, // enums/sets
3249
       0,    0, // constructors
3250
       0,       // flags
3251
       2,       // signalCount
3252
3253
 // signals: name, argc, parameters, tag, flags
3254
       1,    1,   34,    2, 0x06 /* Public */,
3255
       4,    1,   37,    2, 0x06 /* Public */,
3256
3257
 // slots: name, argc, parameters, tag, flags
3258
       6,    1,   40,    2, 0x0a /* Public */,
3259
       7,    1,   43,    2, 0x0a /* Public */,
3260
3261
 // signals: parameters
3262
    QMetaType::Void, QMetaType::Bool,    3,
3263
    QMetaType::Void, QMetaType::Bool,    5,
3264
3265
 // slots: parameters
3266
    QMetaType::Void, QMetaType::Bool,    5,
3267
    QMetaType::Void, QMetaType::Bool,    3,
3268
3269
 // properties: name, type, flags
3270
       8, 0x80000000 | 9, 0x00095009,
3271
      10, QMetaType::QFont, 0x00095103,
3272
      11, QMetaType::QColor, 0x00095103,
3273
      12, QMetaType::QFont, 0x00095103,
3274
      13, QMetaType::QColor, 0x00095103,
3275
       5, QMetaType::Bool, 0x00495103,
3276
       3, QMetaType::Bool, 0x00495103,
3277
3278
 // properties: notify_signal_id
3279
       0,
3280
       0,
3281
       0,
3282
       0,
3283
       0,
3284
       0,
3285
       1,
3286
3287
       0        // eod
3288
};
3289
3290
void QCPAbstractLegendItem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
3291
{
3292
    if (_c == QMetaObject::InvokeMetaMethod) {
3293
        auto *_t = static_cast<QCPAbstractLegendItem *>(_o);
3294
        Q_UNUSED(_t)
3295
        switch (_id) {
3296
        case 0: _t->selectionChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
3297
        case 1: _t->selectableChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
3298
        case 2: _t->setSelectable((*reinterpret_cast< bool(*)>(_a[1]))); break;
3299
        case 3: _t->setSelected((*reinterpret_cast< bool(*)>(_a[1]))); break;
3300
        default: ;
3301
        }
3302
    } else if (_c == QMetaObject::IndexOfMethod) {
3303
        int *result = reinterpret_cast<int *>(_a[0]);
3304
        {
3305
            using _t = void (QCPAbstractLegendItem::*)(bool );
3306
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAbstractLegendItem::selectionChanged)) {
3307
                *result = 0;
3308
                return;
3309
            }
3310
        }
3311
        {
3312
            using _t = void (QCPAbstractLegendItem::*)(bool );
3313
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAbstractLegendItem::selectableChanged)) {
3314
                *result = 1;
3315
                return;
3316
            }
3317
        }
3318
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
3319
        switch (_id) {
3320
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
3321
        case 0:
3322
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLegend* >(); break;
3323
        }
3324
    }
3325
3326
#ifndef QT_NO_PROPERTIES
3327
    else if (_c == QMetaObject::ReadProperty) {
3328
        auto *_t = static_cast<QCPAbstractLegendItem *>(_o);
3329
        Q_UNUSED(_t)
3330
        void *_v = _a[0];
3331
        switch (_id) {
3332
        case 0: *reinterpret_cast< QCPLegend**>(_v) = _t->parentLegend(); break;
3333
        case 1: *reinterpret_cast< QFont*>(_v) = _t->font(); break;
3334
        case 2: *reinterpret_cast< QColor*>(_v) = _t->textColor(); break;
3335
        case 3: *reinterpret_cast< QFont*>(_v) = _t->selectedFont(); break;
3336
        case 4: *reinterpret_cast< QColor*>(_v) = _t->selectedTextColor(); break;
3337
        case 5: *reinterpret_cast< bool*>(_v) = _t->selectable(); break;
3338
        case 6: *reinterpret_cast< bool*>(_v) = _t->selected(); break;
3339
        default: break;
3340
        }
3341
    } else if (_c == QMetaObject::WriteProperty) {
3342
        auto *_t = static_cast<QCPAbstractLegendItem *>(_o);
3343
        Q_UNUSED(_t)
3344
        void *_v = _a[0];
3345
        switch (_id) {
3346
        case 1: _t->setFont(*reinterpret_cast< QFont*>(_v)); break;
3347
        case 2: _t->setTextColor(*reinterpret_cast< QColor*>(_v)); break;
3348
        case 3: _t->setSelectedFont(*reinterpret_cast< QFont*>(_v)); break;
3349
        case 4: _t->setSelectedTextColor(*reinterpret_cast< QColor*>(_v)); break;
3350
        case 5: _t->setSelectable(*reinterpret_cast< bool*>(_v)); break;
3351
        case 6: _t->setSelected(*reinterpret_cast< bool*>(_v)); break;
3352
        default: break;
3353
        }
3354
    } else if (_c == QMetaObject::ResetProperty) {
3355
    }
3356
#endif // QT_NO_PROPERTIES
3357
}
3358
3359
QT_INIT_METAOBJECT const QMetaObject QCPAbstractLegendItem::staticMetaObject = { {
3360
    &QCPLayoutElement::staticMetaObject,
3361
    qt_meta_stringdata_QCPAbstractLegendItem.data,
3362
    qt_meta_data_QCPAbstractLegendItem,
3363
    qt_static_metacall,
3364
    nullptr,
3365
    nullptr
3366
} };
3367
3368
3369
const QMetaObject *QCPAbstractLegendItem::metaObject() const
3370
{
3371
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
3372
}
3373
3374
void *QCPAbstractLegendItem::qt_metacast(const char *_clname)
3375
{
3376
    if (!_clname) return nullptr;
3377
    if (!strcmp(_clname, qt_meta_stringdata_QCPAbstractLegendItem.stringdata0))
3378
        return static_cast<void*>(this);
3379
    return QCPLayoutElement::qt_metacast(_clname);
3380
}
3381
3382
int QCPAbstractLegendItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
3383
{
3384
    _id = QCPLayoutElement::qt_metacall(_c, _id, _a);
3385
    if (_id < 0)
3386
        return _id;
3387
    if (_c == QMetaObject::InvokeMetaMethod) {
3388
        if (_id < 4)
3389
            qt_static_metacall(this, _c, _id, _a);
3390
        _id -= 4;
3391
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
3392
        if (_id < 4)
3393
            *reinterpret_cast<int*>(_a[0]) = -1;
3394
        _id -= 4;
3395
    }
3396
#ifndef QT_NO_PROPERTIES
3397
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
3398
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
3399
        qt_static_metacall(this, _c, _id, _a);
3400
        _id -= 7;
3401
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
3402
        _id -= 7;
3403
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
3404
        _id -= 7;
3405
    } else if (_c == QMetaObject::QueryPropertyStored) {
3406
        _id -= 7;
3407
    } else if (_c == QMetaObject::QueryPropertyEditable) {
3408
        _id -= 7;
3409
    } else if (_c == QMetaObject::QueryPropertyUser) {
3410
        _id -= 7;
3411
    }
3412
#endif // QT_NO_PROPERTIES
3413
    return _id;
3414
}
3415
3416
// SIGNAL 0
3417
void QCPAbstractLegendItem::selectionChanged(bool _t1)
3418
{
3419
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
3420
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
3421
}
3422
3423
// SIGNAL 1
3424
void QCPAbstractLegendItem::selectableChanged(bool _t1)
3425
{
3426
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
3427
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
3428
}
3429
struct qt_meta_stringdata_QCPPlottableLegendItem_t {
3430
    QByteArrayData data[1];
3431
    char stringdata0[23];
3432
};
3433
#define QT_MOC_LITERAL(idx, ofs, len) \
3434
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
3435
    qptrdiff(offsetof(qt_meta_stringdata_QCPPlottableLegendItem_t, stringdata0) + ofs \
3436
        - idx * sizeof(QByteArrayData)) \
3437
    )
3438
static const qt_meta_stringdata_QCPPlottableLegendItem_t qt_meta_stringdata_QCPPlottableLegendItem = {
3439
    {
3440
QT_MOC_LITERAL(0, 0, 22) // "QCPPlottableLegendItem"
3441
3442
    },
3443
    "QCPPlottableLegendItem"
3444
};
3445
#undef QT_MOC_LITERAL
3446
3447
static const uint qt_meta_data_QCPPlottableLegendItem[] = {
3448
3449
 // content:
3450
       8,       // revision
3451
       0,       // classname
3452
       0,    0, // classinfo
3453
       0,    0, // methods
3454
       0,    0, // properties
3455
       0,    0, // enums/sets
3456
       0,    0, // constructors
3457
       0,       // flags
3458
       0,       // signalCount
3459
3460
       0        // eod
3461
};
3462
3463
void QCPPlottableLegendItem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
3464
{
3465
    Q_UNUSED(_o);
3466
    Q_UNUSED(_id);
3467
    Q_UNUSED(_c);
3468
    Q_UNUSED(_a);
3469
}
3470
3471
QT_INIT_METAOBJECT const QMetaObject QCPPlottableLegendItem::staticMetaObject = { {
3472
    &QCPAbstractLegendItem::staticMetaObject,
3473
    qt_meta_stringdata_QCPPlottableLegendItem.data,
3474
    qt_meta_data_QCPPlottableLegendItem,
3475
    qt_static_metacall,
3476
    nullptr,
3477
    nullptr
3478
} };
3479
3480
3481
const QMetaObject *QCPPlottableLegendItem::metaObject() const
3482
{
3483
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
3484
}
3485
3486
void *QCPPlottableLegendItem::qt_metacast(const char *_clname)
3487
{
3488
    if (!_clname) return nullptr;
3489
    if (!strcmp(_clname, qt_meta_stringdata_QCPPlottableLegendItem.stringdata0))
3490
        return static_cast<void*>(this);
3491
    return QCPAbstractLegendItem::qt_metacast(_clname);
3492
}
3493
3494
int QCPPlottableLegendItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
3495
{
3496
    _id = QCPAbstractLegendItem::qt_metacall(_c, _id, _a);
3497
    return _id;
3498
}
3499
struct qt_meta_stringdata_QCPLegend_t {
3500
    QByteArrayData data[27];
3501
    char stringdata0[358];
3502
};
3503
#define QT_MOC_LITERAL(idx, ofs, len) \
3504
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
3505
    qptrdiff(offsetof(qt_meta_stringdata_QCPLegend_t, stringdata0) + ofs \
3506
        - idx * sizeof(QByteArrayData)) \
3507
    )
3508
static const qt_meta_stringdata_QCPLegend_t qt_meta_stringdata_QCPLegend = {
3509
    {
3510
QT_MOC_LITERAL(0, 0, 9), // "QCPLegend"
3511
QT_MOC_LITERAL(1, 10, 16), // "selectionChanged"
3512
QT_MOC_LITERAL(2, 27, 0), // ""
3513
QT_MOC_LITERAL(3, 28, 26), // "QCPLegend::SelectableParts"
3514
QT_MOC_LITERAL(4, 55, 5), // "parts"
3515
QT_MOC_LITERAL(5, 61, 17), // "selectableChanged"
3516
QT_MOC_LITERAL(6, 79, 18), // "setSelectableParts"
3517
QT_MOC_LITERAL(7, 98, 15), // "SelectableParts"
3518
QT_MOC_LITERAL(8, 114, 15), // "selectableParts"
3519
QT_MOC_LITERAL(9, 130, 16), // "setSelectedParts"
3520
QT_MOC_LITERAL(10, 147, 13), // "selectedParts"
3521
QT_MOC_LITERAL(11, 161, 9), // "borderPen"
3522
QT_MOC_LITERAL(12, 171, 5), // "brush"
3523
QT_MOC_LITERAL(13, 177, 4), // "font"
3524
QT_MOC_LITERAL(14, 182, 9), // "textColor"
3525
QT_MOC_LITERAL(15, 192, 8), // "iconSize"
3526
QT_MOC_LITERAL(16, 201, 15), // "iconTextPadding"
3527
QT_MOC_LITERAL(17, 217, 13), // "iconBorderPen"
3528
QT_MOC_LITERAL(18, 231, 17), // "selectedBorderPen"
3529
QT_MOC_LITERAL(19, 249, 21), // "selectedIconBorderPen"
3530
QT_MOC_LITERAL(20, 271, 13), // "selectedBrush"
3531
QT_MOC_LITERAL(21, 285, 12), // "selectedFont"
3532
QT_MOC_LITERAL(22, 298, 17), // "selectedTextColor"
3533
QT_MOC_LITERAL(23, 316, 14), // "SelectablePart"
3534
QT_MOC_LITERAL(24, 331, 6), // "spNone"
3535
QT_MOC_LITERAL(25, 338, 11), // "spLegendBox"
3536
QT_MOC_LITERAL(26, 350, 7) // "spItems"
3537
3538
    },
3539
    "QCPLegend\0selectionChanged\0\0"
3540
    "QCPLegend::SelectableParts\0parts\0"
3541
    "selectableChanged\0setSelectableParts\0"
3542
    "SelectableParts\0selectableParts\0"
3543
    "setSelectedParts\0selectedParts\0borderPen\0"
3544
    "brush\0font\0textColor\0iconSize\0"
3545
    "iconTextPadding\0iconBorderPen\0"
3546
    "selectedBorderPen\0selectedIconBorderPen\0"
3547
    "selectedBrush\0selectedFont\0selectedTextColor\0"
3548
    "SelectablePart\0spNone\0spLegendBox\0"
3549
    "spItems"
3550
};
3551
#undef QT_MOC_LITERAL
3552
3553
static const uint qt_meta_data_QCPLegend[] = {
3554
3555
 // content:
3556
       8,       // revision
3557
       0,       // classname
3558
       0,    0, // classinfo
3559
       4,   14, // methods
3560
      14,   46, // properties
3561
       2,  102, // enums/sets
3562
       0,    0, // constructors
3563
       0,       // flags
3564
       2,       // signalCount
3565
3566
 // signals: name, argc, parameters, tag, flags
3567
       1,    1,   34,    2, 0x06 /* Public */,
3568
       5,    1,   37,    2, 0x06 /* Public */,
3569
3570
 // slots: name, argc, parameters, tag, flags
3571
       6,    1,   40,    2, 0x0a /* Public */,
3572
       9,    1,   43,    2, 0x0a /* Public */,
3573
3574
 // signals: parameters
3575
    QMetaType::Void, 0x80000000 | 3,    4,
3576
    QMetaType::Void, 0x80000000 | 3,    4,
3577
3578
 // slots: parameters
3579
    QMetaType::Void, 0x80000000 | 7,    8,
3580
    QMetaType::Void, 0x80000000 | 7,   10,
3581
3582
 // properties: name, type, flags
3583
      11, QMetaType::QPen, 0x00095103,
3584
      12, QMetaType::QBrush, 0x00095103,
3585
      13, QMetaType::QFont, 0x00095103,
3586
      14, QMetaType::QColor, 0x00095103,
3587
      15, QMetaType::QSize, 0x00095103,
3588
      16, QMetaType::Int, 0x00095103,
3589
      17, QMetaType::QPen, 0x00095103,
3590
       8, 0x80000000 | 7, 0x0049510b,
3591
      10, 0x80000000 | 7, 0x0049510b,
3592
      18, QMetaType::QPen, 0x00095103,
3593
      19, QMetaType::QPen, 0x00095103,
3594
      20, QMetaType::QBrush, 0x00095103,
3595
      21, QMetaType::QFont, 0x00095103,
3596
      22, QMetaType::QColor, 0x00095103,
3597
3598
 // properties: notify_signal_id
3599
       0,
3600
       0,
3601
       0,
3602
       0,
3603
       0,
3604
       0,
3605
       0,
3606
       0,
3607
       1,
3608
       0,
3609
       0,
3610
       0,
3611
       0,
3612
       0,
3613
3614
 // enums: name, alias, flags, count, data
3615
      23,   23, 0x1,    3,  112,
3616
       7,   23, 0x1,    3,  118,
3617
3618
 // enum data: key, value
3619
      24, uint(QCPLegend::spNone),
3620
      25, uint(QCPLegend::spLegendBox),
3621
      26, uint(QCPLegend::spItems),
3622
      24, uint(QCPLegend::spNone),
3623
      25, uint(QCPLegend::spLegendBox),
3624
      26, uint(QCPLegend::spItems),
3625
3626
       0        // eod
3627
};
3628
3629
void QCPLegend::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
3630
{
3631
    if (_c == QMetaObject::InvokeMetaMethod) {
3632
        auto *_t = static_cast<QCPLegend *>(_o);
3633
        Q_UNUSED(_t)
3634
        switch (_id) {
3635
        case 0: _t->selectionChanged((*reinterpret_cast< QCPLegend::SelectableParts(*)>(_a[1]))); break;
3636
        case 1: _t->selectableChanged((*reinterpret_cast< QCPLegend::SelectableParts(*)>(_a[1]))); break;
3637
        case 2: _t->setSelectableParts((*reinterpret_cast< const SelectableParts(*)>(_a[1]))); break;
3638
        case 3: _t->setSelectedParts((*reinterpret_cast< const SelectableParts(*)>(_a[1]))); break;
3639
        default: ;
3640
        }
3641
    } else if (_c == QMetaObject::IndexOfMethod) {
3642
        int *result = reinterpret_cast<int *>(_a[0]);
3643
        {
3644
            using _t = void (QCPLegend::*)(QCPLegend::SelectableParts );
3645
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPLegend::selectionChanged)) {
3646
                *result = 0;
3647
                return;
3648
            }
3649
        }
3650
        {
3651
            using _t = void (QCPLegend::*)(QCPLegend::SelectableParts );
3652
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPLegend::selectableChanged)) {
3653
                *result = 1;
3654
                return;
3655
            }
3656
        }
3657
    }
3658
#ifndef QT_NO_PROPERTIES
3659
    else if (_c == QMetaObject::ReadProperty) {
3660
        auto *_t = static_cast<QCPLegend *>(_o);
3661
        Q_UNUSED(_t)
3662
        void *_v = _a[0];
3663
        switch (_id) {
3664
        case 0: *reinterpret_cast< QPen*>(_v) = _t->borderPen(); break;
3665
        case 1: *reinterpret_cast< QBrush*>(_v) = _t->brush(); break;
3666
        case 2: *reinterpret_cast< QFont*>(_v) = _t->font(); break;
3667
        case 3: *reinterpret_cast< QColor*>(_v) = _t->textColor(); break;
3668
        case 4: *reinterpret_cast< QSize*>(_v) = _t->iconSize(); break;
3669
        case 5: *reinterpret_cast< int*>(_v) = _t->iconTextPadding(); break;
3670
        case 6: *reinterpret_cast< QPen*>(_v) = _t->iconBorderPen(); break;
3671
        case 7: *reinterpret_cast<int*>(_v) = QFlag(_t->selectableParts()); break;
3672
        case 8: *reinterpret_cast<int*>(_v) = QFlag(_t->selectedParts()); break;
3673
        case 9: *reinterpret_cast< QPen*>(_v) = _t->selectedBorderPen(); break;
3674
        case 10: *reinterpret_cast< QPen*>(_v) = _t->selectedIconBorderPen(); break;
3675
        case 11: *reinterpret_cast< QBrush*>(_v) = _t->selectedBrush(); break;
3676
        case 12: *reinterpret_cast< QFont*>(_v) = _t->selectedFont(); break;
3677
        case 13: *reinterpret_cast< QColor*>(_v) = _t->selectedTextColor(); break;
3678
        default: break;
3679
        }
3680
    } else if (_c == QMetaObject::WriteProperty) {
3681
        auto *_t = static_cast<QCPLegend *>(_o);
3682
        Q_UNUSED(_t)
3683
        void *_v = _a[0];
3684
        switch (_id) {
3685
        case 0: _t->setBorderPen(*reinterpret_cast< QPen*>(_v)); break;
3686
        case 1: _t->setBrush(*reinterpret_cast< QBrush*>(_v)); break;
3687
        case 2: _t->setFont(*reinterpret_cast< QFont*>(_v)); break;
3688
        case 3: _t->setTextColor(*reinterpret_cast< QColor*>(_v)); break;
3689
        case 4: _t->setIconSize(*reinterpret_cast< QSize*>(_v)); break;
3690
        case 5: _t->setIconTextPadding(*reinterpret_cast< int*>(_v)); break;
3691
        case 6: _t->setIconBorderPen(*reinterpret_cast< QPen*>(_v)); break;
3692
        case 7: _t->setSelectableParts(QFlag(*reinterpret_cast<int*>(_v))); break;
3693
        case 8: _t->setSelectedParts(QFlag(*reinterpret_cast<int*>(_v))); break;
3694
        case 9: _t->setSelectedBorderPen(*reinterpret_cast< QPen*>(_v)); break;
3695
        case 10: _t->setSelectedIconBorderPen(*reinterpret_cast< QPen*>(_v)); break;
3696
        case 11: _t->setSelectedBrush(*reinterpret_cast< QBrush*>(_v)); break;
3697
        case 12: _t->setSelectedFont(*reinterpret_cast< QFont*>(_v)); break;
3698
        case 13: _t->setSelectedTextColor(*reinterpret_cast< QColor*>(_v)); break;
3699
        default: break;
3700
        }
3701
    } else if (_c == QMetaObject::ResetProperty) {
3702
    }
3703
#endif // QT_NO_PROPERTIES
3704
}
3705
3706
QT_INIT_METAOBJECT const QMetaObject QCPLegend::staticMetaObject = { {
3707
    &QCPLayoutGrid::staticMetaObject,
3708
    qt_meta_stringdata_QCPLegend.data,
3709
    qt_meta_data_QCPLegend,
3710
    qt_static_metacall,
3711
    nullptr,
3712
    nullptr
3713
} };
3714
3715
3716
const QMetaObject *QCPLegend::metaObject() const
3717
{
3718
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
3719
}
3720
3721
void *QCPLegend::qt_metacast(const char *_clname)
3722
{
3723
    if (!_clname) return nullptr;
3724
    if (!strcmp(_clname, qt_meta_stringdata_QCPLegend.stringdata0))
3725
        return static_cast<void*>(this);
3726
    return QCPLayoutGrid::qt_metacast(_clname);
3727
}
3728
3729
int QCPLegend::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
3730
{
3731
    _id = QCPLayoutGrid::qt_metacall(_c, _id, _a);
3732
    if (_id < 0)
3733
        return _id;
3734
    if (_c == QMetaObject::InvokeMetaMethod) {
3735
        if (_id < 4)
3736
            qt_static_metacall(this, _c, _id, _a);
3737
        _id -= 4;
3738
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
3739
        if (_id < 4)
3740
            *reinterpret_cast<int*>(_a[0]) = -1;
3741
        _id -= 4;
3742
    }
3743
#ifndef QT_NO_PROPERTIES
3744
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
3745
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {