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) {
3746
        qt_static_metacall(this, _c, _id, _a);
3747
        _id -= 14;
3748
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
3749
        _id -= 14;
3750
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
3751
        _id -= 14;
3752
    } else if (_c == QMetaObject::QueryPropertyStored) {
3753
        _id -= 14;
3754
    } else if (_c == QMetaObject::QueryPropertyEditable) {
3755
        _id -= 14;
3756
    } else if (_c == QMetaObject::QueryPropertyUser) {
3757
        _id -= 14;
3758
    }
3759
#endif // QT_NO_PROPERTIES
3760
    return _id;
3761
}
3762
3763
// SIGNAL 0
3764
void QCPLegend::selectionChanged(QCPLegend::SelectableParts _t1)
3765
{
3766
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
3767
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
3768
}
3769
3770
// SIGNAL 1
3771
void QCPLegend::selectableChanged(QCPLegend::SelectableParts _t1)
3772
{
3773
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
3774
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
3775
}
3776
struct qt_meta_stringdata_QCPPlotTitle_t {
3777
    QByteArrayData data[13];
3778
    char stringdata0[146];
3779
};
3780
#define QT_MOC_LITERAL(idx, ofs, len) \
3781
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
3782
    qptrdiff(offsetof(qt_meta_stringdata_QCPPlotTitle_t, stringdata0) + ofs \
3783
        - idx * sizeof(QByteArrayData)) \
3784
    )
3785
static const qt_meta_stringdata_QCPPlotTitle_t qt_meta_stringdata_QCPPlotTitle = {
3786
    {
3787
QT_MOC_LITERAL(0, 0, 12), // "QCPPlotTitle"
3788
QT_MOC_LITERAL(1, 13, 16), // "selectionChanged"
3789
QT_MOC_LITERAL(2, 30, 0), // ""
3790
QT_MOC_LITERAL(3, 31, 8), // "selected"
3791
QT_MOC_LITERAL(4, 40, 17), // "selectableChanged"
3792
QT_MOC_LITERAL(5, 58, 10), // "selectable"
3793
QT_MOC_LITERAL(6, 69, 13), // "setSelectable"
3794
QT_MOC_LITERAL(7, 83, 11), // "setSelected"
3795
QT_MOC_LITERAL(8, 95, 4), // "text"
3796
QT_MOC_LITERAL(9, 100, 4), // "font"
3797
QT_MOC_LITERAL(10, 105, 9), // "textColor"
3798
QT_MOC_LITERAL(11, 115, 12), // "selectedFont"
3799
QT_MOC_LITERAL(12, 128, 17) // "selectedTextColor"
3800
3801
    },
3802
    "QCPPlotTitle\0selectionChanged\0\0selected\0"
3803
    "selectableChanged\0selectable\0setSelectable\0"
3804
    "setSelected\0text\0font\0textColor\0"
3805
    "selectedFont\0selectedTextColor"
3806
};
3807
#undef QT_MOC_LITERAL
3808
3809
static const uint qt_meta_data_QCPPlotTitle[] = {
3810
3811
 // content:
3812
       8,       // revision
3813
       0,       // classname
3814
       0,    0, // classinfo
3815
       4,   14, // methods
3816
       7,   46, // properties
3817
       0,    0, // enums/sets
3818
       0,    0, // constructors
3819
       0,       // flags
3820
       2,       // signalCount
3821
3822
 // signals: name, argc, parameters, tag, flags
3823
       1,    1,   34,    2, 0x06 /* Public */,
3824
       4,    1,   37,    2, 0x06 /* Public */,
3825
3826
 // slots: name, argc, parameters, tag, flags
3827
       6,    1,   40,    2, 0x0a /* Public */,
3828
       7,    1,   43,    2, 0x0a /* Public */,
3829
3830
 // signals: parameters
3831
    QMetaType::Void, QMetaType::Bool,    3,
3832
    QMetaType::Void, QMetaType::Bool,    5,
3833
3834
 // slots: parameters
3835
    QMetaType::Void, QMetaType::Bool,    5,
3836
    QMetaType::Void, QMetaType::Bool,    3,
3837
3838
 // properties: name, type, flags
3839
       8, QMetaType::QString, 0x00095103,
3840
       9, QMetaType::QFont, 0x00095103,
3841
      10, QMetaType::QColor, 0x00095103,
3842
      11, QMetaType::QFont, 0x00095103,
3843
      12, QMetaType::QColor, 0x00095103,
3844
       5, QMetaType::Bool, 0x00495103,
3845
       3, QMetaType::Bool, 0x00495103,
3846
3847
 // properties: notify_signal_id
3848
       0,
3849
       0,
3850
       0,
3851
       0,
3852
       0,
3853
       1,
3854
       0,
3855
3856
       0        // eod
3857
};
3858
3859
void QCPPlotTitle::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
3860
{
3861
    if (_c == QMetaObject::InvokeMetaMethod) {
3862
        auto *_t = static_cast<QCPPlotTitle *>(_o);
3863
        Q_UNUSED(_t)
3864
        switch (_id) {
3865
        case 0: _t->selectionChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
3866
        case 1: _t->selectableChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
3867
        case 2: _t->setSelectable((*reinterpret_cast< bool(*)>(_a[1]))); break;
3868
        case 3: _t->setSelected((*reinterpret_cast< bool(*)>(_a[1]))); break;
3869
        default: ;
3870
        }
3871
    } else if (_c == QMetaObject::IndexOfMethod) {
3872
        int *result = reinterpret_cast<int *>(_a[0]);
3873
        {
3874
            using _t = void (QCPPlotTitle::*)(bool );
3875
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPPlotTitle::selectionChanged)) {
3876
                *result = 0;
3877
                return;
3878
            }
3879
        }
3880
        {
3881
            using _t = void (QCPPlotTitle::*)(bool );
3882
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPPlotTitle::selectableChanged)) {
3883
                *result = 1;
3884
                return;
3885
            }
3886
        }
3887
    }
3888
#ifndef QT_NO_PROPERTIES
3889
    else if (_c == QMetaObject::ReadProperty) {
3890
        auto *_t = static_cast<QCPPlotTitle *>(_o);
3891
        Q_UNUSED(_t)
3892
        void *_v = _a[0];
3893
        switch (_id) {
3894
        case 0: *reinterpret_cast< QString*>(_v) = _t->text(); break;
3895
        case 1: *reinterpret_cast< QFont*>(_v) = _t->font(); break;
3896
        case 2: *reinterpret_cast< QColor*>(_v) = _t->textColor(); break;
3897
        case 3: *reinterpret_cast< QFont*>(_v) = _t->selectedFont(); break;
3898
        case 4: *reinterpret_cast< QColor*>(_v) = _t->selectedTextColor(); break;
3899
        case 5: *reinterpret_cast< bool*>(_v) = _t->selectable(); break;
3900
        case 6: *reinterpret_cast< bool*>(_v) = _t->selected(); break;
3901
        default: break;
3902
        }
3903
    } else if (_c == QMetaObject::WriteProperty) {
3904
        auto *_t = static_cast<QCPPlotTitle *>(_o);
3905
        Q_UNUSED(_t)
3906
        void *_v = _a[0];
3907
        switch (_id) {
3908
        case 0: _t->setText(*reinterpret_cast< QString*>(_v)); break;
3909
        case 1: _t->setFont(*reinterpret_cast< QFont*>(_v)); break;
3910
        case 2: _t->setTextColor(*reinterpret_cast< QColor*>(_v)); break;
3911
        case 3: _t->setSelectedFont(*reinterpret_cast< QFont*>(_v)); break;
3912
        case 4: _t->setSelectedTextColor(*reinterpret_cast< QColor*>(_v)); break;
3913
        case 5: _t->setSelectable(*reinterpret_cast< bool*>(_v)); break;
3914
        case 6: _t->setSelected(*reinterpret_cast< bool*>(_v)); break;
3915
        default: break;
3916
        }
3917
    } else if (_c == QMetaObject::ResetProperty) {
3918
    }
3919
#endif // QT_NO_PROPERTIES
3920
}
3921
3922
QT_INIT_METAOBJECT const QMetaObject QCPPlotTitle::staticMetaObject = { {
3923
    &QCPLayoutElement::staticMetaObject,
3924
    qt_meta_stringdata_QCPPlotTitle.data,
3925
    qt_meta_data_QCPPlotTitle,
3926
    qt_static_metacall,
3927
    nullptr,
3928
    nullptr
3929
} };
3930
3931
3932
const QMetaObject *QCPPlotTitle::metaObject() const
3933
{
3934
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
3935
}
3936
3937
void *QCPPlotTitle::qt_metacast(const char *_clname)
3938
{
3939
    if (!_clname) return nullptr;
3940
    if (!strcmp(_clname, qt_meta_stringdata_QCPPlotTitle.stringdata0))
3941
        return static_cast<void*>(this);
3942
    return QCPLayoutElement::qt_metacast(_clname);
3943
}
3944
3945
int QCPPlotTitle::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
3946
{
3947
    _id = QCPLayoutElement::qt_metacall(_c, _id, _a);
3948
    if (_id < 0)
3949
        return _id;
3950
    if (_c == QMetaObject::InvokeMetaMethod) {
3951
        if (_id < 4)
3952
            qt_static_metacall(this, _c, _id, _a);
3953
        _id -= 4;
3954
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
3955
        if (_id < 4)
3956
            *reinterpret_cast<int*>(_a[0]) = -1;
3957
        _id -= 4;
3958
    }
3959
#ifndef QT_NO_PROPERTIES
3960
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
3961
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
3962
        qt_static_metacall(this, _c, _id, _a);
3963
        _id -= 7;
3964
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
3965
        _id -= 7;
3966
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
3967
        _id -= 7;
3968
    } else if (_c == QMetaObject::QueryPropertyStored) {
3969
        _id -= 7;
3970
    } else if (_c == QMetaObject::QueryPropertyEditable) {
3971
        _id -= 7;
3972
    } else if (_c == QMetaObject::QueryPropertyUser) {
3973
        _id -= 7;
3974
    }
3975
#endif // QT_NO_PROPERTIES
3976
    return _id;
3977
}
3978
3979
// SIGNAL 0
3980
void QCPPlotTitle::selectionChanged(bool _t1)
3981
{
3982
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
3983
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
3984
}
3985
3986
// SIGNAL 1
3987
void QCPPlotTitle::selectableChanged(bool _t1)
3988
{
3989
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
3990
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
3991
}
3992
struct qt_meta_stringdata_QCPColorScaleAxisRectPrivate_t {
3993
    QByteArrayData data[7];
3994
    char stringdata0[128];
3995
};
3996
#define QT_MOC_LITERAL(idx, ofs, len) \
3997
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
3998
    qptrdiff(offsetof(qt_meta_stringdata_QCPColorScaleAxisRectPrivate_t, stringdata0) + ofs \
3999
        - idx * sizeof(QByteArrayData)) \
4000
    )
4001
static const qt_meta_stringdata_QCPColorScaleAxisRectPrivate_t qt_meta_stringdata_QCPColorScaleAxisRectPrivate = {
4002
    {
4003
QT_MOC_LITERAL(0, 0, 28), // "QCPColorScaleAxisRectPrivate"
4004
QT_MOC_LITERAL(1, 29, 20), // "axisSelectionChanged"
4005
QT_MOC_LITERAL(2, 50, 0), // ""
4006
QT_MOC_LITERAL(3, 51, 24), // "QCPAxis::SelectableParts"
4007
QT_MOC_LITERAL(4, 76, 13), // "selectedParts"
4008
QT_MOC_LITERAL(5, 90, 21), // "axisSelectableChanged"
4009
QT_MOC_LITERAL(6, 112, 15) // "selectableParts"
4010
4011
    },
4012
    "QCPColorScaleAxisRectPrivate\0"
4013
    "axisSelectionChanged\0\0QCPAxis::SelectableParts\0"
4014
    "selectedParts\0axisSelectableChanged\0"
4015
    "selectableParts"
4016
};
4017
#undef QT_MOC_LITERAL
4018
4019
static const uint qt_meta_data_QCPColorScaleAxisRectPrivate[] = {
4020
4021
 // content:
4022
       8,       // revision
4023
       0,       // classname
4024
       0,    0, // classinfo
4025
       2,   14, // methods
4026
       0,    0, // properties
4027
       0,    0, // enums/sets
4028
       0,    0, // constructors
4029
       0,       // flags
4030
       0,       // signalCount
4031
4032
 // slots: name, argc, parameters, tag, flags
4033
       1,    1,   24,    2, 0x09 /* Protected */,
4034
       5,    1,   27,    2, 0x09 /* Protected */,
4035
4036
 // slots: parameters
4037
    QMetaType::Void, 0x80000000 | 3,    4,
4038
    QMetaType::Void, 0x80000000 | 3,    6,
4039
4040
       0        // eod
4041
};
4042
4043
void QCPColorScaleAxisRectPrivate::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
4044
{
4045
    if (_c == QMetaObject::InvokeMetaMethod) {
4046
        auto *_t = static_cast<QCPColorScaleAxisRectPrivate *>(_o);
4047
        Q_UNUSED(_t)
4048
        switch (_id) {
4049
        case 0: _t->axisSelectionChanged((*reinterpret_cast< QCPAxis::SelectableParts(*)>(_a[1]))); break;
4050
        case 1: _t->axisSelectableChanged((*reinterpret_cast< QCPAxis::SelectableParts(*)>(_a[1]))); break;
4051
        default: ;
4052
        }
4053
    }
4054
}
4055
4056
QT_INIT_METAOBJECT const QMetaObject QCPColorScaleAxisRectPrivate::staticMetaObject = { {
4057
    &QCPAxisRect::staticMetaObject,
4058
    qt_meta_stringdata_QCPColorScaleAxisRectPrivate.data,
4059
    qt_meta_data_QCPColorScaleAxisRectPrivate,
4060
    qt_static_metacall,
4061
    nullptr,
4062
    nullptr
4063
} };
4064
4065
4066
const QMetaObject *QCPColorScaleAxisRectPrivate::metaObject() const
4067
{
4068
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
4069
}
4070
4071
void *QCPColorScaleAxisRectPrivate::qt_metacast(const char *_clname)
4072
{
4073
    if (!_clname) return nullptr;
4074
    if (!strcmp(_clname, qt_meta_stringdata_QCPColorScaleAxisRectPrivate.stringdata0))
4075
        return static_cast<void*>(this);
4076
    return QCPAxisRect::qt_metacast(_clname);
4077
}
4078
4079
int QCPColorScaleAxisRectPrivate::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
4080
{
4081
    _id = QCPAxisRect::qt_metacall(_c, _id, _a);
4082
    if (_id < 0)
4083
        return _id;
4084
    if (_c == QMetaObject::InvokeMetaMethod) {
4085
        if (_id < 2)
4086
            qt_static_metacall(this, _c, _id, _a);
4087
        _id -= 2;
4088
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
4089
        if (_id < 2)
4090
            *reinterpret_cast<int*>(_a[0]) = -1;
4091
        _id -= 2;
4092
    }
4093
    return _id;
4094
}
4095
struct qt_meta_stringdata_QCPColorScale_t {
4096
    QByteArrayData data[23];
4097
    char stringdata0[278];
4098
};
4099
#define QT_MOC_LITERAL(idx, ofs, len) \
4100
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
4101
    qptrdiff(offsetof(qt_meta_stringdata_QCPColorScale_t, stringdata0) + ofs \
4102
        - idx * sizeof(QByteArrayData)) \
4103
    )
4104
static const qt_meta_stringdata_QCPColorScale_t qt_meta_stringdata_QCPColorScale = {
4105
    {
4106
QT_MOC_LITERAL(0, 0, 13), // "QCPColorScale"
4107
QT_MOC_LITERAL(1, 14, 16), // "dataRangeChanged"
4108
QT_MOC_LITERAL(2, 31, 0), // ""
4109
QT_MOC_LITERAL(3, 32, 8), // "QCPRange"
4110
QT_MOC_LITERAL(4, 41, 8), // "newRange"
4111
QT_MOC_LITERAL(5, 50, 20), // "dataScaleTypeChanged"
4112
QT_MOC_LITERAL(6, 71, 18), // "QCPAxis::ScaleType"
4113
QT_MOC_LITERAL(7, 90, 9), // "scaleType"
4114
QT_MOC_LITERAL(8, 100, 15), // "gradientChanged"
4115
QT_MOC_LITERAL(9, 116, 16), // "QCPColorGradient"
4116
QT_MOC_LITERAL(10, 133, 11), // "newGradient"
4117
QT_MOC_LITERAL(11, 145, 12), // "setDataRange"
4118
QT_MOC_LITERAL(12, 158, 9), // "dataRange"
4119
QT_MOC_LITERAL(13, 168, 16), // "setDataScaleType"
4120
QT_MOC_LITERAL(14, 185, 11), // "setGradient"
4121
QT_MOC_LITERAL(15, 197, 8), // "gradient"
4122
QT_MOC_LITERAL(16, 206, 4), // "type"
4123
QT_MOC_LITERAL(17, 211, 17), // "QCPAxis::AxisType"
4124
QT_MOC_LITERAL(18, 229, 13), // "dataScaleType"
4125
QT_MOC_LITERAL(19, 243, 5), // "label"
4126
QT_MOC_LITERAL(20, 249, 8), // "barWidth"
4127
QT_MOC_LITERAL(21, 258, 9), // "rangeDrag"
4128
QT_MOC_LITERAL(22, 268, 9) // "rangeZoom"
4129
4130
    },
4131
    "QCPColorScale\0dataRangeChanged\0\0"
4132
    "QCPRange\0newRange\0dataScaleTypeChanged\0"
4133
    "QCPAxis::ScaleType\0scaleType\0"
4134
    "gradientChanged\0QCPColorGradient\0"
4135
    "newGradient\0setDataRange\0dataRange\0"
4136
    "setDataScaleType\0setGradient\0gradient\0"
4137
    "type\0QCPAxis::AxisType\0dataScaleType\0"
4138
    "label\0barWidth\0rangeDrag\0rangeZoom"
4139
};
4140
#undef QT_MOC_LITERAL
4141
4142
static const uint qt_meta_data_QCPColorScale[] = {
4143
4144
 // content:
4145
       8,       // revision
4146
       0,       // classname
4147
       0,    0, // classinfo
4148
       6,   14, // methods
4149
       8,   62, // properties
4150
       0,    0, // enums/sets
4151
       0,    0, // constructors
4152
       0,       // flags
4153
       3,       // signalCount
4154
4155
 // signals: name, argc, parameters, tag, flags
4156
       1,    1,   44,    2, 0x06 /* Public */,
4157
       5,    1,   47,    2, 0x06 /* Public */,
4158
       8,    1,   50,    2, 0x06 /* Public */,
4159
4160
 // slots: name, argc, parameters, tag, flags
4161
      11,    1,   53,    2, 0x0a /* Public */,
4162
      13,    1,   56,    2, 0x0a /* Public */,
4163
      14,    1,   59,    2, 0x0a /* Public */,
4164
4165
 // signals: parameters
4166
    QMetaType::Void, 0x80000000 | 3,    4,
4167
    QMetaType::Void, 0x80000000 | 6,    7,
4168
    QMetaType::Void, 0x80000000 | 9,   10,
4169
4170
 // slots: parameters
4171
    QMetaType::Void, 0x80000000 | 3,   12,
4172
    QMetaType::Void, 0x80000000 | 6,    7,
4173
    QMetaType::Void, 0x80000000 | 9,   15,
4174
4175
 // properties: name, type, flags
4176
      16, 0x80000000 | 17, 0x0009510b,
4177
      12, 0x80000000 | 3, 0x0049510b,
4178
      18, 0x80000000 | 6, 0x0049510b,
4179
      15, 0x80000000 | 9, 0x0049510b,
4180
      19, QMetaType::QString, 0x00095103,
4181
      20, QMetaType::Int, 0x00095103,
4182
      21, QMetaType::Bool, 0x00095103,
4183
      22, QMetaType::Bool, 0x00095103,
4184
4185
 // properties: notify_signal_id
4186
       0,
4187
       0,
4188
       1,
4189
       2,
4190
       0,
4191
       0,
4192
       0,
4193
       0,
4194
4195
       0        // eod
4196
};
4197
4198
void QCPColorScale::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
4199
{
4200
    if (_c == QMetaObject::InvokeMetaMethod) {
4201
        auto *_t = static_cast<QCPColorScale *>(_o);
4202
        Q_UNUSED(_t)
4203
        switch (_id) {
4204
        case 0: _t->dataRangeChanged((*reinterpret_cast< QCPRange(*)>(_a[1]))); break;
4205
        case 1: _t->dataScaleTypeChanged((*reinterpret_cast< QCPAxis::ScaleType(*)>(_a[1]))); break;
4206
        case 2: _t->gradientChanged((*reinterpret_cast< QCPColorGradient(*)>(_a[1]))); break;
4207
        case 3: _t->setDataRange((*reinterpret_cast< const QCPRange(*)>(_a[1]))); break;
4208
        case 4: _t->setDataScaleType((*reinterpret_cast< QCPAxis::ScaleType(*)>(_a[1]))); break;
4209
        case 5: _t->setGradient((*reinterpret_cast< const QCPColorGradient(*)>(_a[1]))); break;
4210
        default: ;
4211
        }
4212
    } else if (_c == QMetaObject::IndexOfMethod) {
4213
        int *result = reinterpret_cast<int *>(_a[0]);
4214
        {
4215
            using _t = void (QCPColorScale::*)(QCPRange );
4216
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPColorScale::dataRangeChanged)) {
4217
                *result = 0;
4218
                return;
4219
            }
4220
        }
4221
        {
4222
            using _t = void (QCPColorScale::*)(QCPAxis::ScaleType );
4223
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPColorScale::dataScaleTypeChanged)) {
4224
                *result = 1;
4225
                return;
4226
            }
4227
        }
4228
        {
4229
            using _t = void (QCPColorScale::*)(QCPColorGradient );
4230
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPColorScale::gradientChanged)) {
4231
                *result = 2;
4232
                return;
4233
            }
4234
        }
4235
    }
4236
#ifndef QT_NO_PROPERTIES
4237
    else if (_c == QMetaObject::ReadProperty) {
4238
        auto *_t = static_cast<QCPColorScale *>(_o);
4239
        Q_UNUSED(_t)
4240
        void *_v = _a[0];
4241
        switch (_id) {
4242
        case 0: *reinterpret_cast< QCPAxis::AxisType*>(_v) = _t->type(); break;
4243
        case 1: *reinterpret_cast< QCPRange*>(_v) = _t->dataRange(); break;
4244
        case 2: *reinterpret_cast< QCPAxis::ScaleType*>(_v) = _t->dataScaleType(); break;
4245
        case 3: *reinterpret_cast< QCPColorGradient*>(_v) = _t->gradient(); break;
4246
        case 4: *reinterpret_cast< QString*>(_v) = _t->label(); break;
4247
        case 5: *reinterpret_cast< int*>(_v) = _t->barWidth(); break;
4248
        case 6: *reinterpret_cast< bool*>(_v) = _t->rangeDrag(); break;
4249
        case 7: *reinterpret_cast< bool*>(_v) = _t->rangeZoom(); break;
4250
        default: break;
4251
        }
4252
    } else if (_c == QMetaObject::WriteProperty) {
4253
        auto *_t = static_cast<QCPColorScale *>(_o);
4254
        Q_UNUSED(_t)
4255
        void *_v = _a[0];
4256
        switch (_id) {
4257
        case 0: _t->setType(*reinterpret_cast< QCPAxis::AxisType*>(_v)); break;
4258
        case 1: _t->setDataRange(*reinterpret_cast< QCPRange*>(_v)); break;
4259
        case 2: _t->setDataScaleType(*reinterpret_cast< QCPAxis::ScaleType*>(_v)); break;
4260
        case 3: _t->setGradient(*reinterpret_cast< QCPColorGradient*>(_v)); break;
4261
        case 4: _t->setLabel(*reinterpret_cast< QString*>(_v)); break;
4262
        case 5: _t->setBarWidth(*reinterpret_cast< int*>(_v)); break;
4263
        case 6: _t->setRangeDrag(*reinterpret_cast< bool*>(_v)); break;
4264
        case 7: _t->setRangeZoom(*reinterpret_cast< bool*>(_v)); break;
4265
        default: break;
4266
        }
4267
    } else if (_c == QMetaObject::ResetProperty) {
4268
    }
4269
#endif // QT_NO_PROPERTIES
4270
}
4271
4272
static const QMetaObject * const qt_meta_extradata_QCPColorScale[] = {
4273
        &QCPAxis::staticMetaObject,
4274
    nullptr
4275
};
4276
4277
QT_INIT_METAOBJECT const QMetaObject QCPColorScale::staticMetaObject = { {
4278
    &QCPLayoutElement::staticMetaObject,
4279
    qt_meta_stringdata_QCPColorScale.data,
4280
    qt_meta_data_QCPColorScale,
4281
    qt_static_metacall,
4282
    qt_meta_extradata_QCPColorScale,
4283
    nullptr
4284
} };
4285
4286
4287
const QMetaObject *QCPColorScale::metaObject() const
4288
{
4289
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
4290
}
4291
4292
void *QCPColorScale::qt_metacast(const char *_clname)
4293
{
4294
    if (!_clname) return nullptr;
4295
    if (!strcmp(_clname, qt_meta_stringdata_QCPColorScale.stringdata0))
4296
        return static_cast<void*>(this);
4297
    return QCPLayoutElement::qt_metacast(_clname);
4298
}
4299
4300
int QCPColorScale::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
4301
{
4302
    _id = QCPLayoutElement::qt_metacall(_c, _id, _a);
4303
    if (_id < 0)
4304
        return _id;
4305
    if (_c == QMetaObject::InvokeMetaMethod) {
4306
        if (_id < 6)
4307
            qt_static_metacall(this, _c, _id, _a);
4308
        _id -= 6;
4309
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
4310
        if (_id < 6)
4311
            *reinterpret_cast<int*>(_a[0]) = -1;
4312
        _id -= 6;
4313
    }
4314
#ifndef QT_NO_PROPERTIES
4315
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
4316
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
4317
        qt_static_metacall(this, _c, _id, _a);
4318
        _id -= 8;
4319
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
4320
        _id -= 8;
4321
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
4322
        _id -= 8;
4323
    } else if (_c == QMetaObject::QueryPropertyStored) {
4324
        _id -= 8;
4325
    } else if (_c == QMetaObject::QueryPropertyEditable) {
4326
        _id -= 8;
4327
    } else if (_c == QMetaObject::QueryPropertyUser) {
4328
        _id -= 8;
4329
    }
4330
#endif // QT_NO_PROPERTIES
4331
    return _id;
4332
}
4333
4334
// SIGNAL 0
4335
void QCPColorScale::dataRangeChanged(QCPRange _t1)
4336
{
4337
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
4338
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
4339
}
4340
4341
// SIGNAL 1
4342
void QCPColorScale::dataScaleTypeChanged(QCPAxis::ScaleType _t1)
4343
{
4344
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
4345
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
4346
}
4347
4348
// SIGNAL 2
4349
void QCPColorScale::gradientChanged(QCPColorGradient _t1)
4350
{
4351
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
4352
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
4353
}
4354
struct qt_meta_stringdata_QCPGraph_t {
4355
    QByteArrayData data[23];
4356
    char stringdata0[251];
4357
};
4358
#define QT_MOC_LITERAL(idx, ofs, len) \
4359
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
4360
    qptrdiff(offsetof(qt_meta_stringdata_QCPGraph_t, stringdata0) + ofs \
4361
        - idx * sizeof(QByteArrayData)) \
4362
    )
4363
static const qt_meta_stringdata_QCPGraph_t qt_meta_stringdata_QCPGraph = {
4364
    {
4365
QT_MOC_LITERAL(0, 0, 8), // "QCPGraph"
4366
QT_MOC_LITERAL(1, 9, 9), // "lineStyle"
4367
QT_MOC_LITERAL(2, 19, 9), // "LineStyle"
4368
QT_MOC_LITERAL(3, 29, 12), // "scatterStyle"
4369
QT_MOC_LITERAL(4, 42, 15), // "QCPScatterStyle"
4370
QT_MOC_LITERAL(5, 58, 9), // "errorType"
4371
QT_MOC_LITERAL(6, 68, 9), // "ErrorType"
4372
QT_MOC_LITERAL(7, 78, 8), // "errorPen"
4373
QT_MOC_LITERAL(8, 87, 12), // "errorBarSize"
4374
QT_MOC_LITERAL(9, 100, 18), // "errorBarSkipSymbol"
4375
QT_MOC_LITERAL(10, 119, 16), // "channelFillGraph"
4376
QT_MOC_LITERAL(11, 136, 9), // "QCPGraph*"
4377
QT_MOC_LITERAL(12, 146, 16), // "adaptiveSampling"
4378
QT_MOC_LITERAL(13, 163, 6), // "lsNone"
4379
QT_MOC_LITERAL(14, 170, 6), // "lsLine"
4380
QT_MOC_LITERAL(15, 177, 10), // "lsStepLeft"
4381
QT_MOC_LITERAL(16, 188, 11), // "lsStepRight"
4382
QT_MOC_LITERAL(17, 200, 12), // "lsStepCenter"
4383
QT_MOC_LITERAL(18, 213, 9), // "lsImpulse"
4384
QT_MOC_LITERAL(19, 223, 6), // "etNone"
4385
QT_MOC_LITERAL(20, 230, 5), // "etKey"
4386
QT_MOC_LITERAL(21, 236, 7), // "etValue"
4387
QT_MOC_LITERAL(22, 244, 6) // "etBoth"
4388
4389
    },
4390
    "QCPGraph\0lineStyle\0LineStyle\0scatterStyle\0"
4391
    "QCPScatterStyle\0errorType\0ErrorType\0"
4392
    "errorPen\0errorBarSize\0errorBarSkipSymbol\0"
4393
    "channelFillGraph\0QCPGraph*\0adaptiveSampling\0"
4394
    "lsNone\0lsLine\0lsStepLeft\0lsStepRight\0"
4395
    "lsStepCenter\0lsImpulse\0etNone\0etKey\0"
4396
    "etValue\0etBoth"
4397
};
4398
#undef QT_MOC_LITERAL
4399
4400
static const uint qt_meta_data_QCPGraph[] = {
4401
4402
 // content:
4403
       8,       // revision
4404
       0,       // classname
4405
       0,    0, // classinfo
4406
       0,    0, // methods
4407
       8,   14, // properties
4408
       2,   38, // enums/sets
4409
       0,    0, // constructors
4410
       0,       // flags
4411
       0,       // signalCount
4412
4413
 // properties: name, type, flags
4414
       1, 0x80000000 | 2, 0x0009510b,
4415
       3, 0x80000000 | 4, 0x0009510b,
4416
       5, 0x80000000 | 6, 0x0009510b,
4417
       7, QMetaType::QPen, 0x00095103,
4418
       8, QMetaType::Double, 0x00095103,
4419
       9, QMetaType::Bool, 0x00095103,
4420
      10, 0x80000000 | 11, 0x0009510b,
4421
      12, QMetaType::Bool, 0x00095103,
4422
4423
 // enums: name, alias, flags, count, data
4424
       2,    2, 0x0,    6,   48,
4425
       6,    6, 0x0,    4,   60,
4426
4427
 // enum data: key, value
4428
      13, uint(QCPGraph::lsNone),
4429
      14, uint(QCPGraph::lsLine),
4430
      15, uint(QCPGraph::lsStepLeft),
4431
      16, uint(QCPGraph::lsStepRight),
4432
      17, uint(QCPGraph::lsStepCenter),
4433
      18, uint(QCPGraph::lsImpulse),
4434
      19, uint(QCPGraph::etNone),
4435
      20, uint(QCPGraph::etKey),
4436
      21, uint(QCPGraph::etValue),
4437
      22, uint(QCPGraph::etBoth),
4438
4439
       0        // eod
4440
};
4441
4442
void QCPGraph::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
4443
{
4444
    if (_c == QMetaObject::RegisterPropertyMetaType) {
4445
        switch (_id) {
4446
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
4447
        case 6:
4448
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPGraph* >(); break;
4449
        }
4450
    }
4451
4452
#ifndef QT_NO_PROPERTIES
4453
    else if (_c == QMetaObject::ReadProperty) {
4454
        auto *_t = static_cast<QCPGraph *>(_o);
4455
        Q_UNUSED(_t)
4456
        void *_v = _a[0];
4457
        switch (_id) {
4458
        case 0: *reinterpret_cast< LineStyle*>(_v) = _t->lineStyle(); break;
4459
        case 1: *reinterpret_cast< QCPScatterStyle*>(_v) = _t->scatterStyle(); break;
4460
        case 2: *reinterpret_cast< ErrorType*>(_v) = _t->errorType(); break;
4461
        case 3: *reinterpret_cast< QPen*>(_v) = _t->errorPen(); break;
4462
        case 4: *reinterpret_cast< double*>(_v) = _t->errorBarSize(); break;
4463
        case 5: *reinterpret_cast< bool*>(_v) = _t->errorBarSkipSymbol(); break;
4464
        case 6: *reinterpret_cast< QCPGraph**>(_v) = _t->channelFillGraph(); break;
4465
        case 7: *reinterpret_cast< bool*>(_v) = _t->adaptiveSampling(); break;
4466
        default: break;
4467
        }
4468
    } else if (_c == QMetaObject::WriteProperty) {
4469
        auto *_t = static_cast<QCPGraph *>(_o);
4470
        Q_UNUSED(_t)
4471
        void *_v = _a[0];
4472
        switch (_id) {
4473
        case 0: _t->setLineStyle(*reinterpret_cast< LineStyle*>(_v)); break;
4474
        case 1: _t->setScatterStyle(*reinterpret_cast< QCPScatterStyle*>(_v)); break;
4475
        case 2: _t->setErrorType(*reinterpret_cast< ErrorType*>(_v)); break;
4476
        case 3: _t->setErrorPen(*reinterpret_cast< QPen*>(_v)); break;
4477
        case 4: _t->setErrorBarSize(*reinterpret_cast< double*>(_v)); break;
4478
        case 5: _t->setErrorBarSkipSymbol(*reinterpret_cast< bool*>(_v)); break;
4479
        case 6: _t->setChannelFillGraph(*reinterpret_cast< QCPGraph**>(_v)); break;
4480
        case 7: _t->setAdaptiveSampling(*reinterpret_cast< bool*>(_v)); break;
4481
        default: break;
4482
        }
4483
    } else if (_c == QMetaObject::ResetProperty) {
4484
    }
4485
#endif // QT_NO_PROPERTIES
4486
    Q_UNUSED(_o);
4487
}
4488
4489
QT_INIT_METAOBJECT const QMetaObject QCPGraph::staticMetaObject = { {
4490
    &QCPAbstractPlottable::staticMetaObject,
4491
    qt_meta_stringdata_QCPGraph.data,
4492
    qt_meta_data_QCPGraph,
4493
    qt_static_metacall,
4494
    nullptr,
4495
    nullptr
4496
} };
4497
4498
4499
const QMetaObject *QCPGraph::metaObject() const
4500
{
4501
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
4502
}
4503
4504
void *QCPGraph::qt_metacast(const char *_clname)
4505
{
4506
    if (!_clname) return nullptr;
4507
    if (!strcmp(_clname, qt_meta_stringdata_QCPGraph.stringdata0))
4508
        return static_cast<void*>(this);
4509
    return QCPAbstractPlottable::qt_metacast(_clname);
4510
}
4511
4512
int QCPGraph::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
4513
{
4514
    _id = QCPAbstractPlottable::qt_metacall(_c, _id, _a);
4515
    if (_id < 0)
4516
        return _id;
4517
4518
#ifndef QT_NO_PROPERTIES
4519
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
4520
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
4521
        qt_static_metacall(this, _c, _id, _a);
4522
        _id -= 8;
4523
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
4524
        _id -= 8;
4525
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
4526
        _id -= 8;
4527
    } else if (_c == QMetaObject::QueryPropertyStored) {
4528
        _id -= 8;
4529
    } else if (_c == QMetaObject::QueryPropertyEditable) {
4530
        _id -= 8;
4531
    } else if (_c == QMetaObject::QueryPropertyUser) {
4532
        _id -= 8;
4533
    }
4534
#endif // QT_NO_PROPERTIES
4535
    return _id;
4536
}
4537
struct qt_meta_stringdata_QCPCurve_t {
4538
    QByteArrayData data[5];
4539
    char stringdata0[58];
4540
};
4541
#define QT_MOC_LITERAL(idx, ofs, len) \
4542
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
4543
    qptrdiff(offsetof(qt_meta_stringdata_QCPCurve_t, stringdata0) + ofs \
4544
        - idx * sizeof(QByteArrayData)) \
4545
    )
4546
static const qt_meta_stringdata_QCPCurve_t qt_meta_stringdata_QCPCurve = {
4547
    {
4548
QT_MOC_LITERAL(0, 0, 8), // "QCPCurve"
4549
QT_MOC_LITERAL(1, 9, 12), // "scatterStyle"
4550
QT_MOC_LITERAL(2, 22, 15), // "QCPScatterStyle"
4551
QT_MOC_LITERAL(3, 38, 9), // "lineStyle"
4552
QT_MOC_LITERAL(4, 48, 9) // "LineStyle"
4553
4554
    },
4555
    "QCPCurve\0scatterStyle\0QCPScatterStyle\0"
4556
    "lineStyle\0LineStyle"
4557
};
4558
#undef QT_MOC_LITERAL
4559
4560
static const uint qt_meta_data_QCPCurve[] = {
4561
4562
 // content:
4563
       8,       // revision
4564
       0,       // classname
4565
       0,    0, // classinfo
4566
       0,    0, // methods
4567
       2,   14, // properties
4568
       0,    0, // enums/sets
4569
       0,    0, // constructors
4570
       0,       // flags
4571
       0,       // signalCount
4572
4573
 // properties: name, type, flags
4574
       1, 0x80000000 | 2, 0x0009510b,
4575
       3, 0x80000000 | 4, 0x0009510b,
4576
4577
       0        // eod
4578
};
4579
4580
void QCPCurve::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
4581
{
4582
4583
#ifndef QT_NO_PROPERTIES
4584
    if (_c == QMetaObject::ReadProperty) {
4585
        auto *_t = static_cast<QCPCurve *>(_o);
4586
        Q_UNUSED(_t)
4587
        void *_v = _a[0];
4588
        switch (_id) {
4589
        case 0: *reinterpret_cast< QCPScatterStyle*>(_v) = _t->scatterStyle(); break;
4590
        case 1: *reinterpret_cast< LineStyle*>(_v) = _t->lineStyle(); break;
4591
        default: break;
4592
        }
4593
    } else if (_c == QMetaObject::WriteProperty) {
4594
        auto *_t = static_cast<QCPCurve *>(_o);
4595
        Q_UNUSED(_t)
4596
        void *_v = _a[0];
4597
        switch (_id) {
4598
        case 0: _t->setScatterStyle(*reinterpret_cast< QCPScatterStyle*>(_v)); break;
4599
        case 1: _t->setLineStyle(*reinterpret_cast< LineStyle*>(_v)); break;
4600
        default: break;
4601
        }
4602
    } else if (_c == QMetaObject::ResetProperty) {
4603
    }
4604
#endif // QT_NO_PROPERTIES
4605
    Q_UNUSED(_o);
4606
    Q_UNUSED(_id);
4607
    Q_UNUSED(_c);
4608
    Q_UNUSED(_a);
4609
}
4610
4611
QT_INIT_METAOBJECT const QMetaObject QCPCurve::staticMetaObject = { {
4612
    &QCPAbstractPlottable::staticMetaObject,
4613
    qt_meta_stringdata_QCPCurve.data,
4614
    qt_meta_data_QCPCurve,
4615
    qt_static_metacall,
4616
    nullptr,
4617
    nullptr
4618
} };
4619
4620
4621
const QMetaObject *QCPCurve::metaObject() const
4622
{
4623
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
4624
}
4625
4626
void *QCPCurve::qt_metacast(const char *_clname)
4627
{
4628
    if (!_clname) return nullptr;
4629
    if (!strcmp(_clname, qt_meta_stringdata_QCPCurve.stringdata0))
4630
        return static_cast<void*>(this);
4631
    return QCPAbstractPlottable::qt_metacast(_clname);
4632
}
4633
4634
int QCPCurve::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
4635
{
4636
    _id = QCPAbstractPlottable::qt_metacall(_c, _id, _a);
4637
    if (_id < 0)
4638
        return _id;
4639
4640
#ifndef QT_NO_PROPERTIES
4641
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
4642
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
4643
        qt_static_metacall(this, _c, _id, _a);
4644
        _id -= 2;
4645
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
4646
        _id -= 2;
4647
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
4648
        _id -= 2;
4649
    } else if (_c == QMetaObject::QueryPropertyStored) {
4650
        _id -= 2;
4651
    } else if (_c == QMetaObject::QueryPropertyEditable) {
4652
        _id -= 2;
4653
    } else if (_c == QMetaObject::QueryPropertyUser) {
4654
        _id -= 2;
4655
    }
4656
#endif // QT_NO_PROPERTIES
4657
    return _id;
4658
}
4659
struct qt_meta_stringdata_QCPBarsGroup_t {
4660
    QByteArrayData data[4];
4661
    char stringdata0[45];
4662
};
4663
#define QT_MOC_LITERAL(idx, ofs, len) \
4664
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
4665
    qptrdiff(offsetof(qt_meta_stringdata_QCPBarsGroup_t, stringdata0) + ofs \
4666
        - idx * sizeof(QByteArrayData)) \
4667
    )
4668
static const qt_meta_stringdata_QCPBarsGroup_t qt_meta_stringdata_QCPBarsGroup = {
4669
    {
4670
QT_MOC_LITERAL(0, 0, 12), // "QCPBarsGroup"
4671
QT_MOC_LITERAL(1, 13, 11), // "spacingType"
4672
QT_MOC_LITERAL(2, 25, 11), // "SpacingType"
4673
QT_MOC_LITERAL(3, 37, 7) // "spacing"
4674
4675
    },
4676
    "QCPBarsGroup\0spacingType\0SpacingType\0"
4677
    "spacing"
4678
};
4679
#undef QT_MOC_LITERAL
4680
4681
static const uint qt_meta_data_QCPBarsGroup[] = {
4682
4683
 // content:
4684
       8,       // revision
4685
       0,       // classname
4686
       0,    0, // classinfo
4687
       0,    0, // methods
4688
       2,   14, // properties
4689
       0,    0, // enums/sets
4690
       0,    0, // constructors
4691
       0,       // flags
4692
       0,       // signalCount
4693
4694
 // properties: name, type, flags
4695
       1, 0x80000000 | 2, 0x0009510b,
4696
       3, QMetaType::Double, 0x00095103,
4697
4698
       0        // eod
4699
};
4700
4701
void QCPBarsGroup::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
4702
{
4703
4704
#ifndef QT_NO_PROPERTIES
4705
    if (_c == QMetaObject::ReadProperty) {
4706
        auto *_t = static_cast<QCPBarsGroup *>(_o);
4707
        Q_UNUSED(_t)
4708
        void *_v = _a[0];
4709
        switch (_id) {
4710
        case 0: *reinterpret_cast< SpacingType*>(_v) = _t->spacingType(); break;
4711
        case 1: *reinterpret_cast< double*>(_v) = _t->spacing(); break;
4712
        default: break;
4713
        }
4714
    } else if (_c == QMetaObject::WriteProperty) {
4715
        auto *_t = static_cast<QCPBarsGroup *>(_o);
4716
        Q_UNUSED(_t)
4717
        void *_v = _a[0];
4718
        switch (_id) {
4719
        case 0: _t->setSpacingType(*reinterpret_cast< SpacingType*>(_v)); break;
4720
        case 1: _t->setSpacing(*reinterpret_cast< double*>(_v)); break;
4721
        default: break;
4722
        }
4723
    } else if (_c == QMetaObject::ResetProperty) {
4724
    }
4725
#endif // QT_NO_PROPERTIES
4726
    Q_UNUSED(_o);
4727
    Q_UNUSED(_id);
4728
    Q_UNUSED(_c);
4729
    Q_UNUSED(_a);
4730
}
4731
4732
QT_INIT_METAOBJECT const QMetaObject QCPBarsGroup::staticMetaObject = { {
4733
    &QObject::staticMetaObject,
4734
    qt_meta_stringdata_QCPBarsGroup.data,
4735
    qt_meta_data_QCPBarsGroup,
4736
    qt_static_metacall,
4737
    nullptr,
4738
    nullptr
4739
} };
4740
4741
4742
const QMetaObject *QCPBarsGroup::metaObject() const
4743
{
4744
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
4745
}
4746
4747
void *QCPBarsGroup::qt_metacast(const char *_clname)
4748
{
4749
    if (!_clname) return nullptr;
4750
    if (!strcmp(_clname, qt_meta_stringdata_QCPBarsGroup.stringdata0))
4751
        return static_cast<void*>(this);
4752
    return QObject::qt_metacast(_clname);
4753
}
4754
4755
int QCPBarsGroup::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
4756
{
4757
    _id = QObject::qt_metacall(_c, _id, _a);
4758
    if (_id < 0)
4759
        return _id;
4760
4761
#ifndef QT_NO_PROPERTIES
4762
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
4763
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
4764
        qt_static_metacall(this, _c, _id, _a);
4765
        _id -= 2;
4766
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
4767
        _id -= 2;
4768
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
4769
        _id -= 2;
4770
    } else if (_c == QMetaObject::QueryPropertyStored) {
4771
        _id -= 2;
4772
    } else if (_c == QMetaObject::QueryPropertyEditable) {
4773
        _id -= 2;
4774
    } else if (_c == QMetaObject::QueryPropertyUser) {
4775
        _id -= 2;
4776
    }
4777
#endif // QT_NO_PROPERTIES
4778
    return _id;
4779
}
4780
struct qt_meta_stringdata_QCPBars_t {
4781
    QByteArrayData data[13];
4782
    char stringdata0[135];
4783
};
4784
#define QT_MOC_LITERAL(idx, ofs, len) \
4785
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
4786
    qptrdiff(offsetof(qt_meta_stringdata_QCPBars_t, stringdata0) + ofs \
4787
        - idx * sizeof(QByteArrayData)) \
4788
    )
4789
static const qt_meta_stringdata_QCPBars_t qt_meta_stringdata_QCPBars = {
4790
    {
4791
QT_MOC_LITERAL(0, 0, 7), // "QCPBars"
4792
QT_MOC_LITERAL(1, 8, 5), // "width"
4793
QT_MOC_LITERAL(2, 14, 9), // "widthType"
4794
QT_MOC_LITERAL(3, 24, 9), // "WidthType"
4795
QT_MOC_LITERAL(4, 34, 9), // "barsGroup"
4796
QT_MOC_LITERAL(5, 44, 13), // "QCPBarsGroup*"
4797
QT_MOC_LITERAL(6, 58, 9), // "baseValue"
4798
QT_MOC_LITERAL(7, 68, 8), // "barBelow"
4799
QT_MOC_LITERAL(8, 77, 8), // "QCPBars*"
4800
QT_MOC_LITERAL(9, 86, 8), // "barAbove"
4801
QT_MOC_LITERAL(10, 95, 10), // "wtAbsolute"
4802
QT_MOC_LITERAL(11, 106, 15), // "wtAxisRectRatio"
4803
QT_MOC_LITERAL(12, 122, 12) // "wtPlotCoords"
4804
4805
    },
4806
    "QCPBars\0width\0widthType\0WidthType\0"
4807
    "barsGroup\0QCPBarsGroup*\0baseValue\0"
4808
    "barBelow\0QCPBars*\0barAbove\0wtAbsolute\0"
4809
    "wtAxisRectRatio\0wtPlotCoords"
4810
};
4811
#undef QT_MOC_LITERAL
4812
4813
static const uint qt_meta_data_QCPBars[] = {
4814
4815
 // content:
4816
       8,       // revision
4817
       0,       // classname
4818
       0,    0, // classinfo
4819
       0,    0, // methods
4820
       6,   14, // properties
4821
       1,   32, // enums/sets
4822
       0,    0, // constructors
4823
       0,       // flags
4824
       0,       // signalCount
4825
4826
 // properties: name, type, flags
4827
       1, QMetaType::Double, 0x00095103,
4828
       2, 0x80000000 | 3, 0x0009510b,
4829
       4, 0x80000000 | 5, 0x0009510b,
4830
       6, QMetaType::Double, 0x00095103,
4831
       7, 0x80000000 | 8, 0x00095009,
4832
       9, 0x80000000 | 8, 0x00095009,
4833
4834
 // enums: name, alias, flags, count, data
4835
       3,    3, 0x0,    3,   37,
4836
4837
 // enum data: key, value
4838
      10, uint(QCPBars::wtAbsolute),
4839
      11, uint(QCPBars::wtAxisRectRatio),
4840
      12, uint(QCPBars::wtPlotCoords),
4841
4842
       0        // eod
4843
};
4844
4845
void QCPBars::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
4846
{
4847
    if (_c == QMetaObject::RegisterPropertyMetaType) {
4848
        switch (_id) {
4849
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
4850
        case 5:
4851
        case 4:
4852
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPBars* >(); break;
4853
        case 2:
4854
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPBarsGroup* >(); break;
4855
        }
4856
    }
4857
4858
#ifndef QT_NO_PROPERTIES
4859
    else if (_c == QMetaObject::ReadProperty) {
4860
        auto *_t = static_cast<QCPBars *>(_o);
4861
        Q_UNUSED(_t)
4862
        void *_v = _a[0];
4863
        switch (_id) {
4864
        case 0: *reinterpret_cast< double*>(_v) = _t->width(); break;
4865
        case 1: *reinterpret_cast< WidthType*>(_v) = _t->widthType(); break;
4866
        case 2: *reinterpret_cast< QCPBarsGroup**>(_v) = _t->barsGroup(); break;
4867
        case 3: *reinterpret_cast< double*>(_v) = _t->baseValue(); break;
4868
        case 4: *reinterpret_cast< QCPBars**>(_v) = _t->barBelow(); break;
4869
        case 5: *reinterpret_cast< QCPBars**>(_v) = _t->barAbove(); break;
4870
        default: break;
4871
        }
4872
    } else if (_c == QMetaObject::WriteProperty) {
4873
        auto *_t = static_cast<QCPBars *>(_o);
4874
        Q_UNUSED(_t)
4875
        void *_v = _a[0];
4876
        switch (_id) {
4877
        case 0: _t->setWidth(*reinterpret_cast< double*>(_v)); break;
4878
        case 1: _t->setWidthType(*reinterpret_cast< WidthType*>(_v)); break;
4879
        case 2: _t->setBarsGroup(*reinterpret_cast< QCPBarsGroup**>(_v)); break;
4880
        case 3: _t->setBaseValue(*reinterpret_cast< double*>(_v)); break;
4881
        default: break;
4882
        }
4883
    } else if (_c == QMetaObject::ResetProperty) {
4884
    }
4885
#endif // QT_NO_PROPERTIES
4886
    Q_UNUSED(_o);
4887
}
4888
4889
QT_INIT_METAOBJECT const QMetaObject QCPBars::staticMetaObject = { {
4890
    &QCPAbstractPlottable::staticMetaObject,
4891
    qt_meta_stringdata_QCPBars.data,
4892
    qt_meta_data_QCPBars,
4893
    qt_static_metacall,
4894
    nullptr,
4895
    nullptr
4896
} };
4897
4898
4899
const QMetaObject *QCPBars::metaObject() const
4900
{
4901
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
4902
}
4903
4904
void *QCPBars::qt_metacast(const char *_clname)
4905
{
4906
    if (!_clname) return nullptr;
4907
    if (!strcmp(_clname, qt_meta_stringdata_QCPBars.stringdata0))
4908
        return static_cast<void*>(this);
4909
    return QCPAbstractPlottable::qt_metacast(_clname);
4910
}
4911
4912
int QCPBars::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
4913
{
4914
    _id = QCPAbstractPlottable::qt_metacall(_c, _id, _a);
4915
    if (_id < 0)
4916
        return _id;
4917
4918
#ifndef QT_NO_PROPERTIES
4919
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
4920
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
4921
        qt_static_metacall(this, _c, _id, _a);
4922
        _id -= 6;
4923
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
4924
        _id -= 6;
4925
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
4926
        _id -= 6;
4927
    } else if (_c == QMetaObject::QueryPropertyStored) {
4928
        _id -= 6;
4929
    } else if (_c == QMetaObject::QueryPropertyEditable) {
4930
        _id -= 6;
4931
    } else if (_c == QMetaObject::QueryPropertyUser) {
4932
        _id -= 6;
4933
    }
4934
#endif // QT_NO_PROPERTIES
4935
    return _id;
4936
}
4937
struct qt_meta_stringdata_QCPStatisticalBox_t {
4938
    QByteArrayData data[16];
4939
    char stringdata0[181];
4940
};
4941
#define QT_MOC_LITERAL(idx, ofs, len) \
4942
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
4943
    qptrdiff(offsetof(qt_meta_stringdata_QCPStatisticalBox_t, stringdata0) + ofs \
4944
        - idx * sizeof(QByteArrayData)) \
4945
    )
4946
static const qt_meta_stringdata_QCPStatisticalBox_t qt_meta_stringdata_QCPStatisticalBox = {
4947
    {
4948
QT_MOC_LITERAL(0, 0, 17), // "QCPStatisticalBox"
4949
QT_MOC_LITERAL(1, 18, 3), // "key"
4950
QT_MOC_LITERAL(2, 22, 7), // "minimum"
4951
QT_MOC_LITERAL(3, 30, 13), // "lowerQuartile"
4952
QT_MOC_LITERAL(4, 44, 6), // "median"
4953
QT_MOC_LITERAL(5, 51, 13), // "upperQuartile"
4954
QT_MOC_LITERAL(6, 65, 7), // "maximum"
4955
QT_MOC_LITERAL(7, 73, 8), // "outliers"
4956
QT_MOC_LITERAL(8, 82, 15), // "QVector<double>"
4957
QT_MOC_LITERAL(9, 98, 5), // "width"
4958
QT_MOC_LITERAL(10, 104, 12), // "whiskerWidth"
4959
QT_MOC_LITERAL(11, 117, 10), // "whiskerPen"
4960
QT_MOC_LITERAL(12, 128, 13), // "whiskerBarPen"
4961
QT_MOC_LITERAL(13, 142, 9), // "medianPen"
4962
QT_MOC_LITERAL(14, 152, 12), // "outlierStyle"
4963
QT_MOC_LITERAL(15, 165, 15) // "QCPScatterStyle"
4964
4965
    },
4966
    "QCPStatisticalBox\0key\0minimum\0"
4967
    "lowerQuartile\0median\0upperQuartile\0"
4968
    "maximum\0outliers\0QVector<double>\0width\0"
4969
    "whiskerWidth\0whiskerPen\0whiskerBarPen\0"
4970
    "medianPen\0outlierStyle\0QCPScatterStyle"
4971
};
4972
#undef QT_MOC_LITERAL
4973
4974
static const uint qt_meta_data_QCPStatisticalBox[] = {
4975
4976
 // content:
4977
       8,       // revision
4978
       0,       // classname
4979
       0,    0, // classinfo
4980
       0,    0, // methods
4981
      13,   14, // properties
4982
       0,    0, // enums/sets
4983
       0,    0, // constructors
4984
       0,       // flags
4985
       0,       // signalCount
4986
4987
 // properties: name, type, flags
4988
       1, QMetaType::Double, 0x00095103,
4989
       2, QMetaType::Double, 0x00095103,
4990
       3, QMetaType::Double, 0x00095103,
4991
       4, QMetaType::Double, 0x00095103,
4992
       5, QMetaType::Double, 0x00095103,
4993
       6, QMetaType::Double, 0x00095103,
4994
       7, 0x80000000 | 8, 0x0009510b,
4995
       9, QMetaType::Double, 0x00095103,
4996
      10, QMetaType::Double, 0x00095103,
4997
      11, QMetaType::QPen, 0x00095103,
4998
      12, QMetaType::QPen, 0x00095103,
4999
      13, QMetaType::QPen, 0x00095103,
5000
      14, 0x80000000 | 15, 0x0009510b,
5001
5002
       0        // eod
5003
};
5004
5005
void QCPStatisticalBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
5006
{
5007
    if (_c == QMetaObject::RegisterPropertyMetaType) {
5008
        switch (_id) {
5009
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
5010
        case 6:
5011
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QVector<double> >(); break;
5012
        }
5013
    }
5014
5015
#ifndef QT_NO_PROPERTIES
5016
    else if (_c == QMetaObject::ReadProperty) {
5017
        auto *_t = static_cast<QCPStatisticalBox *>(_o);
5018
        Q_UNUSED(_t)
5019
        void *_v = _a[0];
5020
        switch (_id) {
5021
        case 0: *reinterpret_cast< double*>(_v) = _t->key(); break;
5022
        case 1: *reinterpret_cast< double*>(_v) = _t->minimum(); break;
5023
        case 2: *reinterpret_cast< double*>(_v) = _t->lowerQuartile(); break;
5024
        case 3: *reinterpret_cast< double*>(_v) = _t->median(); break;
5025
        case 4: *reinterpret_cast< double*>(_v) = _t->upperQuartile(); break;
5026
        case 5: *reinterpret_cast< double*>(_v) = _t->maximum(); break;
5027
        case 6: *reinterpret_cast< QVector<double>*>(_v) = _t->outliers(); break;
5028
        case 7: *reinterpret_cast< double*>(_v) = _t->width(); break;
5029
        case 8: *reinterpret_cast< double*>(_v) = _t->whiskerWidth(); break;
5030
        case 9: *reinterpret_cast< QPen*>(_v) = _t->whiskerPen(); break;
5031
        case 10: *reinterpret_cast< QPen*>(_v) = _t->whiskerBarPen(); break;
5032
        case 11: *reinterpret_cast< QPen*>(_v) = _t->medianPen(); break;
5033
        case 12: *reinterpret_cast< QCPScatterStyle*>(_v) = _t->outlierStyle(); break;
5034
        default: break;
5035
        }
5036
    } else if (_c == QMetaObject::WriteProperty) {
5037
        auto *_t = static_cast<QCPStatisticalBox *>(_o);
5038
        Q_UNUSED(_t)
5039
        void *_v = _a[0];
5040
        switch (_id) {
5041
        case 0: _t->setKey(*reinterpret_cast< double*>(_v)); break;
5042
        case 1: _t->setMinimum(*reinterpret_cast< double*>(_v)); break;
5043
        case 2: _t->setLowerQuartile(*reinterpret_cast< double*>(_v)); break;
5044
        case 3: _t->setMedian(*reinterpret_cast< double*>(_v)); break;
5045
        case 4: _t->setUpperQuartile(*reinterpret_cast< double*>(_v)); break;
5046
        case 5: _t->setMaximum(*reinterpret_cast< double*>(_v)); break;
5047
        case 6: _t->setOutliers(*reinterpret_cast< QVector<double>*>(_v)); break;
5048
        case 7: _t->setWidth(*reinterpret_cast< double*>(_v)); break;
5049
        case 8: _t->setWhiskerWidth(*reinterpret_cast< double*>(_v)); break;
5050
        case 9: _t->setWhiskerPen(*reinterpret_cast< QPen*>(_v)); break;
5051
        case 10: _t->setWhiskerBarPen(*reinterpret_cast< QPen*>(_v)); break;
5052
        case 11: _t->setMedianPen(*reinterpret_cast< QPen*>(_v)); break;
5053
        case 12: _t->setOutlierStyle(*reinterpret_cast< QCPScatterStyle*>(_v)); break;
5054
        default: break;
5055
        }
5056
    } else if (_c == QMetaObject::ResetProperty) {
5057
    }
5058
#endif // QT_NO_PROPERTIES
5059
    Q_UNUSED(_o);
5060
}
5061
5062
QT_INIT_METAOBJECT const QMetaObject QCPStatisticalBox::staticMetaObject = { {
5063
    &QCPAbstractPlottable::staticMetaObject,
5064
    qt_meta_stringdata_QCPStatisticalBox.data,
5065
    qt_meta_data_QCPStatisticalBox,
5066
    qt_static_metacall,
5067
    nullptr,
5068
    nullptr
5069
} };
5070
5071
5072
const QMetaObject *QCPStatisticalBox::metaObject() const
5073
{
5074
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
5075
}
5076
5077
void *QCPStatisticalBox::qt_metacast(const char *_clname)
5078
{
5079
    if (!_clname) return nullptr;
5080
    if (!strcmp(_clname, qt_meta_stringdata_QCPStatisticalBox.stringdata0))
5081
        return static_cast<void*>(this);
5082
    return QCPAbstractPlottable::qt_metacast(_clname);
5083
}
5084
5085
int QCPStatisticalBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
5086
{
5087
    _id = QCPAbstractPlottable::qt_metacall(_c, _id, _a);
5088
    if (_id < 0)
5089
        return _id;
5090
5091
#ifndef QT_NO_PROPERTIES
5092
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
5093
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
5094
        qt_static_metacall(this, _c, _id, _a);
5095
        _id -= 13;
5096
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
5097
        _id -= 13;
5098
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
5099
        _id -= 13;
5100
    } else if (_c == QMetaObject::QueryPropertyStored) {
5101
        _id -= 13;
5102
    } else if (_c == QMetaObject::QueryPropertyEditable) {
5103
        _id -= 13;
5104
    } else if (_c == QMetaObject::QueryPropertyUser) {
5105
        _id -= 13;
5106
    }
5107
#endif // QT_NO_PROPERTIES
5108
    return _id;
5109
}
5110
struct qt_meta_stringdata_QCPColorMap_t {
5111
    QByteArrayData data[25];
5112
    char stringdata0[334];
5113
};
5114
#define QT_MOC_LITERAL(idx, ofs, len) \
5115
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
5116
    qptrdiff(offsetof(qt_meta_stringdata_QCPColorMap_t, stringdata0) + ofs \
5117
        - idx * sizeof(QByteArrayData)) \
5118
    )
5119
static const qt_meta_stringdata_QCPColorMap_t qt_meta_stringdata_QCPColorMap = {
5120
    {
5121
QT_MOC_LITERAL(0, 0, 11), // "QCPColorMap"
5122
QT_MOC_LITERAL(1, 12, 16), // "dataRangeChanged"
5123
QT_MOC_LITERAL(2, 29, 0), // ""
5124
QT_MOC_LITERAL(3, 30, 8), // "QCPRange"
5125
QT_MOC_LITERAL(4, 39, 8), // "newRange"
5126
QT_MOC_LITERAL(5, 48, 20), // "dataScaleTypeChanged"
5127
QT_MOC_LITERAL(6, 69, 18), // "QCPAxis::ScaleType"
5128
QT_MOC_LITERAL(7, 88, 9), // "scaleType"
5129
QT_MOC_LITERAL(8, 98, 15), // "gradientChanged"
5130
QT_MOC_LITERAL(9, 114, 16), // "QCPColorGradient"
5131
QT_MOC_LITERAL(10, 131, 11), // "newGradient"
5132
QT_MOC_LITERAL(11, 143, 12), // "setDataRange"
5133
QT_MOC_LITERAL(12, 156, 9), // "dataRange"
5134
QT_MOC_LITERAL(13, 166, 16), // "setDataScaleType"
5135
QT_MOC_LITERAL(14, 183, 11), // "setGradient"
5136
QT_MOC_LITERAL(15, 195, 8), // "gradient"
5137
QT_MOC_LITERAL(16, 204, 16), // "updateLegendIcon"
5138
QT_MOC_LITERAL(17, 221, 22), // "Qt::TransformationMode"
5139
QT_MOC_LITERAL(18, 244, 13), // "transformMode"
5140
QT_MOC_LITERAL(19, 258, 9), // "thumbSize"
5141
QT_MOC_LITERAL(20, 268, 13), // "dataScaleType"
5142
QT_MOC_LITERAL(21, 282, 11), // "interpolate"
5143
QT_MOC_LITERAL(22, 294, 13), // "tightBoundary"
5144
QT_MOC_LITERAL(23, 308, 10), // "colorScale"
5145
QT_MOC_LITERAL(24, 319, 14) // "QCPColorScale*"
5146
5147
    },
5148
    "QCPColorMap\0dataRangeChanged\0\0QCPRange\0"
5149
    "newRange\0dataScaleTypeChanged\0"
5150
    "QCPAxis::ScaleType\0scaleType\0"
5151
    "gradientChanged\0QCPColorGradient\0"
5152
    "newGradient\0setDataRange\0dataRange\0"
5153
    "setDataScaleType\0setGradient\0gradient\0"
5154
    "updateLegendIcon\0Qt::TransformationMode\0"
5155
    "transformMode\0thumbSize\0dataScaleType\0"
5156
    "interpolate\0tightBoundary\0colorScale\0"
5157
    "QCPColorScale*"
5158
};
5159
#undef QT_MOC_LITERAL
5160
5161
static const uint qt_meta_data_QCPColorMap[] = {
5162
5163
 // content:
5164
       8,       // revision
5165
       0,       // classname
5166
       0,    0, // classinfo
5167
       9,   14, // methods
5168
       6,   86, // properties
5169
       0,    0, // enums/sets
5170
       0,    0, // constructors
5171
       0,       // flags
5172
       3,       // signalCount
5173
5174
 // signals: name, argc, parameters, tag, flags
5175
       1,    1,   59,    2, 0x06 /* Public */,
5176
       5,    1,   62,    2, 0x06 /* Public */,
5177
       8,    1,   65,    2, 0x06 /* Public */,
5178
5179
 // slots: name, argc, parameters, tag, flags
5180
      11,    1,   68,    2, 0x0a /* Public */,
5181
      13,    1,   71,    2, 0x0a /* Public */,
5182
      14,    1,   74,    2, 0x0a /* Public */,
5183
      16,    2,   77,    2, 0x0a /* Public */,
5184
      16,    1,   82,    2, 0x2a /* Public | MethodCloned */,
5185
      16,    0,   85,    2, 0x2a /* Public | MethodCloned */,
5186
5187
 // signals: parameters
5188
    QMetaType::Void, 0x80000000 | 3,    4,
5189
    QMetaType::Void, 0x80000000 | 6,    7,
5190
    QMetaType::Void, 0x80000000 | 9,   10,
5191
5192
 // slots: parameters
5193
    QMetaType::Void, 0x80000000 | 3,   12,
5194
    QMetaType::Void, 0x80000000 | 6,    7,
5195
    QMetaType::Void, 0x80000000 | 9,   15,
5196
    QMetaType::Void, 0x80000000 | 17, QMetaType::QSize,   18,   19,
5197
    QMetaType::Void, 0x80000000 | 17,   18,
5198
    QMetaType::Void,
5199
5200
 // properties: name, type, flags
5201
      12, 0x80000000 | 3, 0x0049510b,
5202
      20, 0x80000000 | 6, 0x0049510b,
5203
      15, 0x80000000 | 9, 0x0049510b,
5204
      21, QMetaType::Bool, 0x00095103,
5205
      22, QMetaType::Bool, 0x00095103,
5206
      23, 0x80000000 | 24, 0x0009510b,
5207
5208
 // properties: notify_signal_id
5209
       0,
5210
       1,
5211
       2,
5212
       0,
5213
       0,
5214
       0,
5215
5216
       0        // eod
5217
};
5218
5219
void QCPColorMap::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
5220
{
5221
    if (_c == QMetaObject::InvokeMetaMethod) {
5222
        auto *_t = static_cast<QCPColorMap *>(_o);
5223
        Q_UNUSED(_t)
5224
        switch (_id) {
5225
        case 0: _t->dataRangeChanged((*reinterpret_cast< QCPRange(*)>(_a[1]))); break;
5226
        case 1: _t->dataScaleTypeChanged((*reinterpret_cast< QCPAxis::ScaleType(*)>(_a[1]))); break;
5227
        case 2: _t->gradientChanged((*reinterpret_cast< QCPColorGradient(*)>(_a[1]))); break;
5228
        case 3: _t->setDataRange((*reinterpret_cast< const QCPRange(*)>(_a[1]))); break;
5229
        case 4: _t->setDataScaleType((*reinterpret_cast< QCPAxis::ScaleType(*)>(_a[1]))); break;
5230
        case 5: _t->setGradient((*reinterpret_cast< const QCPColorGradient(*)>(_a[1]))); break;
5231
        case 6: _t->updateLegendIcon((*reinterpret_cast< Qt::TransformationMode(*)>(_a[1])),(*reinterpret_cast< const QSize(*)>(_a[2]))); break;
5232
        case 7: _t->updateLegendIcon((*reinterpret_cast< Qt::TransformationMode(*)>(_a[1]))); break;
5233
        case 8: _t->updateLegendIcon(); break;
5234
        default: ;
5235
        }
5236
    } else if (_c == QMetaObject::IndexOfMethod) {
5237
        int *result = reinterpret_cast<int *>(_a[0]);
5238
        {
5239
            using _t = void (QCPColorMap::*)(QCPRange );
5240
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPColorMap::dataRangeChanged)) {
5241
                *result = 0;
5242
                return;
5243
            }
5244
        }
5245
        {
5246
            using _t = void (QCPColorMap::*)(QCPAxis::ScaleType );
5247
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPColorMap::dataScaleTypeChanged)) {
5248
                *result = 1;
5249
                return;
5250
            }
5251
        }
5252
        {
5253
            using _t = void (QCPColorMap::*)(QCPColorGradient );
5254
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPColorMap::gradientChanged)) {
5255
                *result = 2;
5256
                return;
5257
            }
5258
        }
5259
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
5260
        switch (_id) {
5261
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
5262
        case 5:
5263
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPColorScale* >(); break;
5264
        }
5265
    }
5266
5267
#ifndef QT_NO_PROPERTIES
5268
    else if (_c == QMetaObject::ReadProperty) {
5269
        auto *_t = static_cast<QCPColorMap *>(_o);
5270
        Q_UNUSED(_t)
5271
        void *_v = _a[0];
5272
        switch (_id) {
5273
        case 0: *reinterpret_cast< QCPRange*>(_v) = _t->dataRange(); break;
5274
        case 1: *reinterpret_cast< QCPAxis::ScaleType*>(_v) = _t->dataScaleType(); break;
5275
        case 2: *reinterpret_cast< QCPColorGradient*>(_v) = _t->gradient(); break;
5276
        case 3: *reinterpret_cast< bool*>(_v) = _t->interpolate(); break;
5277
        case 4: *reinterpret_cast< bool*>(_v) = _t->tightBoundary(); break;
5278
        case 5: *reinterpret_cast< QCPColorScale**>(_v) = _t->colorScale(); break;
5279
        default: break;
5280
        }
5281
    } else if (_c == QMetaObject::WriteProperty) {
5282
        auto *_t = static_cast<QCPColorMap *>(_o);
5283
        Q_UNUSED(_t)
5284
        void *_v = _a[0];
5285
        switch (_id) {
5286
        case 0: _t->setDataRange(*reinterpret_cast< QCPRange*>(_v)); break;
5287
        case 1: _t->setDataScaleType(*reinterpret_cast< QCPAxis::ScaleType*>(_v)); break;
5288
        case 2: _t->setGradient(*reinterpret_cast< QCPColorGradient*>(_v)); break;
5289
        case 3: _t->setInterpolate(*reinterpret_cast< bool*>(_v)); break;
5290
        case 4: _t->setTightBoundary(*reinterpret_cast< bool*>(_v)); break;
5291
        case 5: _t->setColorScale(*reinterpret_cast< QCPColorScale**>(_v)); break;
5292
        default: break;
5293
        }
5294
    } else if (_c == QMetaObject::ResetProperty) {
5295
    }
5296
#endif // QT_NO_PROPERTIES
5297
}
5298
5299
static const QMetaObject * const qt_meta_extradata_QCPColorMap[] = {
5300
        &QCPAxis::staticMetaObject,
5301
    nullptr
5302
};
5303
5304
QT_INIT_METAOBJECT const QMetaObject QCPColorMap::staticMetaObject = { {
5305
    &QCPAbstractPlottable::staticMetaObject,
5306
    qt_meta_stringdata_QCPColorMap.data,
5307
    qt_meta_data_QCPColorMap,
5308
    qt_static_metacall,
5309
    qt_meta_extradata_QCPColorMap,
5310
    nullptr
5311
} };
5312
5313
5314
const QMetaObject *QCPColorMap::metaObject() const
5315
{
5316
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
5317
}
5318
5319
void *QCPColorMap::qt_metacast(const char *_clname)
5320
{
5321
    if (!_clname) return nullptr;
5322
    if (!strcmp(_clname, qt_meta_stringdata_QCPColorMap.stringdata0))
5323
        return static_cast<void*>(this);
5324
    return QCPAbstractPlottable::qt_metacast(_clname);
5325
}
5326
5327
int QCPColorMap::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
5328
{
5329
    _id = QCPAbstractPlottable::qt_metacall(_c, _id, _a);
5330
    if (_id < 0)
5331
        return _id;
5332
    if (_c == QMetaObject::InvokeMetaMethod) {
5333
        if (_id < 9)
5334
            qt_static_metacall(this, _c, _id, _a);
5335
        _id -= 9;
5336
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
5337
        if (_id < 9)
5338
            *reinterpret_cast<int*>(_a[0]) = -1;
5339
        _id -= 9;
5340
    }
5341
#ifndef QT_NO_PROPERTIES
5342
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
5343
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
5344
        qt_static_metacall(this, _c, _id, _a);
5345
        _id -= 6;
5346
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
5347
        _id -= 6;
5348
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
5349
        _id -= 6;
5350
    } else if (_c == QMetaObject::QueryPropertyStored) {
5351
        _id -= 6;
5352
    } else if (_c == QMetaObject::QueryPropertyEditable) {
5353
        _id -= 6;
5354
    } else if (_c == QMetaObject::QueryPropertyUser) {
5355
        _id -= 6;
5356
    }
5357
#endif // QT_NO_PROPERTIES
5358
    return _id;
5359
}
5360
5361
// SIGNAL 0
5362
void QCPColorMap::dataRangeChanged(QCPRange _t1)
5363
{
5364
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
5365
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
5366
}
5367
5368
// SIGNAL 1
5369
void QCPColorMap::dataScaleTypeChanged(QCPAxis::ScaleType _t1)
5370
{
5371
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
5372
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
5373
}
5374
5375
// SIGNAL 2
5376
void QCPColorMap::gradientChanged(QCPColorGradient _t1)
5377
{
5378
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
5379
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
5380
}
5381
struct qt_meta_stringdata_QCPFinancial_t {
5382
    QByteArrayData data[11];
5383
    char stringdata0[125];
5384
};
5385
#define QT_MOC_LITERAL(idx, ofs, len) \
5386
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
5387
    qptrdiff(offsetof(qt_meta_stringdata_QCPFinancial_t, stringdata0) + ofs \
5388
        - idx * sizeof(QByteArrayData)) \
5389
    )
5390
static const qt_meta_stringdata_QCPFinancial_t qt_meta_stringdata_QCPFinancial = {
5391
    {
5392
QT_MOC_LITERAL(0, 0, 12), // "QCPFinancial"
5393
QT_MOC_LITERAL(1, 13, 10), // "chartStyle"
5394
QT_MOC_LITERAL(2, 24, 10), // "ChartStyle"
5395
QT_MOC_LITERAL(3, 35, 5), // "width"
5396
QT_MOC_LITERAL(4, 41, 10), // "twoColored"
5397
QT_MOC_LITERAL(5, 52, 13), // "brushPositive"
5398
QT_MOC_LITERAL(6, 66, 13), // "brushNegative"
5399
QT_MOC_LITERAL(7, 80, 11), // "penPositive"
5400
QT_MOC_LITERAL(8, 92, 11), // "penNegative"
5401
QT_MOC_LITERAL(9, 104, 6), // "csOhlc"
5402
QT_MOC_LITERAL(10, 111, 13) // "csCandlestick"
5403
5404
    },
5405
    "QCPFinancial\0chartStyle\0ChartStyle\0"
5406
    "width\0twoColored\0brushPositive\0"
5407
    "brushNegative\0penPositive\0penNegative\0"
5408
    "csOhlc\0csCandlestick"
5409
};
5410
#undef QT_MOC_LITERAL
5411
5412
static const uint qt_meta_data_QCPFinancial[] = {
5413
5414
 // content:
5415
       8,       // revision
5416
       0,       // classname
5417
       0,    0, // classinfo
5418
       0,    0, // methods
5419
       7,   14, // properties
5420
       1,   35, // enums/sets
5421
       0,    0, // constructors
5422
       0,       // flags
5423
       0,       // signalCount
5424
5425
 // properties: name, type, flags
5426
       1, 0x80000000 | 2, 0x0009510b,
5427
       3, QMetaType::Double, 0x00095103,
5428
       4, QMetaType::Bool, 0x00095103,
5429
       5, QMetaType::QBrush, 0x00095103,
5430
       6, QMetaType::QBrush, 0x00095103,
5431
       7, QMetaType::QPen, 0x00095103,
5432
       8, QMetaType::QPen, 0x00095103,
5433
5434
 // enums: name, alias, flags, count, data
5435
       2,    2, 0x0,    2,   40,
5436
5437
 // enum data: key, value
5438
       9, uint(QCPFinancial::csOhlc),
5439
      10, uint(QCPFinancial::csCandlestick),
5440
5441
       0        // eod
5442
};
5443
5444
void QCPFinancial::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
5445
{
5446
5447
#ifndef QT_NO_PROPERTIES
5448
    if (_c == QMetaObject::ReadProperty) {
5449
        auto *_t = static_cast<QCPFinancial *>(_o);
5450
        Q_UNUSED(_t)
5451
        void *_v = _a[0];
5452
        switch (_id) {
5453
        case 0: *reinterpret_cast< ChartStyle*>(_v) = _t->chartStyle(); break;
5454
        case 1: *reinterpret_cast< double*>(_v) = _t->width(); break;
5455
        case 2: *reinterpret_cast< bool*>(_v) = _t->twoColored(); break;
5456
        case 3: *reinterpret_cast< QBrush*>(_v) = _t->brushPositive(); break;
5457
        case 4: *reinterpret_cast< QBrush*>(_v) = _t->brushNegative(); break;
5458
        case 5: *reinterpret_cast< QPen*>(_v) = _t->penPositive(); break;
5459
        case 6: *reinterpret_cast< QPen*>(_v) = _t->penNegative(); break;
5460
        default: break;
5461
        }
5462
    } else if (_c == QMetaObject::WriteProperty) {
5463
        auto *_t = static_cast<QCPFinancial *>(_o);
5464
        Q_UNUSED(_t)
5465
        void *_v = _a[0];
5466
        switch (_id) {
5467
        case 0: _t->setChartStyle(*reinterpret_cast< ChartStyle*>(_v)); break;
5468
        case 1: _t->setWidth(*reinterpret_cast< double*>(_v)); break;
5469
        case 2: _t->setTwoColored(*reinterpret_cast< bool*>(_v)); break;
5470
        case 3: _t->setBrushPositive(*reinterpret_cast< QBrush*>(_v)); break;
5471
        case 4: _t->setBrushNegative(*reinterpret_cast< QBrush*>(_v)); break;
5472
        case 5: _t->setPenPositive(*reinterpret_cast< QPen*>(_v)); break;
5473
        case 6: _t->setPenNegative(*reinterpret_cast< QPen*>(_v)); break;
5474
        default: break;
5475
        }
5476
    } else if (_c == QMetaObject::ResetProperty) {
5477
    }
5478
#endif // QT_NO_PROPERTIES
5479
    Q_UNUSED(_o);
5480
    Q_UNUSED(_id);
5481
    Q_UNUSED(_c);
5482
    Q_UNUSED(_a);
5483
}
5484
5485
QT_INIT_METAOBJECT const QMetaObject QCPFinancial::staticMetaObject = { {
5486
    &QCPAbstractPlottable::staticMetaObject,
5487
    qt_meta_stringdata_QCPFinancial.data,
5488
    qt_meta_data_QCPFinancial,
5489
    qt_static_metacall,
5490
    nullptr,
5491
    nullptr
5492
} };
5493
5494
5495
const QMetaObject *QCPFinancial::metaObject() const
5496
{
5497
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
5498
}
5499
5500
void *QCPFinancial::qt_metacast(const char *_clname)
5501
{
5502
    if (!_clname) return nullptr;
5503
    if (!strcmp(_clname, qt_meta_stringdata_QCPFinancial.stringdata0))
5504
        return static_cast<void*>(this);
5505
    return QCPAbstractPlottable::qt_metacast(_clname);
5506
}
5507
5508
int QCPFinancial::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
5509
{
5510
    _id = QCPAbstractPlottable::qt_metacall(_c, _id, _a);
5511
    if (_id < 0)
5512
        return _id;
5513
5514
#ifndef QT_NO_PROPERTIES
5515
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
5516
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
5517
        qt_static_metacall(this, _c, _id, _a);
5518
        _id -= 7;
5519
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
5520
        _id -= 7;
5521
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
5522
        _id -= 7;
5523
    } else if (_c == QMetaObject::QueryPropertyStored) {
5524
        _id -= 7;
5525
    } else if (_c == QMetaObject::QueryPropertyEditable) {
5526
        _id -= 7;
5527
    } else if (_c == QMetaObject::QueryPropertyUser) {
5528
        _id -= 7;
5529
    }
5530
#endif // QT_NO_PROPERTIES
5531
    return _id;
5532
}
5533
struct qt_meta_stringdata_QCPItemStraightLine_t {
5534
    QByteArrayData data[3];
5535
    char stringdata0[36];
5536
};
5537
#define QT_MOC_LITERAL(idx, ofs, len) \
5538
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
5539
    qptrdiff(offsetof(qt_meta_stringdata_QCPItemStraightLine_t, stringdata0) + ofs \
5540
        - idx * sizeof(QByteArrayData)) \
5541
    )
5542
static const qt_meta_stringdata_QCPItemStraightLine_t qt_meta_stringdata_QCPItemStraightLine = {
5543
    {
5544
QT_MOC_LITERAL(0, 0, 19), // "QCPItemStraightLine"
5545
QT_MOC_LITERAL(1, 20, 3), // "pen"
5546
QT_MOC_LITERAL(2, 24, 11) // "selectedPen"
5547
5548
    },
5549
    "QCPItemStraightLine\0pen\0selectedPen"
5550
};
5551
#undef QT_MOC_LITERAL
5552
5553
static const uint qt_meta_data_QCPItemStraightLine[] = {
5554
5555
 // content:
5556
       8,       // revision
5557
       0,       // classname
5558
       0,    0, // classinfo
5559
       0,    0, // methods
5560
       2,   14, // properties
5561
       0,    0, // enums/sets
5562
       0,    0, // constructors
5563
       0,       // flags
5564
       0,       // signalCount
5565
5566
 // properties: name, type, flags
5567
       1, QMetaType::QPen, 0x00095103,
5568
       2, QMetaType::QPen, 0x00095103,
5569
5570
       0        // eod
5571
};
5572
5573
void QCPItemStraightLine::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
5574
{
5575
5576
#ifndef QT_NO_PROPERTIES
5577
    if (_c == QMetaObject::ReadProperty) {
5578
        auto *_t = static_cast<QCPItemStraightLine *>(_o);
5579
        Q_UNUSED(_t)
5580
        void *_v = _a[0];
5581
        switch (_id) {
5582
        case 0: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
5583
        case 1: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
5584
        default: break;
5585
        }
5586
    } else if (_c == QMetaObject::WriteProperty) {
5587
        auto *_t = static_cast<QCPItemStraightLine *>(_o);
5588
        Q_UNUSED(_t)
5589
        void *_v = _a[0];
5590
        switch (_id) {
5591
        case 0: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
5592
        case 1: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
5593
        default: break;
5594
        }
5595
    } else if (_c == QMetaObject::ResetProperty) {
5596
    }
5597
#endif // QT_NO_PROPERTIES
5598
    Q_UNUSED(_o);
5599
    Q_UNUSED(_id);
5600
    Q_UNUSED(_c);
5601
    Q_UNUSED(_a);
5602
}
5603
5604
QT_INIT_METAOBJECT const QMetaObject QCPItemStraightLine::staticMetaObject = { {
5605
    &QCPAbstractItem::staticMetaObject,
5606
    qt_meta_stringdata_QCPItemStraightLine.data,
5607
    qt_meta_data_QCPItemStraightLine,
5608
    qt_static_metacall,
5609
    nullptr,
5610
    nullptr
5611
} };
5612
5613
5614
const QMetaObject *QCPItemStraightLine::metaObject() const
5615
{
5616
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
5617
}
5618
5619
void *QCPItemStraightLine::qt_metacast(const char *_clname)
5620
{
5621
    if (!_clname) return nullptr;
5622
    if (!strcmp(_clname, qt_meta_stringdata_QCPItemStraightLine.stringdata0))
5623
        return static_cast<void*>(this);
5624
    return QCPAbstractItem::qt_metacast(_clname);
5625
}
5626
5627
int QCPItemStraightLine::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
5628
{
5629
    _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
5630
    if (_id < 0)
5631
        return _id;
5632
5633
#ifndef QT_NO_PROPERTIES
5634
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
5635
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
5636
        qt_static_metacall(this, _c, _id, _a);
5637
        _id -= 2;
5638
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
5639
        _id -= 2;
5640
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
5641
        _id -= 2;
5642
    } else if (_c == QMetaObject::QueryPropertyStored) {
5643
        _id -= 2;
5644
    } else if (_c == QMetaObject::QueryPropertyEditable) {
5645
        _id -= 2;
5646
    } else if (_c == QMetaObject::QueryPropertyUser) {
5647
        _id -= 2;
5648
    }
5649
#endif // QT_NO_PROPERTIES
5650
    return _id;
5651
}
5652
struct qt_meta_stringdata_QCPItemLine_t {
5653
    QByteArrayData data[6];
5654
    char stringdata0[52];
5655
};
5656
#define QT_MOC_LITERAL(idx, ofs, len) \
5657
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
5658
    qptrdiff(offsetof(qt_meta_stringdata_QCPItemLine_t, stringdata0) + ofs \
5659
        - idx * sizeof(QByteArrayData)) \
5660
    )
5661
static const qt_meta_stringdata_QCPItemLine_t qt_meta_stringdata_QCPItemLine = {
5662
    {
5663
QT_MOC_LITERAL(0, 0, 11), // "QCPItemLine"
5664
QT_MOC_LITERAL(1, 12, 3), // "pen"
5665
QT_MOC_LITERAL(2, 16, 11), // "selectedPen"
5666
QT_MOC_LITERAL(3, 28, 4), // "head"
5667
QT_MOC_LITERAL(4, 33, 13), // "QCPLineEnding"
5668
QT_MOC_LITERAL(5, 47, 4) // "tail"
5669
5670
    },
5671
    "QCPItemLine\0pen\0selectedPen\0head\0"
5672
    "QCPLineEnding\0tail"
5673
};
5674
#undef QT_MOC_LITERAL
5675
5676
static const uint qt_meta_data_QCPItemLine[] = {
5677
5678
 // content:
5679
       8,       // revision
5680
       0,       // classname
5681
       0,    0, // classinfo
5682
       0,    0, // methods
5683
       4,   14, // properties
5684
       0,    0, // enums/sets
5685
       0,    0, // constructors
5686
       0,       // flags
5687
       0,       // signalCount
5688
5689
 // properties: name, type, flags
5690
       1, QMetaType::QPen, 0x00095103,
5691
       2, QMetaType::QPen, 0x00095103,
5692
       3, 0x80000000 | 4, 0x0009510b,
5693
       5, 0x80000000 | 4, 0x0009510b,
5694
5695
       0        // eod
5696
};
5697
5698
void QCPItemLine::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
5699
{
5700
5701
#ifndef QT_NO_PROPERTIES
5702
    if (_c == QMetaObject::ReadProperty) {
5703
        auto *_t = static_cast<QCPItemLine *>(_o);
5704
        Q_UNUSED(_t)
5705
        void *_v = _a[0];
5706
        switch (_id) {
5707
        case 0: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
5708
        case 1: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
5709
        case 2: *reinterpret_cast< QCPLineEnding*>(_v) = _t->head(); break;
5710
        case 3: *reinterpret_cast< QCPLineEnding*>(_v) = _t->tail(); break;
5711
        default: break;
5712
        }
5713
    } else if (_c == QMetaObject::WriteProperty) {
5714
        auto *_t = static_cast<QCPItemLine *>(_o);
5715
        Q_UNUSED(_t)
5716
        void *_v = _a[0];
5717
        switch (_id) {
5718
        case 0: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
5719
        case 1: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
5720
        case 2: _t->setHead(*reinterpret_cast< QCPLineEnding*>(_v)); break;
5721
        case 3: _t->setTail(*reinterpret_cast< QCPLineEnding*>(_v)); break;
5722
        default: break;
5723
        }
5724
    } else if (_c == QMetaObject::ResetProperty) {
5725
    }
5726
#endif // QT_NO_PROPERTIES
5727
    Q_UNUSED(_o);
5728
    Q_UNUSED(_id);
5729
    Q_UNUSED(_c);
5730
    Q_UNUSED(_a);
5731
}
5732
5733
QT_INIT_METAOBJECT const QMetaObject QCPItemLine::staticMetaObject = { {
5734
    &QCPAbstractItem::staticMetaObject,
5735
    qt_meta_stringdata_QCPItemLine.data,
5736
    qt_meta_data_QCPItemLine,
5737
    qt_static_metacall,
5738
    nullptr,
5739
    nullptr
5740
} };
5741
5742
5743
const QMetaObject *QCPItemLine::metaObject() const
5744
{
5745
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
5746
}
5747
5748
void *QCPItemLine::qt_metacast(const char *_clname)
5749
{
5750
    if (!_clname) return nullptr;
5751
    if (!strcmp(_clname, qt_meta_stringdata_QCPItemLine.stringdata0))
5752
        return static_cast<void*>(this);
5753
    return QCPAbstractItem::qt_metacast(_clname);
5754
}
5755
5756
int QCPItemLine::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
5757
{
5758
    _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
5759
    if (_id < 0)
5760
        return _id;
5761
5762
#ifndef QT_NO_PROPERTIES
5763
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
5764
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
5765
        qt_static_metacall(this, _c, _id, _a);
5766
        _id -= 4;
5767
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
5768
        _id -= 4;
5769
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
5770
        _id -= 4;
5771
    } else if (_c == QMetaObject::QueryPropertyStored) {
5772
        _id -= 4;
5773
    } else if (_c == QMetaObject::QueryPropertyEditable) {
5774
        _id -= 4;
5775
    } else if (_c == QMetaObject::QueryPropertyUser) {
5776
        _id -= 4;
5777
    }
5778
#endif // QT_NO_PROPERTIES
5779
    return _id;
5780
}
5781
struct qt_meta_stringdata_QCPItemCurve_t {
5782
    QByteArrayData data[6];
5783
    char stringdata0[53];
5784
};
5785
#define QT_MOC_LITERAL(idx, ofs, len) \
5786
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
5787
    qptrdiff(offsetof(qt_meta_stringdata_QCPItemCurve_t, stringdata0) + ofs \
5788
        - idx * sizeof(QByteArrayData)) \
5789
    )
5790
static const qt_meta_stringdata_QCPItemCurve_t qt_meta_stringdata_QCPItemCurve = {
5791
    {
5792
QT_MOC_LITERAL(0, 0, 12), // "QCPItemCurve"
5793
QT_MOC_LITERAL(1, 13, 3), // "pen"
5794
QT_MOC_LITERAL(2, 17, 11), // "selectedPen"
5795
QT_MOC_LITERAL(3, 29, 4), // "head"
5796
QT_MOC_LITERAL(4, 34, 13), // "QCPLineEnding"
5797
QT_MOC_LITERAL(5, 48, 4) // "tail"
5798
5799
    },
5800
    "QCPItemCurve\0pen\0selectedPen\0head\0"
5801
    "QCPLineEnding\0tail"
5802
};
5803
#undef QT_MOC_LITERAL
5804
5805
static const uint qt_meta_data_QCPItemCurve[] = {
5806
5807
 // content:
5808
       8,       // revision
5809
       0,       // classname
5810
       0,    0, // classinfo
5811
       0,    0, // methods
5812
       4,   14, // properties
5813
       0,    0, // enums/sets
5814
       0,    0, // constructors
5815
       0,       // flags
5816
       0,       // signalCount
5817
5818
 // properties: name, type, flags
5819
       1, QMetaType::QPen, 0x00095103,
5820
       2, QMetaType::QPen, 0x00095103,
5821
       3, 0x80000000 | 4, 0x0009510b,
5822
       5, 0x80000000 | 4, 0x0009510b,
5823
5824
       0        // eod
5825
};
5826
5827
void QCPItemCurve::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
5828
{
5829
5830
#ifndef QT_NO_PROPERTIES
5831
    if (_c == QMetaObject::ReadProperty) {
5832
        auto *_t = static_cast<QCPItemCurve *>(_o);
5833
        Q_UNUSED(_t)
5834
        void *_v = _a[0];
5835
        switch (_id) {
5836
        case 0: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
5837
        case 1: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
5838
        case 2: *reinterpret_cast< QCPLineEnding*>(_v) = _t->head(); break;
5839
        case 3: *reinterpret_cast< QCPLineEnding*>(_v) = _t->tail(); break;
5840
        default: break;
5841
        }
5842
    } else if (_c == QMetaObject::WriteProperty) {
5843
        auto *_t = static_cast<QCPItemCurve *>(_o);
5844
        Q_UNUSED(_t)
5845
        void *_v = _a[0];
5846
        switch (_id) {
5847
        case 0: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
5848
        case 1: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
5849
        case 2: _t->setHead(*reinterpret_cast< QCPLineEnding*>(_v)); break;
5850
        case 3: _t->setTail(*reinterpret_cast< QCPLineEnding*>(_v)); break;
5851
        default: break;
5852
        }
5853
    } else if (_c == QMetaObject::ResetProperty) {
5854
    }
5855
#endif // QT_NO_PROPERTIES
5856
    Q_UNUSED(_o);
5857
    Q_UNUSED(_id);
5858
    Q_UNUSED(_c);
5859
    Q_UNUSED(_a);
5860
}
5861
5862
QT_INIT_METAOBJECT const QMetaObject QCPItemCurve::staticMetaObject = { {
5863
    &QCPAbstractItem::staticMetaObject,
5864
    qt_meta_stringdata_QCPItemCurve.data,
5865
    qt_meta_data_QCPItemCurve,
5866
    qt_static_metacall,
5867
    nullptr,
5868
    nullptr
5869
} };
5870
5871
5872
const QMetaObject *QCPItemCurve::metaObject() const
5873
{
5874
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
5875
}
5876
5877
void *QCPItemCurve::qt_metacast(const char *_clname)
5878
{
5879
    if (!_clname) return nullptr;
5880
    if (!strcmp(_clname, qt_meta_stringdata_QCPItemCurve.stringdata0))
5881
        return static_cast<void*>(this);
5882
    return QCPAbstractItem::qt_metacast(_clname);
5883
}
5884
5885
int QCPItemCurve::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
5886
{
5887
    _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
5888
    if (_id < 0)
5889
        return _id;
5890
5891
#ifndef QT_NO_PROPERTIES
5892
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
5893
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
5894
        qt_static_metacall(this, _c, _id, _a);
5895
        _id -= 4;
5896
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
5897
        _id -= 4;
5898
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
5899
        _id -= 4;
5900
    } else if (_c == QMetaObject::QueryPropertyStored) {
5901
        _id -= 4;
5902
    } else if (_c == QMetaObject::QueryPropertyEditable) {
5903
        _id -= 4;
5904
    } else if (_c == QMetaObject::QueryPropertyUser) {
5905
        _id -= 4;
5906
    }
5907
#endif // QT_NO_PROPERTIES
5908
    return _id;
5909
}
5910
struct qt_meta_stringdata_QCPItemRect_t {
5911
    QByteArrayData data[5];
5912
    char stringdata0[48];
5913
};
5914
#define QT_MOC_LITERAL(idx, ofs, len) \
5915
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
5916
    qptrdiff(offsetof(qt_meta_stringdata_QCPItemRect_t, stringdata0) + ofs \
5917
        - idx * sizeof(QByteArrayData)) \
5918
    )
5919
static const qt_meta_stringdata_QCPItemRect_t qt_meta_stringdata_QCPItemRect = {
5920
    {
5921
QT_MOC_LITERAL(0, 0, 11), // "QCPItemRect"
5922
QT_MOC_LITERAL(1, 12, 3), // "pen"
5923
QT_MOC_LITERAL(2, 16, 11), // "selectedPen"
5924
QT_MOC_LITERAL(3, 28, 5), // "brush"
5925
QT_MOC_LITERAL(4, 34, 13) // "selectedBrush"
5926
5927
    },
5928
    "QCPItemRect\0pen\0selectedPen\0brush\0"
5929
    "selectedBrush"
5930
};
5931
#undef QT_MOC_LITERAL
5932
5933
static const uint qt_meta_data_QCPItemRect[] = {
5934
5935
 // content:
5936
       8,       // revision
5937
       0,       // classname
5938
       0,    0, // classinfo
5939
       0,    0, // methods
5940
       4,   14, // properties
5941
       0,    0, // enums/sets
5942
       0,    0, // constructors
5943
       0,       // flags
5944
       0,       // signalCount
5945
5946
 // properties: name, type, flags
5947
       1, QMetaType::QPen, 0x00095103,
5948
       2, QMetaType::QPen, 0x00095103,
5949
       3, QMetaType::QBrush, 0x00095103,
5950
       4, QMetaType::QBrush, 0x00095103,
5951
5952
       0        // eod
5953
};
5954
5955
void QCPItemRect::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
5956
{
5957
5958
#ifndef QT_NO_PROPERTIES
5959
    if (_c == QMetaObject::ReadProperty) {
5960
        auto *_t = static_cast<QCPItemRect *>(_o);
5961
        Q_UNUSED(_t)
5962
        void *_v = _a[0];
5963
        switch (_id) {
5964
        case 0: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
5965
        case 1: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
5966
        case 2: *reinterpret_cast< QBrush*>(_v) = _t->brush(); break;
5967
        case 3: *reinterpret_cast< QBrush*>(_v) = _t->selectedBrush(); break;
5968
        default: break;
5969
        }
5970
    } else if (_c == QMetaObject::WriteProperty) {
5971
        auto *_t = static_cast<QCPItemRect *>(_o);
5972
        Q_UNUSED(_t)
5973
        void *_v = _a[0];
5974
        switch (_id) {
5975
        case 0: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
5976
        case 1: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
5977
        case 2: _t->setBrush(*reinterpret_cast< QBrush*>(_v)); break;
5978
        case 3: _t->setSelectedBrush(*reinterpret_cast< QBrush*>(_v)); break;
5979
        default: break;
5980
        }
5981
    } else if (_c == QMetaObject::ResetProperty) {
5982
    }
5983
#endif // QT_NO_PROPERTIES
5984
    Q_UNUSED(_o);
5985
    Q_UNUSED(_id);
5986
    Q_UNUSED(_c);
5987
    Q_UNUSED(_a);
5988
}
5989
5990
QT_INIT_METAOBJECT const QMetaObject QCPItemRect::staticMetaObject = { {
5991
    &QCPAbstractItem::staticMetaObject,
5992
    qt_meta_stringdata_QCPItemRect.data,
5993
    qt_meta_data_QCPItemRect,
5994
    qt_static_metacall,
5995
    nullptr,
5996
    nullptr
5997
} };
5998
5999
6000
const QMetaObject *QCPItemRect::metaObject() const
6001
{
6002
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
6003
}
6004
6005
void *QCPItemRect::qt_metacast(const char *_clname)
6006
{
6007
    if (!_clname) return nullptr;
6008
    if (!strcmp(_clname, qt_meta_stringdata_QCPItemRect.stringdata0))
6009
        return static_cast<void*>(this);
6010
    return QCPAbstractItem::qt_metacast(_clname);
6011
}
6012
6013
int QCPItemRect::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
6014
{
6015
    _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
6016
    if (_id < 0)
6017
        return _id;
6018
6019
#ifndef QT_NO_PROPERTIES
6020
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
6021
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
6022
        qt_static_metacall(this, _c, _id, _a);
6023
        _id -= 4;
6024
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
6025
        _id -= 4;
6026
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
6027
        _id -= 4;
6028
    } else if (_c == QMetaObject::QueryPropertyStored) {
6029
        _id -= 4;
6030
    } else if (_c == QMetaObject::QueryPropertyEditable) {
6031
        _id -= 4;
6032
    } else if (_c == QMetaObject::QueryPropertyUser) {
6033
        _id -= 4;
6034
    }
6035
#endif // QT_NO_PROPERTIES
6036
    return _id;
6037
}
6038
struct qt_meta_stringdata_QCPItemText_t {
6039
    QByteArrayData data[16];
6040
    char stringdata0[163];
6041
};
6042
#define QT_MOC_LITERAL(idx, ofs, len) \
6043
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
6044
    qptrdiff(offsetof(qt_meta_stringdata_QCPItemText_t, stringdata0) + ofs \
6045
        - idx * sizeof(QByteArrayData)) \
6046
    )
6047
static const qt_meta_stringdata_QCPItemText_t qt_meta_stringdata_QCPItemText = {
6048
    {
6049
QT_MOC_LITERAL(0, 0, 11), // "QCPItemText"
6050
QT_MOC_LITERAL(1, 12, 5), // "color"
6051
QT_MOC_LITERAL(2, 18, 13), // "selectedColor"
6052
QT_MOC_LITERAL(3, 32, 3), // "pen"
6053
QT_MOC_LITERAL(4, 36, 11), // "selectedPen"
6054
QT_MOC_LITERAL(5, 48, 5), // "brush"
6055
QT_MOC_LITERAL(6, 54, 13), // "selectedBrush"
6056
QT_MOC_LITERAL(7, 68, 4), // "font"
6057
QT_MOC_LITERAL(8, 73, 12), // "selectedFont"
6058
QT_MOC_LITERAL(9, 86, 4), // "text"
6059
QT_MOC_LITERAL(10, 91, 17), // "positionAlignment"
6060
QT_MOC_LITERAL(11, 109, 13), // "Qt::Alignment"
6061
QT_MOC_LITERAL(12, 123, 13), // "textAlignment"
6062
QT_MOC_LITERAL(13, 137, 8), // "rotation"
6063
QT_MOC_LITERAL(14, 146, 7), // "padding"
6064
QT_MOC_LITERAL(15, 154, 8) // "QMargins"
6065
6066
    },
6067
    "QCPItemText\0color\0selectedColor\0pen\0"
6068
    "selectedPen\0brush\0selectedBrush\0font\0"
6069
    "selectedFont\0text\0positionAlignment\0"
6070
    "Qt::Alignment\0textAlignment\0rotation\0"
6071
    "padding\0QMargins"
6072
};
6073
#undef QT_MOC_LITERAL
6074
6075
static const uint qt_meta_data_QCPItemText[] = {
6076
6077
 // content:
6078
       8,       // revision
6079
       0,       // classname
6080
       0,    0, // classinfo
6081
       0,    0, // methods
6082
      13,   14, // properties
6083
       0,    0, // enums/sets
6084
       0,    0, // constructors
6085
       0,       // flags
6086
       0,       // signalCount
6087
6088
 // properties: name, type, flags
6089
       1, QMetaType::QColor, 0x00095103,
6090
       2, QMetaType::QColor, 0x00095103,
6091
       3, QMetaType::QPen, 0x00095103,
6092
       4, QMetaType::QPen, 0x00095103,
6093
       5, QMetaType::QBrush, 0x00095103,
6094
       6, QMetaType::QBrush, 0x00095103,
6095
       7, QMetaType::QFont, 0x00095103,
6096
       8, QMetaType::QFont, 0x00095103,
6097
       9, QMetaType::QString, 0x00095103,
6098
      10, 0x80000000 | 11, 0x0009510b,
6099
      12, 0x80000000 | 11, 0x0009510b,
6100
      13, QMetaType::Double, 0x00095103,
6101
      14, 0x80000000 | 15, 0x0009510b,
6102
6103
       0        // eod
6104
};
6105
6106
void QCPItemText::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
6107
{
6108
6109
#ifndef QT_NO_PROPERTIES
6110
    if (_c == QMetaObject::ReadProperty) {
6111
        auto *_t = static_cast<QCPItemText *>(_o);
6112
        Q_UNUSED(_t)
6113
        void *_v = _a[0];
6114
        switch (_id) {
6115
        case 0: *reinterpret_cast< QColor*>(_v) = _t->color(); break;
6116
        case 1: *reinterpret_cast< QColor*>(_v) = _t->selectedColor(); break;
6117
        case 2: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
6118
        case 3: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
6119
        case 4: *reinterpret_cast< QBrush*>(_v) = _t->brush(); break;
6120
        case 5: *reinterpret_cast< QBrush*>(_v) = _t->selectedBrush(); break;
6121
        case 6: *reinterpret_cast< QFont*>(_v) = _t->font(); break;
6122
        case 7: *reinterpret_cast< QFont*>(_v) = _t->selectedFont(); break;
6123
        case 8: *reinterpret_cast< QString*>(_v) = _t->text(); break;
6124
        case 9: *reinterpret_cast< Qt::Alignment*>(_v) = _t->positionAlignment(); break;
6125
        case 10: *reinterpret_cast< Qt::Alignment*>(_v) = _t->textAlignment(); break;
6126
        case 11: *reinterpret_cast< double*>(_v) = _t->rotation(); break;
6127
        case 12: *reinterpret_cast< QMargins*>(_v) = _t->padding(); break;
6128
        default: break;
6129
        }
6130
    } else if (_c == QMetaObject::WriteProperty) {
6131
        auto *_t = static_cast<QCPItemText *>(_o);
6132
        Q_UNUSED(_t)
6133
        void *_v = _a[0];
6134
        switch (_id) {
6135
        case 0: _t->setColor(*reinterpret_cast< QColor*>(_v)); break;
6136
        case 1: _t->setSelectedColor(*reinterpret_cast< QColor*>(_v)); break;
6137
        case 2: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
6138
        case 3: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
6139
        case 4: _t->setBrush(*reinterpret_cast< QBrush*>(_v)); break;
6140
        case 5: _t->setSelectedBrush(*reinterpret_cast< QBrush*>(_v)); break;
6141
        case 6: _t->setFont(*reinterpret_cast< QFont*>(_v)); break;
6142
        case 7: _t->setSelectedFont(*reinterpret_cast< QFont*>(_v)); break;
6143
        case 8: _t->setText(*reinterpret_cast< QString*>(_v)); break;
6144
        case 9: _t->setPositionAlignment(*reinterpret_cast< Qt::Alignment*>(_v)); break;
6145
        case 10: _t->setTextAlignment(*reinterpret_cast< Qt::Alignment*>(_v)); break;
6146
        case 11: _t->setRotation(*reinterpret_cast< double*>(_v)); break;
6147
        case 12: _t->setPadding(*reinterpret_cast< QMargins*>(_v)); break;
6148
        default: break;
6149
        }
6150
    } else if (_c == QMetaObject::ResetProperty) {
6151
    }
6152
#endif // QT_NO_PROPERTIES
6153
    Q_UNUSED(_o);
6154
    Q_UNUSED(_id);
6155
    Q_UNUSED(_c);
6156
    Q_UNUSED(_a);
6157
}
6158
6159
QT_INIT_METAOBJECT const QMetaObject QCPItemText::staticMetaObject = { {
6160
    &QCPAbstractItem::staticMetaObject,
6161
    qt_meta_stringdata_QCPItemText.data,
6162
    qt_meta_data_QCPItemText,
6163
    qt_static_metacall,
6164
    nullptr,
6165
    nullptr
6166
} };
6167
6168
6169
const QMetaObject *QCPItemText::metaObject() const
6170
{
6171
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
6172
}
6173
6174
void *QCPItemText::qt_metacast(const char *_clname)
6175
{
6176
    if (!_clname) return nullptr;
6177
    if (!strcmp(_clname, qt_meta_stringdata_QCPItemText.stringdata0))
6178
        return static_cast<void*>(this);
6179
    return QCPAbstractItem::qt_metacast(_clname);
6180
}
6181
6182
int QCPItemText::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
6183
{
6184
    _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
6185
    if (_id < 0)
6186
        return _id;
6187
6188
#ifndef QT_NO_PROPERTIES
6189
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
6190
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
6191
        qt_static_metacall(this, _c, _id, _a);
6192
        _id -= 13;
6193
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
6194
        _id -= 13;
6195
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
6196
        _id -= 13;
6197
    } else if (_c == QMetaObject::QueryPropertyStored) {
6198
        _id -= 13;
6199
    } else if (_c == QMetaObject::QueryPropertyEditable) {
6200
        _id -= 13;
6201
    } else if (_c == QMetaObject::QueryPropertyUser) {
6202
        _id -= 13;
6203
    }
6204
#endif // QT_NO_PROPERTIES
6205
    return _id;
6206
}
6207
struct qt_meta_stringdata_QCPItemEllipse_t {
6208
    QByteArrayData data[5];
6209
    char stringdata0[51];
6210
};
6211
#define QT_MOC_LITERAL(idx, ofs, len) \
6212
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
6213
    qptrdiff(offsetof(qt_meta_stringdata_QCPItemEllipse_t, stringdata0) + ofs \
6214
        - idx * sizeof(QByteArrayData)) \
6215
    )
6216
static const qt_meta_stringdata_QCPItemEllipse_t qt_meta_stringdata_QCPItemEllipse = {
6217
    {
6218
QT_MOC_LITERAL(0, 0, 14), // "QCPItemEllipse"
6219
QT_MOC_LITERAL(1, 15, 3), // "pen"
6220
QT_MOC_LITERAL(2, 19, 11), // "selectedPen"
6221
QT_MOC_LITERAL(3, 31, 5), // "brush"
6222
QT_MOC_LITERAL(4, 37, 13) // "selectedBrush"
6223
6224
    },
6225
    "QCPItemEllipse\0pen\0selectedPen\0brush\0"
6226
    "selectedBrush"
6227
};
6228
#undef QT_MOC_LITERAL
6229
6230
static const uint qt_meta_data_QCPItemEllipse[] = {
6231
6232
 // content:
6233
       8,       // revision
6234
       0,       // classname
6235
       0,    0, // classinfo
6236
       0,    0, // methods
6237
       4,   14, // properties
6238
       0,    0, // enums/sets
6239
       0,    0, // constructors
6240
       0,       // flags
6241
       0,       // signalCount
6242
6243
 // properties: name, type, flags
6244
       1, QMetaType::QPen, 0x00095103,
6245
       2, QMetaType::QPen, 0x00095103,
6246
       3, QMetaType::QBrush, 0x00095103,
6247
       4, QMetaType::QBrush, 0x00095103,
6248
6249
       0        // eod
6250
};
6251
6252
void QCPItemEllipse::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
6253
{
6254
6255
#ifndef QT_NO_PROPERTIES
6256
    if (_c == QMetaObject::ReadProperty) {
6257
        auto *_t = static_cast<QCPItemEllipse *>(_o);
6258
        Q_UNUSED(_t)
6259
        void *_v = _a[0];
6260
        switch (_id) {
6261
        case 0: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
6262
        case 1: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
6263
        case 2: *reinterpret_cast< QBrush*>(_v) = _t->brush(); break;
6264
        case 3: *reinterpret_cast< QBrush*>(_v) = _t->selectedBrush(); break;
6265
        default: break;
6266
        }
6267
    } else if (_c == QMetaObject::WriteProperty) {
6268
        auto *_t = static_cast<QCPItemEllipse *>(_o);
6269
        Q_UNUSED(_t)
6270
        void *_v = _a[0];
6271
        switch (_id) {
6272
        case 0: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
6273
        case 1: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
6274
        case 2: _t->setBrush(*reinterpret_cast< QBrush*>(_v)); break;
6275
        case 3: _t->setSelectedBrush(*reinterpret_cast< QBrush*>(_v)); break;
6276
        default: break;
6277
        }
6278
    } else if (_c == QMetaObject::ResetProperty) {
6279
    }
6280
#endif // QT_NO_PROPERTIES
6281
    Q_UNUSED(_o);
6282
    Q_UNUSED(_id);
6283
    Q_UNUSED(_c);
6284
    Q_UNUSED(_a);
6285
}
6286
6287
QT_INIT_METAOBJECT const QMetaObject QCPItemEllipse::staticMetaObject = { {
6288
    &QCPAbstractItem::staticMetaObject,
6289
    qt_meta_stringdata_QCPItemEllipse.data,
6290
    qt_meta_data_QCPItemEllipse,
6291
    qt_static_metacall,
6292
    nullptr,
6293
    nullptr
6294
} };
6295
6296
6297
const QMetaObject *QCPItemEllipse::metaObject() const
6298
{
6299
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
6300
}
6301
6302
void *QCPItemEllipse::qt_metacast(const char *_clname)
6303
{
6304
    if (!_clname) return nullptr;
6305
    if (!strcmp(_clname, qt_meta_stringdata_QCPItemEllipse.stringdata0))
6306
        return static_cast<void*>(this);
6307
    return QCPAbstractItem::qt_metacast(_clname);
6308
}
6309
6310
int QCPItemEllipse::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
6311
{
6312
    _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
6313
    if (_id < 0)
6314
        return _id;
6315
6316
#ifndef QT_NO_PROPERTIES
6317
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
6318
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
6319
        qt_static_metacall(this, _c, _id, _a);
6320
        _id -= 4;
6321
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
6322
        _id -= 4;
6323
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
6324
        _id -= 4;
6325
    } else if (_c == QMetaObject::QueryPropertyStored) {
6326
        _id -= 4;
6327
    } else if (_c == QMetaObject::QueryPropertyEditable) {
6328
        _id -= 4;
6329
    } else if (_c == QMetaObject::QueryPropertyUser) {
6330
        _id -= 4;
6331
    }
6332
#endif // QT_NO_PROPERTIES
6333
    return _id;
6334
}
6335
struct qt_meta_stringdata_QCPItemPixmap_t {
6336
    QByteArrayData data[9];
6337
    char stringdata0[122];
6338
};
6339
#define QT_MOC_LITERAL(idx, ofs, len) \
6340
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
6341
    qptrdiff(offsetof(qt_meta_stringdata_QCPItemPixmap_t, stringdata0) + ofs \
6342
        - idx * sizeof(QByteArrayData)) \
6343
    )
6344
static const qt_meta_stringdata_QCPItemPixmap_t qt_meta_stringdata_QCPItemPixmap = {
6345
    {
6346
QT_MOC_LITERAL(0, 0, 13), // "QCPItemPixmap"
6347
QT_MOC_LITERAL(1, 14, 6), // "pixmap"
6348
QT_MOC_LITERAL(2, 21, 6), // "scaled"
6349
QT_MOC_LITERAL(3, 28, 15), // "aspectRatioMode"
6350
QT_MOC_LITERAL(4, 44, 19), // "Qt::AspectRatioMode"
6351
QT_MOC_LITERAL(5, 64, 18), // "transformationMode"
6352
QT_MOC_LITERAL(6, 83, 22), // "Qt::TransformationMode"
6353
QT_MOC_LITERAL(7, 106, 3), // "pen"
6354
QT_MOC_LITERAL(8, 110, 11) // "selectedPen"
6355
6356
    },
6357
    "QCPItemPixmap\0pixmap\0scaled\0aspectRatioMode\0"
6358
    "Qt::AspectRatioMode\0transformationMode\0"
6359
    "Qt::TransformationMode\0pen\0selectedPen"
6360
};
6361
#undef QT_MOC_LITERAL
6362
6363
static const uint qt_meta_data_QCPItemPixmap[] = {
6364
6365
 // content:
6366
       8,       // revision
6367
       0,       // classname
6368
       0,    0, // classinfo
6369
       0,    0, // methods
6370
       6,   14, // properties
6371
       0,    0, // enums/sets
6372
       0,    0, // constructors
6373
       0,       // flags
6374
       0,       // signalCount
6375
6376
 // properties: name, type, flags
6377
       1, QMetaType::QPixmap, 0x00095103,
6378
       2, QMetaType::Bool, 0x00095103,
6379
       3, 0x80000000 | 4, 0x00095009,
6380
       5, 0x80000000 | 6, 0x00095009,
6381
       7, QMetaType::QPen, 0x00095103,
6382
       8, QMetaType::QPen, 0x00095103,
6383
6384
       0        // eod
6385
};
6386
6387
void QCPItemPixmap::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
6388
{
6389
6390
#ifndef QT_NO_PROPERTIES
6391
    if (_c == QMetaObject::ReadProperty) {
6392
        auto *_t = static_cast<QCPItemPixmap *>(_o);
6393
        Q_UNUSED(_t)
6394
        void *_v = _a[0];
6395
        switch (_id) {
6396
        case 0: *reinterpret_cast< QPixmap*>(_v) = _t->pixmap(); break;
6397
        case 1: *reinterpret_cast< bool*>(_v) = _t->scaled(); break;
6398
        case 2: *reinterpret_cast< Qt::AspectRatioMode*>(_v) = _t->aspectRatioMode(); break;
6399
        case 3: *reinterpret_cast< Qt::TransformationMode*>(_v) = _t->transformationMode(); break;
6400
        case 4: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
6401
        case 5: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
6402
        default: break;
6403
        }
6404
    } else if (_c == QMetaObject::WriteProperty) {
6405
        auto *_t = static_cast<QCPItemPixmap *>(_o);
6406
        Q_UNUSED(_t)
6407
        void *_v = _a[0];
6408
        switch (_id) {
6409
        case 0: _t->setPixmap(*reinterpret_cast< QPixmap*>(_v)); break;
6410
        case 1: _t->setScaled(*reinterpret_cast< bool*>(_v)); break;
6411
        case 4: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
6412
        case 5: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
6413
        default: break;
6414
        }
6415
    } else if (_c == QMetaObject::ResetProperty) {
6416
    }
6417
#endif // QT_NO_PROPERTIES
6418
    Q_UNUSED(_o);
6419
    Q_UNUSED(_id);
6420
    Q_UNUSED(_c);
6421
    Q_UNUSED(_a);
6422
}
6423
6424
QT_INIT_METAOBJECT const QMetaObject QCPItemPixmap::staticMetaObject = { {
6425
    &QCPAbstractItem::staticMetaObject,
6426
    qt_meta_stringdata_QCPItemPixmap.data,
6427
    qt_meta_data_QCPItemPixmap,
6428
    qt_static_metacall,
6429
    nullptr,
6430
    nullptr
6431
} };
6432
6433
6434
const QMetaObject *QCPItemPixmap::metaObject() const
6435
{
6436
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
6437
}
6438
6439
void *QCPItemPixmap::qt_metacast(const char *_clname)
6440
{
6441
    if (!_clname) return nullptr;
6442
    if (!strcmp(_clname, qt_meta_stringdata_QCPItemPixmap.stringdata0))
6443
        return static_cast<void*>(this);
6444
    return QCPAbstractItem::qt_metacast(_clname);
6445
}
6446
6447
int QCPItemPixmap::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
6448
{
6449
    _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
6450
    if (_id < 0)
6451
        return _id;
6452
6453
#ifndef QT_NO_PROPERTIES
6454
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
6455
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
6456
        qt_static_metacall(this, _c, _id, _a);
6457
        _id -= 6;
6458
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
6459
        _id -= 6;
6460
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
6461
        _id -= 6;
6462
    } else if (_c == QMetaObject::QueryPropertyStored) {
6463
        _id -= 6;
6464
    } else if (_c == QMetaObject::QueryPropertyEditable) {
6465
        _id -= 6;
6466
    } else if (_c == QMetaObject::QueryPropertyUser) {
6467
        _id -= 6;
6468
    }
6469
#endif // QT_NO_PROPERTIES
6470
    return _id;
6471
}
6472
struct qt_meta_stringdata_QCPItemTracer_t {
6473
    QByteArrayData data[17];
6474
    char stringdata0[156];
6475
};
6476
#define QT_MOC_LITERAL(idx, ofs, len) \
6477
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
6478
    qptrdiff(offsetof(qt_meta_stringdata_QCPItemTracer_t, stringdata0) + ofs \
6479
        - idx * sizeof(QByteArrayData)) \
6480
    )
6481
static const qt_meta_stringdata_QCPItemTracer_t qt_meta_stringdata_QCPItemTracer = {
6482
    {
6483
QT_MOC_LITERAL(0, 0, 13), // "QCPItemTracer"
6484
QT_MOC_LITERAL(1, 14, 3), // "pen"
6485
QT_MOC_LITERAL(2, 18, 11), // "selectedPen"
6486
QT_MOC_LITERAL(3, 30, 5), // "brush"
6487
QT_MOC_LITERAL(4, 36, 13), // "selectedBrush"
6488
QT_MOC_LITERAL(5, 50, 4), // "size"
6489
QT_MOC_LITERAL(6, 55, 5), // "style"
6490
QT_MOC_LITERAL(7, 61, 11), // "TracerStyle"
6491
QT_MOC_LITERAL(8, 73, 5), // "graph"
6492
QT_MOC_LITERAL(9, 79, 9), // "QCPGraph*"
6493
QT_MOC_LITERAL(10, 89, 8), // "graphKey"
6494
QT_MOC_LITERAL(11, 98, 13), // "interpolating"
6495
QT_MOC_LITERAL(12, 112, 6), // "tsNone"
6496
QT_MOC_LITERAL(13, 119, 6), // "tsPlus"
6497
QT_MOC_LITERAL(14, 126, 11), // "tsCrosshair"
6498
QT_MOC_LITERAL(15, 138, 8), // "tsCircle"
6499
QT_MOC_LITERAL(16, 147, 8) // "tsSquare"
6500
6501
    },
6502
    "QCPItemTracer\0pen\0selectedPen\0brush\0"
6503
    "selectedBrush\0size\0style\0TracerStyle\0"
6504
    "graph\0QCPGraph*\0graphKey\0interpolating\0"
6505
    "tsNone\0tsPlus\0tsCrosshair\0tsCircle\0"
6506
    "tsSquare"
6507
};
6508
#undef QT_MOC_LITERAL
6509
6510
static const uint qt_meta_data_QCPItemTracer[] = {
6511
6512
 // content:
6513
       8,       // revision
6514
       0,       // classname
6515
       0,    0, // classinfo
6516
       0,    0, // methods
6517
       9,   14, // properties
6518
       1,   41, // enums/sets
6519
       0,    0, // constructors
6520
       0,       // flags
6521
       0,       // signalCount
6522
6523
 // properties: name, type, flags
6524
       1, QMetaType::QPen, 0x00095103,
6525
       2, QMetaType::QPen, 0x00095103,
6526
       3, QMetaType::QBrush, 0x00095103,
6527
       4, QMetaType::QBrush, 0x00095103,
6528
       5, QMetaType::Double, 0x00095103,
6529
       6, 0x80000000 | 7, 0x0009510b,
6530
       8, 0x80000000 | 9, 0x0009510b,
6531
      10, QMetaType::Double, 0x00095103,
6532
      11, QMetaType::Bool, 0x00095103,
6533
6534
 // enums: name, alias, flags, count, data
6535
       7,    7, 0x0,    5,   46,
6536
6537
 // enum data: key, value
6538
      12, uint(QCPItemTracer::tsNone),
6539
      13, uint(QCPItemTracer::tsPlus),
6540
      14, uint(QCPItemTracer::tsCrosshair),
6541
      15, uint(QCPItemTracer::tsCircle),
6542
      16, uint(QCPItemTracer::tsSquare),
6543
6544
       0        // eod
6545
};
6546
6547
void QCPItemTracer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
6548
{
6549
    if (_c == QMetaObject::RegisterPropertyMetaType) {
6550
        switch (_id) {
6551
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
6552
        case 6:
6553
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPGraph* >(); break;
6554
        }
6555
    }
6556
6557
#ifndef QT_NO_PROPERTIES
6558
    else if (_c == QMetaObject::ReadProperty) {
6559
        auto *_t = static_cast<QCPItemTracer *>(_o);
6560
        Q_UNUSED(_t)
6561
        void *_v = _a[0];
6562
        switch (_id) {
6563
        case 0: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
6564
        case 1: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
6565
        case 2: *reinterpret_cast< QBrush*>(_v) = _t->brush(); break;
6566
        case 3: *reinterpret_cast< QBrush*>(_v) = _t->selectedBrush(); break;
6567
        case 4: *reinterpret_cast< double*>(_v) = _t->size(); break;
6568
        case 5: *reinterpret_cast< TracerStyle*>(_v) = _t->style(); break;
6569
        case 6: *reinterpret_cast< QCPGraph**>(_v) = _t->graph(); break;
6570
        case 7: *reinterpret_cast< double*>(_v) = _t->graphKey(); break;
6571
        case 8: *reinterpret_cast< bool*>(_v) = _t->interpolating(); break;
6572
        default: break;
6573
        }
6574
    } else if (_c == QMetaObject::WriteProperty) {
6575
        auto *_t = static_cast<QCPItemTracer *>(_o);
6576
        Q_UNUSED(_t)
6577
        void *_v = _a[0];
6578
        switch (_id) {
6579
        case 0: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
6580
        case 1: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
6581
        case 2: _t->setBrush(*reinterpret_cast< QBrush*>(_v)); break;
6582
        case 3: _t->setSelectedBrush(*reinterpret_cast< QBrush*>(_v)); break;
6583
        case 4: _t->setSize(*reinterpret_cast< double*>(_v)); break;
6584
        case 5: _t->setStyle(*reinterpret_cast< TracerStyle*>(_v)); break;
6585
        case 6: _t->setGraph(*reinterpret_cast< QCPGraph**>(_v)); break;
6586
        case 7: _t->setGraphKey(*reinterpret_cast< double*>(_v)); break;
6587
        case 8: _t->setInterpolating(*reinterpret_cast< bool*>(_v)); break;
6588
        default: break;
6589
        }
6590
    } else if (_c == QMetaObject::ResetProperty) {
6591
    }
6592
#endif // QT_NO_PROPERTIES
6593
    Q_UNUSED(_o);
6594
}
6595
6596
QT_INIT_METAOBJECT const QMetaObject QCPItemTracer::staticMetaObject = { {
6597
    &QCPAbstractItem::staticMetaObject,
6598
    qt_meta_stringdata_QCPItemTracer.data,
6599
    qt_meta_data_QCPItemTracer,
6600
    qt_static_metacall,
6601
    nullptr,
6602
    nullptr
6603
} };
6604
6605
6606
const QMetaObject *QCPItemTracer::metaObject() const
6607
{
6608
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
6609
}
6610
6611
void *QCPItemTracer::qt_metacast(const char *_clname)
6612
{
6613
    if (!_clname) return nullptr;
6614
    if (!strcmp(_clname, qt_meta_stringdata_QCPItemTracer.stringdata0))
6615
        return static_cast<void*>(this);
6616
    return QCPAbstractItem::qt_metacast(_clname);
6617
}
6618
6619
int QCPItemTracer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
6620
{
6621
    _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
6622
    if (_id < 0)
6623
        return _id;
6624
6625
#ifndef QT_NO_PROPERTIES
6626
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
6627
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
6628
        qt_static_metacall(this, _c, _id, _a);
6629
        _id -= 9;
6630
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
6631
        _id -= 9;
6632
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
6633
        _id -= 9;
6634
    } else if (_c == QMetaObject::QueryPropertyStored) {
6635
        _id -= 9;
6636
    } else if (_c == QMetaObject::QueryPropertyEditable) {
6637
        _id -= 9;
6638
    } else if (_c == QMetaObject::QueryPropertyUser) {
6639
        _id -= 9;
6640
    }
6641
#endif // QT_NO_PROPERTIES
6642
    return _id;
6643
}
6644
struct qt_meta_stringdata_QCPItemBracket_t {
6645
    QByteArrayData data[6];
6646
    char stringdata0[57];
6647
};
6648
#define QT_MOC_LITERAL(idx, ofs, len) \
6649
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
6650
    qptrdiff(offsetof(qt_meta_stringdata_QCPItemBracket_t, stringdata0) + ofs \
6651
        - idx * sizeof(QByteArrayData)) \
6652
    )
6653
static const qt_meta_stringdata_QCPItemBracket_t qt_meta_stringdata_QCPItemBracket = {
6654
    {
6655
QT_MOC_LITERAL(0, 0, 14), // "QCPItemBracket"
6656
QT_MOC_LITERAL(1, 15, 3), // "pen"
6657
QT_MOC_LITERAL(2, 19, 11), // "selectedPen"
6658
QT_MOC_LITERAL(3, 31, 6), // "length"
6659
QT_MOC_LITERAL(4, 38, 5), // "style"
6660
QT_MOC_LITERAL(5, 44, 12) // "BracketStyle"
6661
6662
    },
6663
    "QCPItemBracket\0pen\0selectedPen\0length\0"
6664
    "style\0BracketStyle"
6665
};
6666
#undef QT_MOC_LITERAL
6667
6668
static const uint qt_meta_data_QCPItemBracket[] = {
6669
6670
 // content:
6671
       8,       // revision
6672
       0,       // classname
6673
       0,    0, // classinfo
6674
       0,    0, // methods
6675
       4,   14, // properties
6676
       0,    0, // enums/sets
6677
       0,    0, // constructors
6678
       0,       // flags
6679
       0,       // signalCount
6680
6681
 // properties: name, type, flags
6682
       1, QMetaType::QPen, 0x00095103,
6683
       2, QMetaType::QPen, 0x00095103,
6684
       3, QMetaType::Double, 0x00095103,
6685
       4, 0x80000000 | 5, 0x0009510b,
6686
6687
       0        // eod
6688
};
6689
6690
void QCPItemBracket::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
6691
{
6692
6693
#ifndef QT_NO_PROPERTIES
6694
    if (_c == QMetaObject::ReadProperty) {
6695
        auto *_t = static_cast<QCPItemBracket *>(_o);
6696
        Q_UNUSED(_t)
6697
        void *_v = _a[0];
6698
        switch (_id) {
6699
        case 0: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
6700
        case 1: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
6701
        case 2: *reinterpret_cast< double*>(_v) = _t->length(); break;
6702
        case 3: *reinterpret_cast< BracketStyle*>(_v) = _t->style(); break;
6703
        default: break;
6704
        }
6705
    } else if (_c == QMetaObject::WriteProperty) {
6706
        auto *_t = static_cast<QCPItemBracket *>(_o);
6707
        Q_UNUSED(_t)
6708
        void *_v = _a[0];
6709
        switch (_id) {
6710
        case 0: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
6711
        case 1: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
6712
        case 2: _t->setLength(*reinterpret_cast< double*>(_v)); break;
6713
        case 3: _t->setStyle(*reinterpret_cast< BracketStyle*>(_v)); break;
6714
        default: break;
6715
        }
6716
    } else if (_c == QMetaObject::ResetProperty) {
6717
    }
6718
#endif // QT_NO_PROPERTIES
6719
    Q_UNUSED(_o);
6720
    Q_UNUSED(_id);
6721
    Q_UNUSED(_c);
6722
    Q_UNUSED(_a);
6723
}
6724
6725
QT_INIT_METAOBJECT const QMetaObject QCPItemBracket::staticMetaObject = { {
6726
    &QCPAbstractItem::staticMetaObject,
6727
    qt_meta_stringdata_QCPItemBracket.data,
6728
    qt_meta_data_QCPItemBracket,
6729
    qt_static_metacall,
6730
    nullptr,
6731
    nullptr
6732
} };
6733
6734
6735
const QMetaObject *QCPItemBracket::metaObject() const
6736
{
6737
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
6738
}
6739
6740
void *QCPItemBracket::qt_metacast(const char *_clname)
6741
{
6742
    if (!_clname) return nullptr;
6743
    if (!strcmp(_clname, qt_meta_stringdata_QCPItemBracket.stringdata0))
6744
        return static_cast<void*>(this);
6745
    return QCPAbstractItem::qt_metacast(_clname);
6746
}
6747
6748
int QCPItemBracket::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
6749
{
6750
    _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
6751
    if (_id < 0)
6752
        return _id;
6753
6754
#ifndef QT_NO_PROPERTIES
6755
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
6756
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
6757
        qt_static_metacall(this, _c, _id, _a);
6758
        _id -= 4;
6759
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
6760
        _id -= 4;
6761
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
6762
        _id -= 4;
6763
    } else if (_c == QMetaObject::QueryPropertyStored) {
6764
        _id -= 4;
6765
    } else if (_c == QMetaObject::QueryPropertyEditable) {
6766
        _id -= 4;
6767
    } else if (_c == QMetaObject::QueryPropertyUser) {
6768
        _id -= 4;
6769
    }
6770
#endif // QT_NO_PROPERTIES
6771
    return _id;
6772
}
6773
QT_WARNING_POP
6774
QT_END_MOC_NAMESPACE