GCC Code Coverage Report

Directory: ./
File: plugins/pyqcustomplot/pyqcustomplot_autogen/MWXTG7G72Q/moc_qcustomplot.cpp
Date: 2024-12-20 15:53:58
Exec Total Coverage
Lines: 0 2267 0.0%
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.15.3)
5 **
6 ** WARNING! All changes made in this file will be lost!
7 *****************************************************************************/
8
9 #include <memory>
10 #include "../../qcustomplot.h"
11 #include <QtCore/qbytearray.h>
12 #include <QtCore/qmetatype.h>
13 #include <QtCore/QList>
14 #include <QtCore/QVector>
15 #if !defined(Q_MOC_OUTPUT_REVISION)
16 #error "The header file 'qcustomplot.h' doesn't include <QObject>."
17 #elif Q_MOC_OUTPUT_REVISION != 67
18 #error "This file was generated using the moc from 5.15.3. It"
19 #error "cannot be used with the include files from this version of Qt."
20 #error "(The moc has changed too much.)"
21 #endif
22
23 QT_BEGIN_MOC_NAMESPACE
24 QT_WARNING_PUSH
25 QT_WARNING_DISABLE_DEPRECATED
26 struct qt_meta_stringdata_QCPScatterStyle_t {
27 QByteArrayData data[20];
28 char stringdata0[209];
29 };
30 #define QT_MOC_LITERAL(idx, ofs, len) \
31 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
32 qptrdiff(offsetof(qt_meta_stringdata_QCPScatterStyle_t, stringdata0) + ofs \
33 - idx * sizeof(QByteArrayData)) \
34 )
35 static const qt_meta_stringdata_QCPScatterStyle_t qt_meta_stringdata_QCPScatterStyle = {
36 {
37 QT_MOC_LITERAL(0, 0, 15), // "QCPScatterStyle"
38 QT_MOC_LITERAL(1, 16, 12), // "ScatterShape"
39 QT_MOC_LITERAL(2, 29, 6), // "ssNone"
40 QT_MOC_LITERAL(3, 36, 5), // "ssDot"
41 QT_MOC_LITERAL(4, 42, 7), // "ssCross"
42 QT_MOC_LITERAL(5, 50, 6), // "ssPlus"
43 QT_MOC_LITERAL(6, 57, 8), // "ssCircle"
44 QT_MOC_LITERAL(7, 66, 6), // "ssDisc"
45 QT_MOC_LITERAL(8, 73, 8), // "ssSquare"
46 QT_MOC_LITERAL(9, 82, 9), // "ssDiamond"
47 QT_MOC_LITERAL(10, 92, 6), // "ssStar"
48 QT_MOC_LITERAL(11, 99, 10), // "ssTriangle"
49 QT_MOC_LITERAL(12, 110, 18), // "ssTriangleInverted"
50 QT_MOC_LITERAL(13, 129, 13), // "ssCrossSquare"
51 QT_MOC_LITERAL(14, 143, 12), // "ssPlusSquare"
52 QT_MOC_LITERAL(15, 156, 13), // "ssCrossCircle"
53 QT_MOC_LITERAL(16, 170, 12), // "ssPlusCircle"
54 QT_MOC_LITERAL(17, 183, 7), // "ssPeace"
55 QT_MOC_LITERAL(18, 191, 8), // "ssPixmap"
56 QT_MOC_LITERAL(19, 200, 8) // "ssCustom"
57
58 },
59 "QCPScatterStyle\0ScatterShape\0ssNone\0"
60 "ssDot\0ssCross\0ssPlus\0ssCircle\0ssDisc\0"
61 "ssSquare\0ssDiamond\0ssStar\0ssTriangle\0"
62 "ssTriangleInverted\0ssCrossSquare\0"
63 "ssPlusSquare\0ssCrossCircle\0ssPlusCircle\0"
64 "ssPeace\0ssPixmap\0ssCustom"
65 };
66 #undef QT_MOC_LITERAL
67
68 static const uint qt_meta_data_QCPScatterStyle[] = {
69
70 // content:
71 8, // revision
72 0, // classname
73 0, 0, // classinfo
74 0, 0, // methods
75 0, 0, // properties
76 1, 14, // enums/sets
77 0, 0, // constructors
78 4, // flags
79 0, // signalCount
80
81 // enums: name, alias, flags, count, data
82 1, 1, 0x0, 18, 19,
83
84 // enum data: key, value
85 2, uint(QCPScatterStyle::ssNone),
86 3, uint(QCPScatterStyle::ssDot),
87 4, uint(QCPScatterStyle::ssCross),
88 5, uint(QCPScatterStyle::ssPlus),
89 6, uint(QCPScatterStyle::ssCircle),
90 7, uint(QCPScatterStyle::ssDisc),
91 8, uint(QCPScatterStyle::ssSquare),
92 9, uint(QCPScatterStyle::ssDiamond),
93 10, uint(QCPScatterStyle::ssStar),
94 11, uint(QCPScatterStyle::ssTriangle),
95 12, uint(QCPScatterStyle::ssTriangleInverted),
96 13, uint(QCPScatterStyle::ssCrossSquare),
97 14, uint(QCPScatterStyle::ssPlusSquare),
98 15, uint(QCPScatterStyle::ssCrossCircle),
99 16, uint(QCPScatterStyle::ssPlusCircle),
100 17, uint(QCPScatterStyle::ssPeace),
101 18, uint(QCPScatterStyle::ssPixmap),
102 19, uint(QCPScatterStyle::ssCustom),
103
104 0 // eod
105 };
106
107 QT_INIT_METAOBJECT const QMetaObject QCPScatterStyle::staticMetaObject = { {
108 nullptr,
109 qt_meta_stringdata_QCPScatterStyle.data,
110 qt_meta_data_QCPScatterStyle,
111 nullptr,
112 nullptr,
113 nullptr
114 } };
115
116 struct qt_meta_stringdata_QCPPainter_t {
117 QByteArrayData data[7];
118 char stringdata0[85];
119 };
120 #define QT_MOC_LITERAL(idx, ofs, len) \
121 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
122 qptrdiff(offsetof(qt_meta_stringdata_QCPPainter_t, stringdata0) + ofs \
123 - idx * sizeof(QByteArrayData)) \
124 )
125 static const qt_meta_stringdata_QCPPainter_t qt_meta_stringdata_QCPPainter = {
126 {
127 QT_MOC_LITERAL(0, 0, 10), // "QCPPainter"
128 QT_MOC_LITERAL(1, 11, 11), // "PainterMode"
129 QT_MOC_LITERAL(2, 23, 9), // "pmDefault"
130 QT_MOC_LITERAL(3, 33, 12), // "pmVectorized"
131 QT_MOC_LITERAL(4, 46, 11), // "pmNoCaching"
132 QT_MOC_LITERAL(5, 58, 13), // "pmNonCosmetic"
133 QT_MOC_LITERAL(6, 72, 12) // "PainterModes"
134
135 },
136 "QCPPainter\0PainterMode\0pmDefault\0"
137 "pmVectorized\0pmNoCaching\0pmNonCosmetic\0"
138 "PainterModes"
139 };
140 #undef QT_MOC_LITERAL
141
142 static const uint qt_meta_data_QCPPainter[] = {
143
144 // content:
145 8, // revision
146 0, // classname
147 0, 0, // classinfo
148 0, 0, // methods
149 0, 0, // properties
150 2, 14, // enums/sets
151 0, 0, // constructors
152 4, // flags
153 0, // signalCount
154
155 // enums: name, alias, flags, count, data
156 1, 1, 0x1, 4, 24,
157 6, 1, 0x1, 4, 32,
158
159 // enum data: key, value
160 2, uint(QCPPainter::pmDefault),
161 3, uint(QCPPainter::pmVectorized),
162 4, uint(QCPPainter::pmNoCaching),
163 5, uint(QCPPainter::pmNonCosmetic),
164 2, uint(QCPPainter::pmDefault),
165 3, uint(QCPPainter::pmVectorized),
166 4, uint(QCPPainter::pmNoCaching),
167 5, uint(QCPPainter::pmNonCosmetic),
168
169 0 // eod
170 };
171
172 QT_INIT_METAOBJECT const QMetaObject QCPPainter::staticMetaObject = { {
173 QtPrivate::MetaObjectForType<QPainter>::value(),
174 qt_meta_stringdata_QCPPainter.data,
175 qt_meta_data_QCPPainter,
176 nullptr,
177 nullptr,
178 nullptr
179 } };
180
181 struct qt_meta_stringdata_QCPLayer_t {
182 QByteArrayData data[8];
183 char stringdata0[82];
184 };
185 #define QT_MOC_LITERAL(idx, ofs, len) \
186 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
187 qptrdiff(offsetof(qt_meta_stringdata_QCPLayer_t, stringdata0) + ofs \
188 - idx * sizeof(QByteArrayData)) \
189 )
190 static const qt_meta_stringdata_QCPLayer_t qt_meta_stringdata_QCPLayer = {
191 {
192 QT_MOC_LITERAL(0, 0, 8), // "QCPLayer"
193 QT_MOC_LITERAL(1, 9, 10), // "parentPlot"
194 QT_MOC_LITERAL(2, 20, 12), // "QCustomPlot*"
195 QT_MOC_LITERAL(3, 33, 4), // "name"
196 QT_MOC_LITERAL(4, 38, 5), // "index"
197 QT_MOC_LITERAL(5, 44, 8), // "children"
198 QT_MOC_LITERAL(6, 53, 20), // "QList<QCPLayerable*>"
199 QT_MOC_LITERAL(7, 74, 7) // "visible"
200
201 },
202 "QCPLayer\0parentPlot\0QCustomPlot*\0name\0"
203 "index\0children\0QList<QCPLayerable*>\0"
204 "visible"
205 };
206 #undef QT_MOC_LITERAL
207
208 static const uint qt_meta_data_QCPLayer[] = {
209
210 // content:
211 8, // revision
212 0, // classname
213 0, 0, // classinfo
214 0, 0, // methods
215 5, 14, // properties
216 0, 0, // enums/sets
217 0, 0, // constructors
218 0, // flags
219 0, // signalCount
220
221 // properties: name, type, flags
222 1, 0x80000000 | 2, 0x00095009,
223 3, QMetaType::QString, 0x00095001,
224 4, QMetaType::Int, 0x00095001,
225 5, 0x80000000 | 6, 0x00095009,
226 7, QMetaType::Bool, 0x00095103,
227
228 0 // eod
229 };
230
231 ✗ void QCPLayer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
232 {
233 ✗ if (_c == QMetaObject::RegisterPropertyMetaType) {
234 ✗ switch (_id) {
235 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
236 ✗ case 0:
237 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCustomPlot* >(); break;
238 ✗ case 3:
239 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<QCPLayerable*> >(); break;
240 }
241 }
242
243 #ifndef QT_NO_PROPERTIES
244 ✗ else if (_c == QMetaObject::ReadProperty) {
245 ✗ auto *_t = static_cast<QCPLayer *>(_o);
246 (void)_t;
247 ✗ void *_v = _a[0];
248 ✗ switch (_id) {
249 ✗ case 0: *reinterpret_cast< QCustomPlot**>(_v) = _t->parentPlot(); break;
250 ✗ case 1: *reinterpret_cast< QString*>(_v) = _t->name(); break;
251 ✗ case 2: *reinterpret_cast< int*>(_v) = _t->index(); break;
252 ✗ case 3: *reinterpret_cast< QList<QCPLayerable*>*>(_v) = _t->children(); break;
253 ✗ case 4: *reinterpret_cast< bool*>(_v) = _t->visible(); break;
254 ✗ default: break;
255 }
256 ✗ } else if (_c == QMetaObject::WriteProperty) {
257 ✗ auto *_t = static_cast<QCPLayer *>(_o);
258 (void)_t;
259 ✗ void *_v = _a[0];
260 ✗ switch (_id) {
261 ✗ case 4: _t->setVisible(*reinterpret_cast< bool*>(_v)); break;
262 ✗ default: break;
263 }
264 } else if (_c == QMetaObject::ResetProperty) {
265 }
266 #endif // QT_NO_PROPERTIES
267 (void)_o;
268 }
269
270 QT_INIT_METAOBJECT const QMetaObject QCPLayer::staticMetaObject = { {
271 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
272 qt_meta_stringdata_QCPLayer.data,
273 qt_meta_data_QCPLayer,
274 qt_static_metacall,
275 nullptr,
276 nullptr
277 } };
278
279
280 ✗ const QMetaObject *QCPLayer::metaObject() const
281 {
282 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
283 }
284
285 ✗ void *QCPLayer::qt_metacast(const char *_clname)
286 {
287 ✗ if (!_clname) return nullptr;
288 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPLayer.stringdata0))
289 ✗ return static_cast<void*>(this);
290 ✗ return QObject::qt_metacast(_clname);
291 }
292
293 ✗ int QCPLayer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
294 {
295 ✗ _id = QObject::qt_metacall(_c, _id, _a);
296 ✗ if (_id < 0)
297 ✗ return _id;
298
299 #ifndef QT_NO_PROPERTIES
300 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
301 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
302 ✗ qt_static_metacall(this, _c, _id, _a);
303 ✗ _id -= 5;
304 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
305 ✗ _id -= 5;
306 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
307 ✗ _id -= 5;
308 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
309 ✗ _id -= 5;
310 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
311 ✗ _id -= 5;
312 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
313 ✗ _id -= 5;
314 }
315 #endif // QT_NO_PROPERTIES
316 ✗ return _id;
317 }
318 struct qt_meta_stringdata_QCPLayerable_t {
319 QByteArrayData data[13];
320 char stringdata0[135];
321 };
322 #define QT_MOC_LITERAL(idx, ofs, len) \
323 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
324 qptrdiff(offsetof(qt_meta_stringdata_QCPLayerable_t, stringdata0) + ofs \
325 - idx * sizeof(QByteArrayData)) \
326 )
327 static const qt_meta_stringdata_QCPLayerable_t qt_meta_stringdata_QCPLayerable = {
328 {
329 QT_MOC_LITERAL(0, 0, 12), // "QCPLayerable"
330 QT_MOC_LITERAL(1, 13, 12), // "layerChanged"
331 QT_MOC_LITERAL(2, 26, 0), // ""
332 QT_MOC_LITERAL(3, 27, 9), // "QCPLayer*"
333 QT_MOC_LITERAL(4, 37, 8), // "newLayer"
334 QT_MOC_LITERAL(5, 46, 8), // "setLayer"
335 QT_MOC_LITERAL(6, 55, 5), // "layer"
336 QT_MOC_LITERAL(7, 61, 7), // "visible"
337 QT_MOC_LITERAL(8, 69, 10), // "parentPlot"
338 QT_MOC_LITERAL(9, 80, 12), // "QCustomPlot*"
339 QT_MOC_LITERAL(10, 93, 15), // "parentLayerable"
340 QT_MOC_LITERAL(11, 109, 13), // "QCPLayerable*"
341 QT_MOC_LITERAL(12, 123, 11) // "antialiased"
342
343 },
344 "QCPLayerable\0layerChanged\0\0QCPLayer*\0"
345 "newLayer\0setLayer\0layer\0visible\0"
346 "parentPlot\0QCustomPlot*\0parentLayerable\0"
347 "QCPLayerable*\0antialiased"
348 };
349 #undef QT_MOC_LITERAL
350
351 static const uint qt_meta_data_QCPLayerable[] = {
352
353 // content:
354 8, // revision
355 0, // classname
356 0, 0, // classinfo
357 2, 14, // methods
358 5, 30, // properties
359 0, 0, // enums/sets
360 0, 0, // constructors
361 0, // flags
362 1, // signalCount
363
364 // signals: name, argc, parameters, tag, flags
365 1, 1, 24, 2, 0x06 /* Public */,
366
367 // slots: name, argc, parameters, tag, flags
368 5, 1, 27, 2, 0x0a /* Public */,
369
370 // signals: parameters
371 QMetaType::Void, 0x80000000 | 3, 4,
372
373 // slots: parameters
374 QMetaType::Bool, 0x80000000 | 3, 6,
375
376 // properties: name, type, flags
377 7, QMetaType::Bool, 0x00095103,
378 8, 0x80000000 | 9, 0x00095009,
379 10, 0x80000000 | 11, 0x00095009,
380 6, 0x80000000 | 3, 0x0049510b,
381 12, QMetaType::Bool, 0x00095103,
382
383 // properties: notify_signal_id
384 0,
385 0,
386 0,
387 0,
388 0,
389
390 0 // eod
391 };
392
393 ✗ void QCPLayerable::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
394 {
395 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
396 ✗ auto *_t = static_cast<QCPLayerable *>(_o);
397 (void)_t;
398 ✗ switch (_id) {
399 ✗ case 0: _t->layerChanged((*reinterpret_cast< QCPLayer*(*)>(_a[1]))); break;
400 ✗ case 1: { bool _r = _t->setLayer((*reinterpret_cast< QCPLayer*(*)>(_a[1])));
401 ✗ if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = std::move(_r); } break;
402 ✗ default: ;
403 }
404 ✗ } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
405 ✗ switch (_id) {
406 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
407 ✗ case 0:
408 ✗ switch (*reinterpret_cast<int*>(_a[1])) {
409 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
410 ✗ case 0:
411 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayer* >(); break;
412 }
413 ✗ break;
414 ✗ case 1:
415 ✗ switch (*reinterpret_cast<int*>(_a[1])) {
416 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
417 ✗ case 0:
418 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayer* >(); break;
419 }
420 ✗ break;
421 }
422 ✗ } else if (_c == QMetaObject::IndexOfMethod) {
423 ✗ int *result = reinterpret_cast<int *>(_a[0]);
424 {
425 using _t = void (QCPLayerable::*)(QCPLayer * );
426 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPLayerable::layerChanged)) {
427 ✗ *result = 0;
428 ✗ return;
429 }
430 }
431 ✗ } else if (_c == QMetaObject::RegisterPropertyMetaType) {
432 ✗ switch (_id) {
433 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
434 ✗ case 3:
435 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayer* >(); break;
436 ✗ case 2:
437 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayerable* >(); break;
438 ✗ case 1:
439 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCustomPlot* >(); break;
440 }
441 }
442
443 #ifndef QT_NO_PROPERTIES
444 ✗ else if (_c == QMetaObject::ReadProperty) {
445 ✗ auto *_t = static_cast<QCPLayerable *>(_o);
446 (void)_t;
447 ✗ void *_v = _a[0];
448 ✗ switch (_id) {
449 ✗ case 0: *reinterpret_cast< bool*>(_v) = _t->visible(); break;
450 ✗ case 1: *reinterpret_cast< QCustomPlot**>(_v) = _t->parentPlot(); break;
451 ✗ case 2: *reinterpret_cast< QCPLayerable**>(_v) = _t->parentLayerable(); break;
452 ✗ case 3: *reinterpret_cast< QCPLayer**>(_v) = _t->layer(); break;
453 ✗ case 4: *reinterpret_cast< bool*>(_v) = _t->antialiased(); break;
454 ✗ default: break;
455 }
456 ✗ } else if (_c == QMetaObject::WriteProperty) {
457 ✗ auto *_t = static_cast<QCPLayerable *>(_o);
458 (void)_t;
459 ✗ void *_v = _a[0];
460 ✗ switch (_id) {
461 ✗ case 0: _t->setVisible(*reinterpret_cast< bool*>(_v)); break;
462 ✗ case 3: _t->setLayer(*reinterpret_cast< QCPLayer**>(_v)); break;
463 ✗ case 4: _t->setAntialiased(*reinterpret_cast< bool*>(_v)); break;
464 ✗ default: break;
465 }
466 } else if (_c == QMetaObject::ResetProperty) {
467 }
468 #endif // QT_NO_PROPERTIES
469 }
470
471 QT_INIT_METAOBJECT const QMetaObject QCPLayerable::staticMetaObject = { {
472 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
473 qt_meta_stringdata_QCPLayerable.data,
474 qt_meta_data_QCPLayerable,
475 qt_static_metacall,
476 nullptr,
477 nullptr
478 } };
479
480
481 ✗ const QMetaObject *QCPLayerable::metaObject() const
482 {
483 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
484 }
485
486 ✗ void *QCPLayerable::qt_metacast(const char *_clname)
487 {
488 ✗ if (!_clname) return nullptr;
489 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPLayerable.stringdata0))
490 ✗ return static_cast<void*>(this);
491 ✗ return QObject::qt_metacast(_clname);
492 }
493
494 ✗ int QCPLayerable::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
495 {
496 ✗ _id = QObject::qt_metacall(_c, _id, _a);
497 ✗ if (_id < 0)
498 ✗ return _id;
499 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
500 ✗ if (_id < 2)
501 ✗ qt_static_metacall(this, _c, _id, _a);
502 ✗ _id -= 2;
503 ✗ } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
504 ✗ if (_id < 2)
505 ✗ qt_static_metacall(this, _c, _id, _a);
506 ✗ _id -= 2;
507 }
508 #ifndef QT_NO_PROPERTIES
509 ✗ else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
510 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
511 ✗ qt_static_metacall(this, _c, _id, _a);
512 ✗ _id -= 5;
513 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
514 ✗ _id -= 5;
515 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
516 ✗ _id -= 5;
517 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
518 ✗ _id -= 5;
519 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
520 ✗ _id -= 5;
521 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
522 ✗ _id -= 5;
523 }
524 #endif // QT_NO_PROPERTIES
525 ✗ return _id;
526 }
527
528 // SIGNAL 0
529 ✗ void QCPLayerable::layerChanged(QCPLayer * _t1)
530 {
531 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
532 ✗ QMetaObject::activate(this, &staticMetaObject, 0, _a);
533 }
534 struct qt_meta_stringdata_QCPMarginGroup_t {
535 QByteArrayData data[1];
536 char stringdata0[15];
537 };
538 #define QT_MOC_LITERAL(idx, ofs, len) \
539 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
540 qptrdiff(offsetof(qt_meta_stringdata_QCPMarginGroup_t, stringdata0) + ofs \
541 - idx * sizeof(QByteArrayData)) \
542 )
543 static const qt_meta_stringdata_QCPMarginGroup_t qt_meta_stringdata_QCPMarginGroup = {
544 {
545 QT_MOC_LITERAL(0, 0, 14) // "QCPMarginGroup"
546
547 },
548 "QCPMarginGroup"
549 };
550 #undef QT_MOC_LITERAL
551
552 static const uint qt_meta_data_QCPMarginGroup[] = {
553
554 // content:
555 8, // revision
556 0, // classname
557 0, 0, // classinfo
558 0, 0, // methods
559 0, 0, // properties
560 0, 0, // enums/sets
561 0, 0, // constructors
562 0, // flags
563 0, // signalCount
564
565 0 // eod
566 };
567
568 ✗ void QCPMarginGroup::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
569 {
570 (void)_o;
571 (void)_id;
572 (void)_c;
573 (void)_a;
574 }
575
576 QT_INIT_METAOBJECT const QMetaObject QCPMarginGroup::staticMetaObject = { {
577 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
578 qt_meta_stringdata_QCPMarginGroup.data,
579 qt_meta_data_QCPMarginGroup,
580 qt_static_metacall,
581 nullptr,
582 nullptr
583 } };
584
585
586 ✗ const QMetaObject *QCPMarginGroup::metaObject() const
587 {
588 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
589 }
590
591 ✗ void *QCPMarginGroup::qt_metacast(const char *_clname)
592 {
593 ✗ if (!_clname) return nullptr;
594 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPMarginGroup.stringdata0))
595 ✗ return static_cast<void*>(this);
596 ✗ return QObject::qt_metacast(_clname);
597 }
598
599 ✗ int QCPMarginGroup::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
600 {
601 ✗ _id = QObject::qt_metacall(_c, _id, _a);
602 ✗ return _id;
603 }
604 struct qt_meta_stringdata_QCPLayoutElement_t {
605 QByteArrayData data[14];
606 char stringdata0[151];
607 };
608 #define QT_MOC_LITERAL(idx, ofs, len) \
609 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
610 qptrdiff(offsetof(qt_meta_stringdata_QCPLayoutElement_t, stringdata0) + ofs \
611 - idx * sizeof(QByteArrayData)) \
612 )
613 static const qt_meta_stringdata_QCPLayoutElement_t qt_meta_stringdata_QCPLayoutElement = {
614 {
615 QT_MOC_LITERAL(0, 0, 16), // "QCPLayoutElement"
616 QT_MOC_LITERAL(1, 17, 6), // "layout"
617 QT_MOC_LITERAL(2, 24, 10), // "QCPLayout*"
618 QT_MOC_LITERAL(3, 35, 4), // "rect"
619 QT_MOC_LITERAL(4, 40, 9), // "outerRect"
620 QT_MOC_LITERAL(5, 50, 7), // "margins"
621 QT_MOC_LITERAL(6, 58, 8), // "QMargins"
622 QT_MOC_LITERAL(7, 67, 14), // "minimumMargins"
623 QT_MOC_LITERAL(8, 82, 11), // "minimumSize"
624 QT_MOC_LITERAL(9, 94, 11), // "maximumSize"
625 QT_MOC_LITERAL(10, 106, 11), // "UpdatePhase"
626 QT_MOC_LITERAL(11, 118, 13), // "upPreparation"
627 QT_MOC_LITERAL(12, 132, 9), // "upMargins"
628 QT_MOC_LITERAL(13, 142, 8) // "upLayout"
629
630 },
631 "QCPLayoutElement\0layout\0QCPLayout*\0"
632 "rect\0outerRect\0margins\0QMargins\0"
633 "minimumMargins\0minimumSize\0maximumSize\0"
634 "UpdatePhase\0upPreparation\0upMargins\0"
635 "upLayout"
636 };
637 #undef QT_MOC_LITERAL
638
639 static const uint qt_meta_data_QCPLayoutElement[] = {
640
641 // content:
642 8, // revision
643 0, // classname
644 0, 0, // classinfo
645 0, 0, // methods
646 7, 14, // properties
647 1, 35, // enums/sets
648 0, 0, // constructors
649 0, // flags
650 0, // signalCount
651
652 // properties: name, type, flags
653 1, 0x80000000 | 2, 0x00095009,
654 3, QMetaType::QRect, 0x00095001,
655 4, QMetaType::QRect, 0x00095103,
656 5, 0x80000000 | 6, 0x0009510b,
657 7, 0x80000000 | 6, 0x0009510b,
658 8, QMetaType::QSize, 0x00095103,
659 9, QMetaType::QSize, 0x00095103,
660
661 // enums: name, alias, flags, count, data
662 10, 10, 0x0, 3, 40,
663
664 // enum data: key, value
665 11, uint(QCPLayoutElement::upPreparation),
666 12, uint(QCPLayoutElement::upMargins),
667 13, uint(QCPLayoutElement::upLayout),
668
669 0 // eod
670 };
671
672 ✗ void QCPLayoutElement::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
673 {
674 ✗ if (_c == QMetaObject::RegisterPropertyMetaType) {
675 ✗ switch (_id) {
676 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
677 ✗ case 0:
678 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayout* >(); break;
679 }
680 }
681
682 #ifndef QT_NO_PROPERTIES
683 ✗ else if (_c == QMetaObject::ReadProperty) {
684 ✗ auto *_t = static_cast<QCPLayoutElement *>(_o);
685 (void)_t;
686 ✗ void *_v = _a[0];
687 ✗ switch (_id) {
688 ✗ case 0: *reinterpret_cast< QCPLayout**>(_v) = _t->layout(); break;
689 ✗ case 1: *reinterpret_cast< QRect*>(_v) = _t->rect(); break;
690 ✗ case 2: *reinterpret_cast< QRect*>(_v) = _t->outerRect(); break;
691 ✗ case 3: *reinterpret_cast< QMargins*>(_v) = _t->margins(); break;
692 ✗ case 4: *reinterpret_cast< QMargins*>(_v) = _t->minimumMargins(); break;
693 ✗ case 5: *reinterpret_cast< QSize*>(_v) = _t->minimumSize(); break;
694 ✗ case 6: *reinterpret_cast< QSize*>(_v) = _t->maximumSize(); break;
695 ✗ default: break;
696 }
697 ✗ } else if (_c == QMetaObject::WriteProperty) {
698 ✗ auto *_t = static_cast<QCPLayoutElement *>(_o);
699 (void)_t;
700 ✗ void *_v = _a[0];
701 ✗ switch (_id) {
702 ✗ case 2: _t->setOuterRect(*reinterpret_cast< QRect*>(_v)); break;
703 ✗ case 3: _t->setMargins(*reinterpret_cast< QMargins*>(_v)); break;
704 ✗ case 4: _t->setMinimumMargins(*reinterpret_cast< QMargins*>(_v)); break;
705 ✗ case 5: _t->setMinimumSize(*reinterpret_cast< QSize*>(_v)); break;
706 ✗ case 6: _t->setMaximumSize(*reinterpret_cast< QSize*>(_v)); break;
707 ✗ default: break;
708 }
709 } else if (_c == QMetaObject::ResetProperty) {
710 }
711 #endif // QT_NO_PROPERTIES
712 (void)_o;
713 }
714
715 QT_INIT_METAOBJECT const QMetaObject QCPLayoutElement::staticMetaObject = { {
716 QMetaObject::SuperData::link<QCPLayerable::staticMetaObject>(),
717 qt_meta_stringdata_QCPLayoutElement.data,
718 qt_meta_data_QCPLayoutElement,
719 qt_static_metacall,
720 nullptr,
721 nullptr
722 } };
723
724
725 ✗ const QMetaObject *QCPLayoutElement::metaObject() const
726 {
727 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
728 }
729
730 ✗ void *QCPLayoutElement::qt_metacast(const char *_clname)
731 {
732 ✗ if (!_clname) return nullptr;
733 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPLayoutElement.stringdata0))
734 ✗ return static_cast<void*>(this);
735 ✗ return QCPLayerable::qt_metacast(_clname);
736 }
737
738 ✗ int QCPLayoutElement::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
739 {
740 ✗ _id = QCPLayerable::qt_metacall(_c, _id, _a);
741 ✗ if (_id < 0)
742 ✗ return _id;
743
744 #ifndef QT_NO_PROPERTIES
745 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
746 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
747 ✗ qt_static_metacall(this, _c, _id, _a);
748 ✗ _id -= 7;
749 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
750 ✗ _id -= 7;
751 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
752 ✗ _id -= 7;
753 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
754 ✗ _id -= 7;
755 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
756 ✗ _id -= 7;
757 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
758 ✗ _id -= 7;
759 }
760 #endif // QT_NO_PROPERTIES
761 ✗ return _id;
762 }
763 struct qt_meta_stringdata_QCPLayout_t {
764 QByteArrayData data[1];
765 char stringdata0[10];
766 };
767 #define QT_MOC_LITERAL(idx, ofs, len) \
768 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
769 qptrdiff(offsetof(qt_meta_stringdata_QCPLayout_t, stringdata0) + ofs \
770 - idx * sizeof(QByteArrayData)) \
771 )
772 static const qt_meta_stringdata_QCPLayout_t qt_meta_stringdata_QCPLayout = {
773 {
774 QT_MOC_LITERAL(0, 0, 9) // "QCPLayout"
775
776 },
777 "QCPLayout"
778 };
779 #undef QT_MOC_LITERAL
780
781 static const uint qt_meta_data_QCPLayout[] = {
782
783 // content:
784 8, // revision
785 0, // classname
786 0, 0, // classinfo
787 0, 0, // methods
788 0, 0, // properties
789 0, 0, // enums/sets
790 0, 0, // constructors
791 0, // flags
792 0, // signalCount
793
794 0 // eod
795 };
796
797 ✗ void QCPLayout::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
798 {
799 (void)_o;
800 (void)_id;
801 (void)_c;
802 (void)_a;
803 }
804
805 QT_INIT_METAOBJECT const QMetaObject QCPLayout::staticMetaObject = { {
806 QMetaObject::SuperData::link<QCPLayoutElement::staticMetaObject>(),
807 qt_meta_stringdata_QCPLayout.data,
808 qt_meta_data_QCPLayout,
809 qt_static_metacall,
810 nullptr,
811 nullptr
812 } };
813
814
815 ✗ const QMetaObject *QCPLayout::metaObject() const
816 {
817 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
818 }
819
820 ✗ void *QCPLayout::qt_metacast(const char *_clname)
821 {
822 ✗ if (!_clname) return nullptr;
823 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPLayout.stringdata0))
824 ✗ return static_cast<void*>(this);
825 ✗ return QCPLayoutElement::qt_metacast(_clname);
826 }
827
828 ✗ int QCPLayout::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
829 {
830 ✗ _id = QCPLayoutElement::qt_metacall(_c, _id, _a);
831 ✗ return _id;
832 }
833 struct qt_meta_stringdata_QCPLayoutGrid_t {
834 QByteArrayData data[8];
835 char stringdata0[113];
836 };
837 #define QT_MOC_LITERAL(idx, ofs, len) \
838 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
839 qptrdiff(offsetof(qt_meta_stringdata_QCPLayoutGrid_t, stringdata0) + ofs \
840 - idx * sizeof(QByteArrayData)) \
841 )
842 static const qt_meta_stringdata_QCPLayoutGrid_t qt_meta_stringdata_QCPLayoutGrid = {
843 {
844 QT_MOC_LITERAL(0, 0, 13), // "QCPLayoutGrid"
845 QT_MOC_LITERAL(1, 14, 8), // "rowCount"
846 QT_MOC_LITERAL(2, 23, 11), // "columnCount"
847 QT_MOC_LITERAL(3, 35, 20), // "columnStretchFactors"
848 QT_MOC_LITERAL(4, 56, 13), // "QList<double>"
849 QT_MOC_LITERAL(5, 70, 17), // "rowStretchFactors"
850 QT_MOC_LITERAL(6, 88, 13), // "columnSpacing"
851 QT_MOC_LITERAL(7, 102, 10) // "rowSpacing"
852
853 },
854 "QCPLayoutGrid\0rowCount\0columnCount\0"
855 "columnStretchFactors\0QList<double>\0"
856 "rowStretchFactors\0columnSpacing\0"
857 "rowSpacing"
858 };
859 #undef QT_MOC_LITERAL
860
861 static const uint qt_meta_data_QCPLayoutGrid[] = {
862
863 // content:
864 8, // revision
865 0, // classname
866 0, 0, // classinfo
867 0, 0, // methods
868 6, 14, // properties
869 0, 0, // enums/sets
870 0, 0, // constructors
871 0, // flags
872 0, // signalCount
873
874 // properties: name, type, flags
875 1, QMetaType::Int, 0x00095001,
876 2, QMetaType::Int, 0x00095001,
877 3, 0x80000000 | 4, 0x0009510b,
878 5, 0x80000000 | 4, 0x0009510b,
879 6, QMetaType::Int, 0x00095103,
880 7, QMetaType::Int, 0x00095103,
881
882 0 // eod
883 };
884
885 ✗ void QCPLayoutGrid::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
886 {
887 ✗ if (_c == QMetaObject::RegisterPropertyMetaType) {
888 ✗ switch (_id) {
889 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
890 ✗ case 3:
891 case 2:
892 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<double> >(); break;
893 }
894 }
895
896 #ifndef QT_NO_PROPERTIES
897 ✗ else if (_c == QMetaObject::ReadProperty) {
898 ✗ auto *_t = static_cast<QCPLayoutGrid *>(_o);
899 (void)_t;
900 ✗ void *_v = _a[0];
901 ✗ switch (_id) {
902 ✗ case 0: *reinterpret_cast< int*>(_v) = _t->rowCount(); break;
903 ✗ case 1: *reinterpret_cast< int*>(_v) = _t->columnCount(); break;
904 ✗ case 2: *reinterpret_cast< QList<double>*>(_v) = _t->columnStretchFactors(); break;
905 ✗ case 3: *reinterpret_cast< QList<double>*>(_v) = _t->rowStretchFactors(); break;
906 ✗ case 4: *reinterpret_cast< int*>(_v) = _t->columnSpacing(); break;
907 ✗ case 5: *reinterpret_cast< int*>(_v) = _t->rowSpacing(); break;
908 ✗ default: break;
909 }
910 ✗ } else if (_c == QMetaObject::WriteProperty) {
911 ✗ auto *_t = static_cast<QCPLayoutGrid *>(_o);
912 (void)_t;
913 ✗ void *_v = _a[0];
914 ✗ switch (_id) {
915 ✗ case 2: _t->setColumnStretchFactors(*reinterpret_cast< QList<double>*>(_v)); break;
916 ✗ case 3: _t->setRowStretchFactors(*reinterpret_cast< QList<double>*>(_v)); break;
917 ✗ case 4: _t->setColumnSpacing(*reinterpret_cast< int*>(_v)); break;
918 ✗ case 5: _t->setRowSpacing(*reinterpret_cast< int*>(_v)); break;
919 ✗ default: break;
920 }
921 } else if (_c == QMetaObject::ResetProperty) {
922 }
923 #endif // QT_NO_PROPERTIES
924 (void)_o;
925 }
926
927 QT_INIT_METAOBJECT const QMetaObject QCPLayoutGrid::staticMetaObject = { {
928 QMetaObject::SuperData::link<QCPLayout::staticMetaObject>(),
929 qt_meta_stringdata_QCPLayoutGrid.data,
930 qt_meta_data_QCPLayoutGrid,
931 qt_static_metacall,
932 nullptr,
933 nullptr
934 } };
935
936
937 ✗ const QMetaObject *QCPLayoutGrid::metaObject() const
938 {
939 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
940 }
941
942 ✗ void *QCPLayoutGrid::qt_metacast(const char *_clname)
943 {
944 ✗ if (!_clname) return nullptr;
945 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPLayoutGrid.stringdata0))
946 ✗ return static_cast<void*>(this);
947 ✗ return QCPLayout::qt_metacast(_clname);
948 }
949
950 ✗ int QCPLayoutGrid::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
951 {
952 ✗ _id = QCPLayout::qt_metacall(_c, _id, _a);
953 ✗ if (_id < 0)
954 ✗ return _id;
955
956 #ifndef QT_NO_PROPERTIES
957 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
958 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
959 ✗ qt_static_metacall(this, _c, _id, _a);
960 ✗ _id -= 6;
961 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
962 ✗ _id -= 6;
963 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
964 ✗ _id -= 6;
965 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
966 ✗ _id -= 6;
967 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
968 ✗ _id -= 6;
969 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
970 ✗ _id -= 6;
971 }
972 #endif // QT_NO_PROPERTIES
973 ✗ return _id;
974 }
975 struct qt_meta_stringdata_QCPLayoutInset_t {
976 QByteArrayData data[1];
977 char stringdata0[15];
978 };
979 #define QT_MOC_LITERAL(idx, ofs, len) \
980 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
981 qptrdiff(offsetof(qt_meta_stringdata_QCPLayoutInset_t, stringdata0) + ofs \
982 - idx * sizeof(QByteArrayData)) \
983 )
984 static const qt_meta_stringdata_QCPLayoutInset_t qt_meta_stringdata_QCPLayoutInset = {
985 {
986 QT_MOC_LITERAL(0, 0, 14) // "QCPLayoutInset"
987
988 },
989 "QCPLayoutInset"
990 };
991 #undef QT_MOC_LITERAL
992
993 static const uint qt_meta_data_QCPLayoutInset[] = {
994
995 // content:
996 8, // revision
997 0, // classname
998 0, 0, // classinfo
999 0, 0, // methods
1000 0, 0, // properties
1001 0, 0, // enums/sets
1002 0, 0, // constructors
1003 0, // flags
1004 0, // signalCount
1005
1006 0 // eod
1007 };
1008
1009 ✗ void QCPLayoutInset::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
1010 {
1011 (void)_o;
1012 (void)_id;
1013 (void)_c;
1014 (void)_a;
1015 }
1016
1017 QT_INIT_METAOBJECT const QMetaObject QCPLayoutInset::staticMetaObject = { {
1018 QMetaObject::SuperData::link<QCPLayout::staticMetaObject>(),
1019 qt_meta_stringdata_QCPLayoutInset.data,
1020 qt_meta_data_QCPLayoutInset,
1021 qt_static_metacall,
1022 nullptr,
1023 nullptr
1024 } };
1025
1026
1027 ✗ const QMetaObject *QCPLayoutInset::metaObject() const
1028 {
1029 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
1030 }
1031
1032 ✗ void *QCPLayoutInset::qt_metacast(const char *_clname)
1033 {
1034 ✗ if (!_clname) return nullptr;
1035 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPLayoutInset.stringdata0))
1036 ✗ return static_cast<void*>(this);
1037 ✗ return QCPLayout::qt_metacast(_clname);
1038 }
1039
1040 ✗ int QCPLayoutInset::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
1041 {
1042 ✗ _id = QCPLayout::qt_metacall(_c, _id, _a);
1043 ✗ return _id;
1044 }
1045 struct qt_meta_stringdata_QCPLineEnding_t {
1046 QByteArrayData data[12];
1047 char stringdata0[124];
1048 };
1049 #define QT_MOC_LITERAL(idx, ofs, len) \
1050 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
1051 qptrdiff(offsetof(qt_meta_stringdata_QCPLineEnding_t, stringdata0) + ofs \
1052 - idx * sizeof(QByteArrayData)) \
1053 )
1054 static const qt_meta_stringdata_QCPLineEnding_t qt_meta_stringdata_QCPLineEnding = {
1055 {
1056 QT_MOC_LITERAL(0, 0, 13), // "QCPLineEnding"
1057 QT_MOC_LITERAL(1, 14, 11), // "EndingStyle"
1058 QT_MOC_LITERAL(2, 26, 6), // "esNone"
1059 QT_MOC_LITERAL(3, 33, 11), // "esFlatArrow"
1060 QT_MOC_LITERAL(4, 45, 12), // "esSpikeArrow"
1061 QT_MOC_LITERAL(5, 58, 11), // "esLineArrow"
1062 QT_MOC_LITERAL(6, 70, 6), // "esDisc"
1063 QT_MOC_LITERAL(7, 77, 8), // "esSquare"
1064 QT_MOC_LITERAL(8, 86, 9), // "esDiamond"
1065 QT_MOC_LITERAL(9, 96, 5), // "esBar"
1066 QT_MOC_LITERAL(10, 102, 9), // "esHalfBar"
1067 QT_MOC_LITERAL(11, 112, 11) // "esSkewedBar"
1068
1069 },
1070 "QCPLineEnding\0EndingStyle\0esNone\0"
1071 "esFlatArrow\0esSpikeArrow\0esLineArrow\0"
1072 "esDisc\0esSquare\0esDiamond\0esBar\0"
1073 "esHalfBar\0esSkewedBar"
1074 };
1075 #undef QT_MOC_LITERAL
1076
1077 static const uint qt_meta_data_QCPLineEnding[] = {
1078
1079 // content:
1080 8, // revision
1081 0, // classname
1082 0, 0, // classinfo
1083 0, 0, // methods
1084 0, 0, // properties
1085 1, 14, // enums/sets
1086 0, 0, // constructors
1087 4, // flags
1088 0, // signalCount
1089
1090 // enums: name, alias, flags, count, data
1091 1, 1, 0x0, 10, 19,
1092
1093 // enum data: key, value
1094 2, uint(QCPLineEnding::esNone),
1095 3, uint(QCPLineEnding::esFlatArrow),
1096 4, uint(QCPLineEnding::esSpikeArrow),
1097 5, uint(QCPLineEnding::esLineArrow),
1098 6, uint(QCPLineEnding::esDisc),
1099 7, uint(QCPLineEnding::esSquare),
1100 8, uint(QCPLineEnding::esDiamond),
1101 9, uint(QCPLineEnding::esBar),
1102 10, uint(QCPLineEnding::esHalfBar),
1103 11, uint(QCPLineEnding::esSkewedBar),
1104
1105 0 // eod
1106 };
1107
1108 QT_INIT_METAOBJECT const QMetaObject QCPLineEnding::staticMetaObject = { {
1109 nullptr,
1110 qt_meta_stringdata_QCPLineEnding.data,
1111 qt_meta_data_QCPLineEnding,
1112 nullptr,
1113 nullptr,
1114 nullptr
1115 } };
1116
1117 struct qt_meta_stringdata_QCPGrid_t {
1118 QByteArrayData data[7];
1119 char stringdata0[89];
1120 };
1121 #define QT_MOC_LITERAL(idx, ofs, len) \
1122 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
1123 qptrdiff(offsetof(qt_meta_stringdata_QCPGrid_t, stringdata0) + ofs \
1124 - idx * sizeof(QByteArrayData)) \
1125 )
1126 static const qt_meta_stringdata_QCPGrid_t qt_meta_stringdata_QCPGrid = {
1127 {
1128 QT_MOC_LITERAL(0, 0, 7), // "QCPGrid"
1129 QT_MOC_LITERAL(1, 8, 14), // "subGridVisible"
1130 QT_MOC_LITERAL(2, 23, 18), // "antialiasedSubGrid"
1131 QT_MOC_LITERAL(3, 42, 19), // "antialiasedZeroLine"
1132 QT_MOC_LITERAL(4, 62, 3), // "pen"
1133 QT_MOC_LITERAL(5, 66, 10), // "subGridPen"
1134 QT_MOC_LITERAL(6, 77, 11) // "zeroLinePen"
1135
1136 },
1137 "QCPGrid\0subGridVisible\0antialiasedSubGrid\0"
1138 "antialiasedZeroLine\0pen\0subGridPen\0"
1139 "zeroLinePen"
1140 };
1141 #undef QT_MOC_LITERAL
1142
1143 static const uint qt_meta_data_QCPGrid[] = {
1144
1145 // content:
1146 8, // revision
1147 0, // classname
1148 0, 0, // classinfo
1149 0, 0, // methods
1150 6, 14, // properties
1151 0, 0, // enums/sets
1152 0, 0, // constructors
1153 0, // flags
1154 0, // signalCount
1155
1156 // properties: name, type, flags
1157 1, QMetaType::Bool, 0x00095103,
1158 2, QMetaType::Bool, 0x00095103,
1159 3, QMetaType::Bool, 0x00095103,
1160 4, QMetaType::QPen, 0x00095103,
1161 5, QMetaType::QPen, 0x00095103,
1162 6, QMetaType::QPen, 0x00095103,
1163
1164 0 // eod
1165 };
1166
1167 ✗ void QCPGrid::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
1168 {
1169
1170 #ifndef QT_NO_PROPERTIES
1171 ✗ if (_c == QMetaObject::ReadProperty) {
1172 ✗ auto *_t = static_cast<QCPGrid *>(_o);
1173 (void)_t;
1174 ✗ void *_v = _a[0];
1175 ✗ switch (_id) {
1176 ✗ case 0: *reinterpret_cast< bool*>(_v) = _t->subGridVisible(); break;
1177 ✗ case 1: *reinterpret_cast< bool*>(_v) = _t->antialiasedSubGrid(); break;
1178 ✗ case 2: *reinterpret_cast< bool*>(_v) = _t->antialiasedZeroLine(); break;
1179 ✗ case 3: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
1180 ✗ case 4: *reinterpret_cast< QPen*>(_v) = _t->subGridPen(); break;
1181 ✗ case 5: *reinterpret_cast< QPen*>(_v) = _t->zeroLinePen(); break;
1182 ✗ default: break;
1183 }
1184 ✗ } else if (_c == QMetaObject::WriteProperty) {
1185 ✗ auto *_t = static_cast<QCPGrid *>(_o);
1186 (void)_t;
1187 ✗ void *_v = _a[0];
1188 ✗ switch (_id) {
1189 ✗ case 0: _t->setSubGridVisible(*reinterpret_cast< bool*>(_v)); break;
1190 ✗ case 1: _t->setAntialiasedSubGrid(*reinterpret_cast< bool*>(_v)); break;
1191 ✗ case 2: _t->setAntialiasedZeroLine(*reinterpret_cast< bool*>(_v)); break;
1192 ✗ case 3: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
1193 ✗ case 4: _t->setSubGridPen(*reinterpret_cast< QPen*>(_v)); break;
1194 ✗ case 5: _t->setZeroLinePen(*reinterpret_cast< QPen*>(_v)); break;
1195 ✗ default: break;
1196 }
1197 } else if (_c == QMetaObject::ResetProperty) {
1198 }
1199 #endif // QT_NO_PROPERTIES
1200 (void)_o;
1201 (void)_id;
1202 (void)_c;
1203 (void)_a;
1204 }
1205
1206 QT_INIT_METAOBJECT const QMetaObject QCPGrid::staticMetaObject = { {
1207 QMetaObject::SuperData::link<QCPLayerable::staticMetaObject>(),
1208 qt_meta_stringdata_QCPGrid.data,
1209 qt_meta_data_QCPGrid,
1210 qt_static_metacall,
1211 nullptr,
1212 nullptr
1213 } };
1214
1215
1216 ✗ const QMetaObject *QCPGrid::metaObject() const
1217 {
1218 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
1219 }
1220
1221 ✗ void *QCPGrid::qt_metacast(const char *_clname)
1222 {
1223 ✗ if (!_clname) return nullptr;
1224 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPGrid.stringdata0))
1225 ✗ return static_cast<void*>(this);
1226 ✗ return QCPLayerable::qt_metacast(_clname);
1227 }
1228
1229 ✗ int QCPGrid::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
1230 {
1231 ✗ _id = QCPLayerable::qt_metacall(_c, _id, _a);
1232 ✗ if (_id < 0)
1233 ✗ return _id;
1234
1235 #ifndef QT_NO_PROPERTIES
1236 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
1237 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
1238 ✗ qt_static_metacall(this, _c, _id, _a);
1239 ✗ _id -= 6;
1240 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
1241 ✗ _id -= 6;
1242 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
1243 ✗ _id -= 6;
1244 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
1245 ✗ _id -= 6;
1246 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
1247 ✗ _id -= 6;
1248 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
1249 ✗ _id -= 6;
1250 }
1251 #endif // QT_NO_PROPERTIES
1252 ✗ return _id;
1253 }
1254 struct qt_meta_stringdata_QCPAxis_t {
1255 QByteArrayData data[97];
1256 char stringdata0[1196];
1257 };
1258 #define QT_MOC_LITERAL(idx, ofs, len) \
1259 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
1260 qptrdiff(offsetof(qt_meta_stringdata_QCPAxis_t, stringdata0) + ofs \
1261 - idx * sizeof(QByteArrayData)) \
1262 )
1263 static const qt_meta_stringdata_QCPAxis_t qt_meta_stringdata_QCPAxis = {
1264 {
1265 QT_MOC_LITERAL(0, 0, 7), // "QCPAxis"
1266 QT_MOC_LITERAL(1, 8, 12), // "ticksRequest"
1267 QT_MOC_LITERAL(2, 21, 0), // ""
1268 QT_MOC_LITERAL(3, 22, 12), // "rangeChanged"
1269 QT_MOC_LITERAL(4, 35, 8), // "QCPRange"
1270 QT_MOC_LITERAL(5, 44, 8), // "newRange"
1271 QT_MOC_LITERAL(6, 53, 8), // "oldRange"
1272 QT_MOC_LITERAL(7, 62, 16), // "scaleTypeChanged"
1273 QT_MOC_LITERAL(8, 79, 18), // "QCPAxis::ScaleType"
1274 QT_MOC_LITERAL(9, 98, 9), // "scaleType"
1275 QT_MOC_LITERAL(10, 108, 16), // "selectionChanged"
1276 QT_MOC_LITERAL(11, 125, 24), // "QCPAxis::SelectableParts"
1277 QT_MOC_LITERAL(12, 150, 5), // "parts"
1278 QT_MOC_LITERAL(13, 156, 17), // "selectableChanged"
1279 QT_MOC_LITERAL(14, 174, 12), // "setScaleType"
1280 QT_MOC_LITERAL(15, 187, 4), // "type"
1281 QT_MOC_LITERAL(16, 192, 8), // "setRange"
1282 QT_MOC_LITERAL(17, 201, 5), // "range"
1283 QT_MOC_LITERAL(18, 207, 18), // "setSelectableParts"
1284 QT_MOC_LITERAL(19, 226, 15), // "selectableParts"
1285 QT_MOC_LITERAL(20, 242, 16), // "setSelectedParts"
1286 QT_MOC_LITERAL(21, 259, 13), // "selectedParts"
1287 QT_MOC_LITERAL(22, 273, 8), // "axisType"
1288 QT_MOC_LITERAL(23, 282, 8), // "AxisType"
1289 QT_MOC_LITERAL(24, 291, 8), // "axisRect"
1290 QT_MOC_LITERAL(25, 300, 12), // "QCPAxisRect*"
1291 QT_MOC_LITERAL(26, 313, 9), // "ScaleType"
1292 QT_MOC_LITERAL(27, 323, 12), // "scaleLogBase"
1293 QT_MOC_LITERAL(28, 336, 13), // "rangeReversed"
1294 QT_MOC_LITERAL(29, 350, 9), // "autoTicks"
1295 QT_MOC_LITERAL(30, 360, 13), // "autoTickCount"
1296 QT_MOC_LITERAL(31, 374, 14), // "autoTickLabels"
1297 QT_MOC_LITERAL(32, 389, 12), // "autoTickStep"
1298 QT_MOC_LITERAL(33, 402, 12), // "autoSubTicks"
1299 QT_MOC_LITERAL(34, 415, 5), // "ticks"
1300 QT_MOC_LITERAL(35, 421, 10), // "tickLabels"
1301 QT_MOC_LITERAL(36, 432, 16), // "tickLabelPadding"
1302 QT_MOC_LITERAL(37, 449, 13), // "tickLabelType"
1303 QT_MOC_LITERAL(38, 463, 9), // "LabelType"
1304 QT_MOC_LITERAL(39, 473, 13), // "tickLabelFont"
1305 QT_MOC_LITERAL(40, 487, 14), // "tickLabelColor"
1306 QT_MOC_LITERAL(41, 502, 17), // "tickLabelRotation"
1307 QT_MOC_LITERAL(42, 520, 13), // "tickLabelSide"
1308 QT_MOC_LITERAL(43, 534, 9), // "LabelSide"
1309 QT_MOC_LITERAL(44, 544, 14), // "dateTimeFormat"
1310 QT_MOC_LITERAL(45, 559, 12), // "dateTimeSpec"
1311 QT_MOC_LITERAL(46, 572, 12), // "Qt::TimeSpec"
1312 QT_MOC_LITERAL(47, 585, 12), // "numberFormat"
1313 QT_MOC_LITERAL(48, 598, 15), // "numberPrecision"
1314 QT_MOC_LITERAL(49, 614, 8), // "tickStep"
1315 QT_MOC_LITERAL(50, 623, 10), // "tickVector"
1316 QT_MOC_LITERAL(51, 634, 15), // "QVector<double>"
1317 QT_MOC_LITERAL(52, 650, 16), // "tickVectorLabels"
1318 QT_MOC_LITERAL(53, 667, 16), // "QVector<QString>"
1319 QT_MOC_LITERAL(54, 684, 12), // "tickLengthIn"
1320 QT_MOC_LITERAL(55, 697, 13), // "tickLengthOut"
1321 QT_MOC_LITERAL(56, 711, 12), // "subTickCount"
1322 QT_MOC_LITERAL(57, 724, 15), // "subTickLengthIn"
1323 QT_MOC_LITERAL(58, 740, 16), // "subTickLengthOut"
1324 QT_MOC_LITERAL(59, 757, 7), // "basePen"
1325 QT_MOC_LITERAL(60, 765, 7), // "tickPen"
1326 QT_MOC_LITERAL(61, 773, 10), // "subTickPen"
1327 QT_MOC_LITERAL(62, 784, 9), // "labelFont"
1328 QT_MOC_LITERAL(63, 794, 10), // "labelColor"
1329 QT_MOC_LITERAL(64, 805, 5), // "label"
1330 QT_MOC_LITERAL(65, 811, 12), // "labelPadding"
1331 QT_MOC_LITERAL(66, 824, 7), // "padding"
1332 QT_MOC_LITERAL(67, 832, 6), // "offset"
1333 QT_MOC_LITERAL(68, 839, 15), // "SelectableParts"
1334 QT_MOC_LITERAL(69, 855, 21), // "selectedTickLabelFont"
1335 QT_MOC_LITERAL(70, 877, 17), // "selectedLabelFont"
1336 QT_MOC_LITERAL(71, 895, 22), // "selectedTickLabelColor"
1337 QT_MOC_LITERAL(72, 918, 18), // "selectedLabelColor"
1338 QT_MOC_LITERAL(73, 937, 15), // "selectedBasePen"
1339 QT_MOC_LITERAL(74, 953, 15), // "selectedTickPen"
1340 QT_MOC_LITERAL(75, 969, 18), // "selectedSubTickPen"
1341 QT_MOC_LITERAL(76, 988, 11), // "lowerEnding"
1342 QT_MOC_LITERAL(77, 1000, 13), // "QCPLineEnding"
1343 QT_MOC_LITERAL(78, 1014, 11), // "upperEnding"
1344 QT_MOC_LITERAL(79, 1026, 4), // "grid"
1345 QT_MOC_LITERAL(80, 1031, 8), // "QCPGrid*"
1346 QT_MOC_LITERAL(81, 1040, 6), // "atLeft"
1347 QT_MOC_LITERAL(82, 1047, 7), // "atRight"
1348 QT_MOC_LITERAL(83, 1055, 5), // "atTop"
1349 QT_MOC_LITERAL(84, 1061, 8), // "atBottom"
1350 QT_MOC_LITERAL(85, 1070, 9), // "AxisTypes"
1351 QT_MOC_LITERAL(86, 1080, 8), // "ltNumber"
1352 QT_MOC_LITERAL(87, 1089, 10), // "ltDateTime"
1353 QT_MOC_LITERAL(88, 1100, 8), // "lsInside"
1354 QT_MOC_LITERAL(89, 1109, 9), // "lsOutside"
1355 QT_MOC_LITERAL(90, 1119, 8), // "stLinear"
1356 QT_MOC_LITERAL(91, 1128, 13), // "stLogarithmic"
1357 QT_MOC_LITERAL(92, 1142, 14), // "SelectablePart"
1358 QT_MOC_LITERAL(93, 1157, 6), // "spNone"
1359 QT_MOC_LITERAL(94, 1164, 6), // "spAxis"
1360 QT_MOC_LITERAL(95, 1171, 12), // "spTickLabels"
1361 QT_MOC_LITERAL(96, 1184, 11) // "spAxisLabel"
1362
1363 },
1364 "QCPAxis\0ticksRequest\0\0rangeChanged\0"
1365 "QCPRange\0newRange\0oldRange\0scaleTypeChanged\0"
1366 "QCPAxis::ScaleType\0scaleType\0"
1367 "selectionChanged\0QCPAxis::SelectableParts\0"
1368 "parts\0selectableChanged\0setScaleType\0"
1369 "type\0setRange\0range\0setSelectableParts\0"
1370 "selectableParts\0setSelectedParts\0"
1371 "selectedParts\0axisType\0AxisType\0"
1372 "axisRect\0QCPAxisRect*\0ScaleType\0"
1373 "scaleLogBase\0rangeReversed\0autoTicks\0"
1374 "autoTickCount\0autoTickLabels\0autoTickStep\0"
1375 "autoSubTicks\0ticks\0tickLabels\0"
1376 "tickLabelPadding\0tickLabelType\0LabelType\0"
1377 "tickLabelFont\0tickLabelColor\0"
1378 "tickLabelRotation\0tickLabelSide\0"
1379 "LabelSide\0dateTimeFormat\0dateTimeSpec\0"
1380 "Qt::TimeSpec\0numberFormat\0numberPrecision\0"
1381 "tickStep\0tickVector\0QVector<double>\0"
1382 "tickVectorLabels\0QVector<QString>\0"
1383 "tickLengthIn\0tickLengthOut\0subTickCount\0"
1384 "subTickLengthIn\0subTickLengthOut\0"
1385 "basePen\0tickPen\0subTickPen\0labelFont\0"
1386 "labelColor\0label\0labelPadding\0padding\0"
1387 "offset\0SelectableParts\0selectedTickLabelFont\0"
1388 "selectedLabelFont\0selectedTickLabelColor\0"
1389 "selectedLabelColor\0selectedBasePen\0"
1390 "selectedTickPen\0selectedSubTickPen\0"
1391 "lowerEnding\0QCPLineEnding\0upperEnding\0"
1392 "grid\0QCPGrid*\0atLeft\0atRight\0atTop\0"
1393 "atBottom\0AxisTypes\0ltNumber\0ltDateTime\0"
1394 "lsInside\0lsOutside\0stLinear\0stLogarithmic\0"
1395 "SelectablePart\0spNone\0spAxis\0spTickLabels\0"
1396 "spAxisLabel"
1397 };
1398 #undef QT_MOC_LITERAL
1399
1400 static const uint qt_meta_data_QCPAxis[] = {
1401
1402 // content:
1403 8, // revision
1404 0, // classname
1405 0, 0, // classinfo
1406 10, 14, // methods
1407 52, 94, // properties
1408 7, 302, // enums/sets
1409 0, 0, // constructors
1410 0, // flags
1411 6, // signalCount
1412
1413 // signals: name, argc, parameters, tag, flags
1414 1, 0, 64, 2, 0x06 /* Public */,
1415 3, 1, 65, 2, 0x06 /* Public */,
1416 3, 2, 68, 2, 0x06 /* Public */,
1417 7, 1, 73, 2, 0x06 /* Public */,
1418 10, 1, 76, 2, 0x06 /* Public */,
1419 13, 1, 79, 2, 0x06 /* Public */,
1420
1421 // slots: name, argc, parameters, tag, flags
1422 14, 1, 82, 2, 0x0a /* Public */,
1423 16, 1, 85, 2, 0x0a /* Public */,
1424 18, 1, 88, 2, 0x0a /* Public */,
1425 20, 1, 91, 2, 0x0a /* Public */,
1426
1427 // signals: parameters
1428 QMetaType::Void,
1429 QMetaType::Void, 0x80000000 | 4, 5,
1430 QMetaType::Void, 0x80000000 | 4, 0x80000000 | 4, 5, 6,
1431 QMetaType::Void, 0x80000000 | 8, 9,
1432 QMetaType::Void, 0x80000000 | 11, 12,
1433 QMetaType::Void, 0x80000000 | 11, 12,
1434
1435 // slots: parameters
1436 QMetaType::Void, 0x80000000 | 8, 15,
1437 QMetaType::Void, 0x80000000 | 4, 17,
1438 QMetaType::Void, 0x80000000 | 11, 19,
1439 QMetaType::Void, 0x80000000 | 11, 21,
1440
1441 // properties: name, type, flags
1442 22, 0x80000000 | 23, 0x00095009,
1443 24, 0x80000000 | 25, 0x00095009,
1444 9, 0x80000000 | 26, 0x0049510b,
1445 27, QMetaType::Double, 0x00095103,
1446 17, 0x80000000 | 4, 0x0049510b,
1447 28, QMetaType::Bool, 0x00095103,
1448 29, QMetaType::Bool, 0x00095103,
1449 30, QMetaType::Int, 0x00095103,
1450 31, QMetaType::Bool, 0x00095103,
1451 32, QMetaType::Bool, 0x00095103,
1452 33, QMetaType::Bool, 0x00095103,
1453 34, QMetaType::Bool, 0x00095103,
1454 35, QMetaType::Bool, 0x00095103,
1455 36, QMetaType::Int, 0x00095103,
1456 37, 0x80000000 | 38, 0x0009510b,
1457 39, QMetaType::QFont, 0x00095103,
1458 40, QMetaType::QColor, 0x00095103,
1459 41, QMetaType::Double, 0x00095103,
1460 42, 0x80000000 | 43, 0x0009510b,
1461 44, QMetaType::QString, 0x00095103,
1462 45, 0x80000000 | 46, 0x0009510b,
1463 47, QMetaType::QString, 0x00095103,
1464 48, QMetaType::Int, 0x00095103,
1465 49, QMetaType::Double, 0x00095103,
1466 50, 0x80000000 | 51, 0x0009510b,
1467 52, 0x80000000 | 53, 0x0009510b,
1468 54, QMetaType::Int, 0x00095103,
1469 55, QMetaType::Int, 0x00095103,
1470 56, QMetaType::Int, 0x00095103,
1471 57, QMetaType::Int, 0x00095103,
1472 58, QMetaType::Int, 0x00095103,
1473 59, QMetaType::QPen, 0x00095103,
1474 60, QMetaType::QPen, 0x00095103,
1475 61, QMetaType::QPen, 0x00095103,
1476 62, QMetaType::QFont, 0x00095103,
1477 63, QMetaType::QColor, 0x00095103,
1478 64, QMetaType::QString, 0x00095103,
1479 65, QMetaType::Int, 0x00095103,
1480 66, QMetaType::Int, 0x00095103,
1481 67, QMetaType::Int, 0x00095103,
1482 21, 0x80000000 | 68, 0x0049510b,
1483 19, 0x80000000 | 68, 0x0049510b,
1484 69, QMetaType::QFont, 0x00095103,
1485 70, QMetaType::QFont, 0x00095103,
1486 71, QMetaType::QColor, 0x00095103,
1487 72, QMetaType::QColor, 0x00095103,
1488 73, QMetaType::QPen, 0x00095103,
1489 74, QMetaType::QPen, 0x00095103,
1490 75, QMetaType::QPen, 0x00095103,
1491 76, 0x80000000 | 77, 0x0009510b,
1492 78, 0x80000000 | 77, 0x0009510b,
1493 79, 0x80000000 | 80, 0x00095009,
1494
1495 // properties: notify_signal_id
1496 0,
1497 0,
1498 3,
1499 0,
1500 1,
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 0,
1536 4,
1537 5,
1538 0,
1539 0,
1540 0,
1541 0,
1542 0,
1543 0,
1544 0,
1545 0,
1546 0,
1547 0,
1548
1549 // enums: name, alias, flags, count, data
1550 23, 23, 0x1, 4, 337,
1551 85, 23, 0x1, 4, 345,
1552 38, 38, 0x0, 2, 353,
1553 43, 43, 0x0, 2, 357,
1554 26, 26, 0x0, 2, 361,
1555 92, 92, 0x1, 4, 365,
1556 68, 92, 0x1, 4, 373,
1557
1558 // enum data: key, value
1559 81, uint(QCPAxis::atLeft),
1560 82, uint(QCPAxis::atRight),
1561 83, uint(QCPAxis::atTop),
1562 84, uint(QCPAxis::atBottom),
1563 81, uint(QCPAxis::atLeft),
1564 82, uint(QCPAxis::atRight),
1565 83, uint(QCPAxis::atTop),
1566 84, uint(QCPAxis::atBottom),
1567 86, uint(QCPAxis::ltNumber),
1568 87, uint(QCPAxis::ltDateTime),
1569 88, uint(QCPAxis::lsInside),
1570 89, uint(QCPAxis::lsOutside),
1571 90, uint(QCPAxis::stLinear),
1572 91, uint(QCPAxis::stLogarithmic),
1573 93, uint(QCPAxis::spNone),
1574 94, uint(QCPAxis::spAxis),
1575 95, uint(QCPAxis::spTickLabels),
1576 96, uint(QCPAxis::spAxisLabel),
1577 93, uint(QCPAxis::spNone),
1578 94, uint(QCPAxis::spAxis),
1579 95, uint(QCPAxis::spTickLabels),
1580 96, uint(QCPAxis::spAxisLabel),
1581
1582 0 // eod
1583 };
1584
1585 ✗ void QCPAxis::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
1586 {
1587 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
1588 ✗ auto *_t = static_cast<QCPAxis *>(_o);
1589 (void)_t;
1590 ✗ switch (_id) {
1591 ✗ case 0: _t->ticksRequest(); break;
1592 ✗ case 1: _t->rangeChanged((*reinterpret_cast< const QCPRange(*)>(_a[1]))); break;
1593 ✗ case 2: _t->rangeChanged((*reinterpret_cast< const QCPRange(*)>(_a[1])),(*reinterpret_cast< const QCPRange(*)>(_a[2]))); break;
1594 ✗ case 3: _t->scaleTypeChanged((*reinterpret_cast< QCPAxis::ScaleType(*)>(_a[1]))); break;
1595 ✗ case 4: _t->selectionChanged((*reinterpret_cast< const QCPAxis::SelectableParts(*)>(_a[1]))); break;
1596 ✗ case 5: _t->selectableChanged((*reinterpret_cast< const QCPAxis::SelectableParts(*)>(_a[1]))); break;
1597 ✗ case 6: _t->setScaleType((*reinterpret_cast< QCPAxis::ScaleType(*)>(_a[1]))); break;
1598 ✗ case 7: _t->setRange((*reinterpret_cast< const QCPRange(*)>(_a[1]))); break;
1599 ✗ case 8: _t->setSelectableParts((*reinterpret_cast< const QCPAxis::SelectableParts(*)>(_a[1]))); break;
1600 ✗ case 9: _t->setSelectedParts((*reinterpret_cast< const QCPAxis::SelectableParts(*)>(_a[1]))); break;
1601 ✗ default: ;
1602 }
1603 ✗ } else if (_c == QMetaObject::IndexOfMethod) {
1604 ✗ int *result = reinterpret_cast<int *>(_a[0]);
1605 {
1606 using _t = void (QCPAxis::*)();
1607 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAxis::ticksRequest)) {
1608 ✗ *result = 0;
1609 ✗ return;
1610 }
1611 }
1612 {
1613 using _t = void (QCPAxis::*)(const QCPRange & );
1614 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAxis::rangeChanged)) {
1615 ✗ *result = 1;
1616 ✗ return;
1617 }
1618 }
1619 {
1620 using _t = void (QCPAxis::*)(const QCPRange & , const QCPRange & );
1621 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAxis::rangeChanged)) {
1622 ✗ *result = 2;
1623 ✗ return;
1624 }
1625 }
1626 {
1627 using _t = void (QCPAxis::*)(QCPAxis::ScaleType );
1628 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAxis::scaleTypeChanged)) {
1629 ✗ *result = 3;
1630 ✗ return;
1631 }
1632 }
1633 {
1634 using _t = void (QCPAxis::*)(const QCPAxis::SelectableParts & );
1635 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAxis::selectionChanged)) {
1636 ✗ *result = 4;
1637 ✗ return;
1638 }
1639 }
1640 {
1641 using _t = void (QCPAxis::*)(const QCPAxis::SelectableParts & );
1642 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAxis::selectableChanged)) {
1643 ✗ *result = 5;
1644 ✗ return;
1645 }
1646 }
1647 ✗ } else if (_c == QMetaObject::RegisterPropertyMetaType) {
1648 ✗ switch (_id) {
1649 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
1650 ✗ case 1:
1651 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxisRect* >(); break;
1652 ✗ case 51:
1653 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPGrid* >(); break;
1654 ✗ case 25:
1655 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QVector<QString> >(); break;
1656 ✗ case 24:
1657 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QVector<double> >(); break;
1658 }
1659 }
1660
1661 #ifndef QT_NO_PROPERTIES
1662 ✗ else if (_c == QMetaObject::ReadProperty) {
1663 ✗ auto *_t = static_cast<QCPAxis *>(_o);
1664 (void)_t;
1665 ✗ void *_v = _a[0];
1666 ✗ switch (_id) {
1667 ✗ case 0: *reinterpret_cast<int*>(_v) = QFlag(_t->axisType()); break;
1668 ✗ case 1: *reinterpret_cast< QCPAxisRect**>(_v) = _t->axisRect(); break;
1669 ✗ case 2: *reinterpret_cast< ScaleType*>(_v) = _t->scaleType(); break;
1670 ✗ case 3: *reinterpret_cast< double*>(_v) = _t->scaleLogBase(); break;
1671 ✗ case 4: *reinterpret_cast< QCPRange*>(_v) = _t->range(); break;
1672 ✗ case 5: *reinterpret_cast< bool*>(_v) = _t->rangeReversed(); break;
1673 ✗ case 6: *reinterpret_cast< bool*>(_v) = _t->autoTicks(); break;
1674 ✗ case 7: *reinterpret_cast< int*>(_v) = _t->autoTickCount(); break;
1675 ✗ case 8: *reinterpret_cast< bool*>(_v) = _t->autoTickLabels(); break;
1676 ✗ case 9: *reinterpret_cast< bool*>(_v) = _t->autoTickStep(); break;
1677 ✗ case 10: *reinterpret_cast< bool*>(_v) = _t->autoSubTicks(); break;
1678 ✗ case 11: *reinterpret_cast< bool*>(_v) = _t->ticks(); break;
1679 ✗ case 12: *reinterpret_cast< bool*>(_v) = _t->tickLabels(); break;
1680 ✗ case 13: *reinterpret_cast< int*>(_v) = _t->tickLabelPadding(); break;
1681 ✗ case 14: *reinterpret_cast< LabelType*>(_v) = _t->tickLabelType(); break;
1682 ✗ case 15: *reinterpret_cast< QFont*>(_v) = _t->tickLabelFont(); break;
1683 ✗ case 16: *reinterpret_cast< QColor*>(_v) = _t->tickLabelColor(); break;
1684 ✗ case 17: *reinterpret_cast< double*>(_v) = _t->tickLabelRotation(); break;
1685 ✗ case 18: *reinterpret_cast< LabelSide*>(_v) = _t->tickLabelSide(); break;
1686 ✗ case 19: *reinterpret_cast< QString*>(_v) = _t->dateTimeFormat(); break;
1687 ✗ case 20: *reinterpret_cast< Qt::TimeSpec*>(_v) = _t->dateTimeSpec(); break;
1688 ✗ case 21: *reinterpret_cast< QString*>(_v) = _t->numberFormat(); break;
1689 ✗ case 22: *reinterpret_cast< int*>(_v) = _t->numberPrecision(); break;
1690 ✗ case 23: *reinterpret_cast< double*>(_v) = _t->tickStep(); break;
1691 ✗ case 24: *reinterpret_cast< QVector<double>*>(_v) = _t->tickVector(); break;
1692 ✗ case 25: *reinterpret_cast< QVector<QString>*>(_v) = _t->tickVectorLabels(); break;
1693 ✗ case 26: *reinterpret_cast< int*>(_v) = _t->tickLengthIn(); break;
1694 ✗ case 27: *reinterpret_cast< int*>(_v) = _t->tickLengthOut(); break;
1695 ✗ case 28: *reinterpret_cast< int*>(_v) = _t->subTickCount(); break;
1696 ✗ case 29: *reinterpret_cast< int*>(_v) = _t->subTickLengthIn(); break;
1697 ✗ case 30: *reinterpret_cast< int*>(_v) = _t->subTickLengthOut(); break;
1698 ✗ case 31: *reinterpret_cast< QPen*>(_v) = _t->basePen(); break;
1699 ✗ case 32: *reinterpret_cast< QPen*>(_v) = _t->tickPen(); break;
1700 ✗ case 33: *reinterpret_cast< QPen*>(_v) = _t->subTickPen(); break;
1701 ✗ case 34: *reinterpret_cast< QFont*>(_v) = _t->labelFont(); break;
1702 ✗ case 35: *reinterpret_cast< QColor*>(_v) = _t->labelColor(); break;
1703 ✗ case 36: *reinterpret_cast< QString*>(_v) = _t->label(); break;
1704 ✗ case 37: *reinterpret_cast< int*>(_v) = _t->labelPadding(); break;
1705 ✗ case 38: *reinterpret_cast< int*>(_v) = _t->padding(); break;
1706 ✗ case 39: *reinterpret_cast< int*>(_v) = _t->offset(); break;
1707 ✗ case 40: *reinterpret_cast<int*>(_v) = QFlag(_t->selectedParts()); break;
1708 ✗ case 41: *reinterpret_cast<int*>(_v) = QFlag(_t->selectableParts()); break;
1709 ✗ case 42: *reinterpret_cast< QFont*>(_v) = _t->selectedTickLabelFont(); break;
1710 ✗ case 43: *reinterpret_cast< QFont*>(_v) = _t->selectedLabelFont(); break;
1711 ✗ case 44: *reinterpret_cast< QColor*>(_v) = _t->selectedTickLabelColor(); break;
1712 ✗ case 45: *reinterpret_cast< QColor*>(_v) = _t->selectedLabelColor(); break;
1713 ✗ case 46: *reinterpret_cast< QPen*>(_v) = _t->selectedBasePen(); break;
1714 ✗ case 47: *reinterpret_cast< QPen*>(_v) = _t->selectedTickPen(); break;
1715 ✗ case 48: *reinterpret_cast< QPen*>(_v) = _t->selectedSubTickPen(); break;
1716 ✗ case 49: *reinterpret_cast< QCPLineEnding*>(_v) = _t->lowerEnding(); break;
1717 ✗ case 50: *reinterpret_cast< QCPLineEnding*>(_v) = _t->upperEnding(); break;
1718 ✗ case 51: *reinterpret_cast< QCPGrid**>(_v) = _t->grid(); break;
1719 ✗ default: break;
1720 }
1721 ✗ } else if (_c == QMetaObject::WriteProperty) {
1722 ✗ auto *_t = static_cast<QCPAxis *>(_o);
1723 (void)_t;
1724 ✗ void *_v = _a[0];
1725 ✗ switch (_id) {
1726 ✗ case 2: _t->setScaleType(*reinterpret_cast< ScaleType*>(_v)); break;
1727 ✗ case 3: _t->setScaleLogBase(*reinterpret_cast< double*>(_v)); break;
1728 ✗ case 4: _t->setRange(*reinterpret_cast< QCPRange*>(_v)); break;
1729 ✗ case 5: _t->setRangeReversed(*reinterpret_cast< bool*>(_v)); break;
1730 ✗ case 6: _t->setAutoTicks(*reinterpret_cast< bool*>(_v)); break;
1731 ✗ case 7: _t->setAutoTickCount(*reinterpret_cast< int*>(_v)); break;
1732 ✗ case 8: _t->setAutoTickLabels(*reinterpret_cast< bool*>(_v)); break;
1733 ✗ case 9: _t->setAutoTickStep(*reinterpret_cast< bool*>(_v)); break;
1734 ✗ case 10: _t->setAutoSubTicks(*reinterpret_cast< bool*>(_v)); break;
1735 ✗ case 11: _t->setTicks(*reinterpret_cast< bool*>(_v)); break;
1736 ✗ case 12: _t->setTickLabels(*reinterpret_cast< bool*>(_v)); break;
1737 ✗ case 13: _t->setTickLabelPadding(*reinterpret_cast< int*>(_v)); break;
1738 ✗ case 14: _t->setTickLabelType(*reinterpret_cast< LabelType*>(_v)); break;
1739 ✗ case 15: _t->setTickLabelFont(*reinterpret_cast< QFont*>(_v)); break;
1740 ✗ case 16: _t->setTickLabelColor(*reinterpret_cast< QColor*>(_v)); break;
1741 ✗ case 17: _t->setTickLabelRotation(*reinterpret_cast< double*>(_v)); break;
1742 ✗ case 18: _t->setTickLabelSide(*reinterpret_cast< LabelSide*>(_v)); break;
1743 ✗ case 19: _t->setDateTimeFormat(*reinterpret_cast< QString*>(_v)); break;
1744 ✗ case 20: _t->setDateTimeSpec(*reinterpret_cast< Qt::TimeSpec*>(_v)); break;
1745 ✗ case 21: _t->setNumberFormat(*reinterpret_cast< QString*>(_v)); break;
1746 ✗ case 22: _t->setNumberPrecision(*reinterpret_cast< int*>(_v)); break;
1747 ✗ case 23: _t->setTickStep(*reinterpret_cast< double*>(_v)); break;
1748 ✗ case 24: _t->setTickVector(*reinterpret_cast< QVector<double>*>(_v)); break;
1749 ✗ case 25: _t->setTickVectorLabels(*reinterpret_cast< QVector<QString>*>(_v)); break;
1750 ✗ case 26: _t->setTickLengthIn(*reinterpret_cast< int*>(_v)); break;
1751 ✗ case 27: _t->setTickLengthOut(*reinterpret_cast< int*>(_v)); break;
1752 ✗ case 28: _t->setSubTickCount(*reinterpret_cast< int*>(_v)); break;
1753 ✗ case 29: _t->setSubTickLengthIn(*reinterpret_cast< int*>(_v)); break;
1754 ✗ case 30: _t->setSubTickLengthOut(*reinterpret_cast< int*>(_v)); break;
1755 ✗ case 31: _t->setBasePen(*reinterpret_cast< QPen*>(_v)); break;
1756 ✗ case 32: _t->setTickPen(*reinterpret_cast< QPen*>(_v)); break;
1757 ✗ case 33: _t->setSubTickPen(*reinterpret_cast< QPen*>(_v)); break;
1758 ✗ case 34: _t->setLabelFont(*reinterpret_cast< QFont*>(_v)); break;
1759 ✗ case 35: _t->setLabelColor(*reinterpret_cast< QColor*>(_v)); break;
1760 ✗ case 36: _t->setLabel(*reinterpret_cast< QString*>(_v)); break;
1761 ✗ case 37: _t->setLabelPadding(*reinterpret_cast< int*>(_v)); break;
1762 ✗ case 38: _t->setPadding(*reinterpret_cast< int*>(_v)); break;
1763 ✗ case 39: _t->setOffset(*reinterpret_cast< int*>(_v)); break;
1764 ✗ case 40: _t->setSelectedParts(QFlag(*reinterpret_cast<int*>(_v))); break;
1765 ✗ case 41: _t->setSelectableParts(QFlag(*reinterpret_cast<int*>(_v))); break;
1766 ✗ case 42: _t->setSelectedTickLabelFont(*reinterpret_cast< QFont*>(_v)); break;
1767 ✗ case 43: _t->setSelectedLabelFont(*reinterpret_cast< QFont*>(_v)); break;
1768 ✗ case 44: _t->setSelectedTickLabelColor(*reinterpret_cast< QColor*>(_v)); break;
1769 ✗ case 45: _t->setSelectedLabelColor(*reinterpret_cast< QColor*>(_v)); break;
1770 ✗ case 46: _t->setSelectedBasePen(*reinterpret_cast< QPen*>(_v)); break;
1771 ✗ case 47: _t->setSelectedTickPen(*reinterpret_cast< QPen*>(_v)); break;
1772 ✗ case 48: _t->setSelectedSubTickPen(*reinterpret_cast< QPen*>(_v)); break;
1773 ✗ case 49: _t->setLowerEnding(*reinterpret_cast< QCPLineEnding*>(_v)); break;
1774 ✗ case 50: _t->setUpperEnding(*reinterpret_cast< QCPLineEnding*>(_v)); break;
1775 ✗ default: break;
1776 }
1777 } else if (_c == QMetaObject::ResetProperty) {
1778 }
1779 #endif // QT_NO_PROPERTIES
1780 }
1781
1782 QT_INIT_METAOBJECT const QMetaObject QCPAxis::staticMetaObject = { {
1783 QMetaObject::SuperData::link<QCPLayerable::staticMetaObject>(),
1784 qt_meta_stringdata_QCPAxis.data,
1785 qt_meta_data_QCPAxis,
1786 qt_static_metacall,
1787 nullptr,
1788 nullptr
1789 } };
1790
1791
1792 ✗ const QMetaObject *QCPAxis::metaObject() const
1793 {
1794 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
1795 }
1796
1797 ✗ void *QCPAxis::qt_metacast(const char *_clname)
1798 {
1799 ✗ if (!_clname) return nullptr;
1800 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPAxis.stringdata0))
1801 ✗ return static_cast<void*>(this);
1802 ✗ return QCPLayerable::qt_metacast(_clname);
1803 }
1804
1805 ✗ int QCPAxis::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
1806 {
1807 ✗ _id = QCPLayerable::qt_metacall(_c, _id, _a);
1808 ✗ if (_id < 0)
1809 ✗ return _id;
1810 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
1811 ✗ if (_id < 10)
1812 ✗ qt_static_metacall(this, _c, _id, _a);
1813 ✗ _id -= 10;
1814 ✗ } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
1815 ✗ if (_id < 10)
1816 ✗ *reinterpret_cast<int*>(_a[0]) = -1;
1817 ✗ _id -= 10;
1818 }
1819 #ifndef QT_NO_PROPERTIES
1820 ✗ else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
1821 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
1822 ✗ qt_static_metacall(this, _c, _id, _a);
1823 ✗ _id -= 52;
1824 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
1825 ✗ _id -= 52;
1826 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
1827 ✗ _id -= 52;
1828 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
1829 ✗ _id -= 52;
1830 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
1831 ✗ _id -= 52;
1832 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
1833 ✗ _id -= 52;
1834 }
1835 #endif // QT_NO_PROPERTIES
1836 ✗ return _id;
1837 }
1838
1839 // SIGNAL 0
1840 ✗ void QCPAxis::ticksRequest()
1841 {
1842 ✗ QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
1843 }
1844
1845 // SIGNAL 1
1846 ✗ void QCPAxis::rangeChanged(const QCPRange & _t1)
1847 {
1848 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1849 ✗ QMetaObject::activate(this, &staticMetaObject, 1, _a);
1850 }
1851
1852 // SIGNAL 2
1853 ✗ void QCPAxis::rangeChanged(const QCPRange & _t1, const QCPRange & _t2)
1854 {
1855 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
1856 ✗ QMetaObject::activate(this, &staticMetaObject, 2, _a);
1857 }
1858
1859 // SIGNAL 3
1860 ✗ void QCPAxis::scaleTypeChanged(QCPAxis::ScaleType _t1)
1861 {
1862 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1863 ✗ QMetaObject::activate(this, &staticMetaObject, 3, _a);
1864 }
1865
1866 // SIGNAL 4
1867 ✗ void QCPAxis::selectionChanged(const QCPAxis::SelectableParts & _t1)
1868 {
1869 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1870 ✗ QMetaObject::activate(this, &staticMetaObject, 4, _a);
1871 }
1872
1873 // SIGNAL 5
1874 ✗ void QCPAxis::selectableChanged(const QCPAxis::SelectableParts & _t1)
1875 {
1876 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
1877 ✗ QMetaObject::activate(this, &staticMetaObject, 5, _a);
1878 }
1879 struct qt_meta_stringdata_QCPAbstractPlottable_t {
1880 QByteArrayData data[19];
1881 char stringdata0[228];
1882 };
1883 #define QT_MOC_LITERAL(idx, ofs, len) \
1884 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
1885 qptrdiff(offsetof(qt_meta_stringdata_QCPAbstractPlottable_t, stringdata0) + ofs \
1886 - idx * sizeof(QByteArrayData)) \
1887 )
1888 static const qt_meta_stringdata_QCPAbstractPlottable_t qt_meta_stringdata_QCPAbstractPlottable = {
1889 {
1890 QT_MOC_LITERAL(0, 0, 20), // "QCPAbstractPlottable"
1891 QT_MOC_LITERAL(1, 21, 16), // "selectionChanged"
1892 QT_MOC_LITERAL(2, 38, 0), // ""
1893 QT_MOC_LITERAL(3, 39, 8), // "selected"
1894 QT_MOC_LITERAL(4, 48, 17), // "selectableChanged"
1895 QT_MOC_LITERAL(5, 66, 10), // "selectable"
1896 QT_MOC_LITERAL(6, 77, 13), // "setSelectable"
1897 QT_MOC_LITERAL(7, 91, 11), // "setSelected"
1898 QT_MOC_LITERAL(8, 103, 4), // "name"
1899 QT_MOC_LITERAL(9, 108, 15), // "antialiasedFill"
1900 QT_MOC_LITERAL(10, 124, 19), // "antialiasedScatters"
1901 QT_MOC_LITERAL(11, 144, 20), // "antialiasedErrorBars"
1902 QT_MOC_LITERAL(12, 165, 3), // "pen"
1903 QT_MOC_LITERAL(13, 169, 11), // "selectedPen"
1904 QT_MOC_LITERAL(14, 181, 5), // "brush"
1905 QT_MOC_LITERAL(15, 187, 13), // "selectedBrush"
1906 QT_MOC_LITERAL(16, 201, 7), // "keyAxis"
1907 QT_MOC_LITERAL(17, 209, 8), // "QCPAxis*"
1908 QT_MOC_LITERAL(18, 218, 9) // "valueAxis"
1909
1910 },
1911 "QCPAbstractPlottable\0selectionChanged\0"
1912 "\0selected\0selectableChanged\0selectable\0"
1913 "setSelectable\0setSelected\0name\0"
1914 "antialiasedFill\0antialiasedScatters\0"
1915 "antialiasedErrorBars\0pen\0selectedPen\0"
1916 "brush\0selectedBrush\0keyAxis\0QCPAxis*\0"
1917 "valueAxis"
1918 };
1919 #undef QT_MOC_LITERAL
1920
1921 static const uint qt_meta_data_QCPAbstractPlottable[] = {
1922
1923 // content:
1924 8, // revision
1925 0, // classname
1926 0, 0, // classinfo
1927 4, 14, // methods
1928 12, 46, // properties
1929 0, 0, // enums/sets
1930 0, 0, // constructors
1931 0, // flags
1932 2, // signalCount
1933
1934 // signals: name, argc, parameters, tag, flags
1935 1, 1, 34, 2, 0x06 /* Public */,
1936 4, 1, 37, 2, 0x06 /* Public */,
1937
1938 // slots: name, argc, parameters, tag, flags
1939 6, 1, 40, 2, 0x0a /* Public */,
1940 7, 1, 43, 2, 0x0a /* Public */,
1941
1942 // signals: parameters
1943 QMetaType::Void, QMetaType::Bool, 3,
1944 QMetaType::Void, QMetaType::Bool, 5,
1945
1946 // slots: parameters
1947 QMetaType::Void, QMetaType::Bool, 5,
1948 QMetaType::Void, QMetaType::Bool, 3,
1949
1950 // properties: name, type, flags
1951 8, QMetaType::QString, 0x00095103,
1952 9, QMetaType::Bool, 0x00095103,
1953 10, QMetaType::Bool, 0x00095103,
1954 11, QMetaType::Bool, 0x00095103,
1955 12, QMetaType::QPen, 0x00095103,
1956 13, QMetaType::QPen, 0x00095103,
1957 14, QMetaType::QBrush, 0x00095103,
1958 15, QMetaType::QBrush, 0x00095103,
1959 16, 0x80000000 | 17, 0x0009510b,
1960 18, 0x80000000 | 17, 0x0009510b,
1961 5, QMetaType::Bool, 0x00495103,
1962 3, QMetaType::Bool, 0x00495103,
1963
1964 // properties: notify_signal_id
1965 0,
1966 0,
1967 0,
1968 0,
1969 0,
1970 0,
1971 0,
1972 0,
1973 0,
1974 0,
1975 1,
1976 0,
1977
1978 0 // eod
1979 };
1980
1981 ✗ void QCPAbstractPlottable::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
1982 {
1983 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
1984 ✗ auto *_t = static_cast<QCPAbstractPlottable *>(_o);
1985 (void)_t;
1986 ✗ switch (_id) {
1987 ✗ case 0: _t->selectionChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
1988 ✗ case 1: _t->selectableChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
1989 ✗ case 2: _t->setSelectable((*reinterpret_cast< bool(*)>(_a[1]))); break;
1990 ✗ case 3: _t->setSelected((*reinterpret_cast< bool(*)>(_a[1]))); break;
1991 ✗ default: ;
1992 }
1993 ✗ } else if (_c == QMetaObject::IndexOfMethod) {
1994 ✗ int *result = reinterpret_cast<int *>(_a[0]);
1995 {
1996 using _t = void (QCPAbstractPlottable::*)(bool );
1997 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAbstractPlottable::selectionChanged)) {
1998 ✗ *result = 0;
1999 ✗ return;
2000 }
2001 }
2002 {
2003 using _t = void (QCPAbstractPlottable::*)(bool );
2004 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAbstractPlottable::selectableChanged)) {
2005 ✗ *result = 1;
2006 ✗ return;
2007 }
2008 }
2009 ✗ } else if (_c == QMetaObject::RegisterPropertyMetaType) {
2010 ✗ switch (_id) {
2011 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2012 ✗ case 9:
2013 case 8:
2014 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxis* >(); break;
2015 }
2016 }
2017
2018 #ifndef QT_NO_PROPERTIES
2019 ✗ else if (_c == QMetaObject::ReadProperty) {
2020 ✗ auto *_t = static_cast<QCPAbstractPlottable *>(_o);
2021 (void)_t;
2022 ✗ void *_v = _a[0];
2023 ✗ switch (_id) {
2024 ✗ case 0: *reinterpret_cast< QString*>(_v) = _t->name(); break;
2025 ✗ case 1: *reinterpret_cast< bool*>(_v) = _t->antialiasedFill(); break;
2026 ✗ case 2: *reinterpret_cast< bool*>(_v) = _t->antialiasedScatters(); break;
2027 ✗ case 3: *reinterpret_cast< bool*>(_v) = _t->antialiasedErrorBars(); break;
2028 ✗ case 4: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
2029 ✗ case 5: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
2030 ✗ case 6: *reinterpret_cast< QBrush*>(_v) = _t->brush(); break;
2031 ✗ case 7: *reinterpret_cast< QBrush*>(_v) = _t->selectedBrush(); break;
2032 ✗ case 8: *reinterpret_cast< QCPAxis**>(_v) = _t->keyAxis(); break;
2033 ✗ case 9: *reinterpret_cast< QCPAxis**>(_v) = _t->valueAxis(); break;
2034 ✗ case 10: *reinterpret_cast< bool*>(_v) = _t->selectable(); break;
2035 ✗ case 11: *reinterpret_cast< bool*>(_v) = _t->selected(); break;
2036 ✗ default: break;
2037 }
2038 ✗ } else if (_c == QMetaObject::WriteProperty) {
2039 ✗ auto *_t = static_cast<QCPAbstractPlottable *>(_o);
2040 (void)_t;
2041 ✗ void *_v = _a[0];
2042 ✗ switch (_id) {
2043 ✗ case 0: _t->setName(*reinterpret_cast< QString*>(_v)); break;
2044 ✗ case 1: _t->setAntialiasedFill(*reinterpret_cast< bool*>(_v)); break;
2045 ✗ case 2: _t->setAntialiasedScatters(*reinterpret_cast< bool*>(_v)); break;
2046 ✗ case 3: _t->setAntialiasedErrorBars(*reinterpret_cast< bool*>(_v)); break;
2047 ✗ case 4: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
2048 ✗ case 5: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
2049 ✗ case 6: _t->setBrush(*reinterpret_cast< QBrush*>(_v)); break;
2050 ✗ case 7: _t->setSelectedBrush(*reinterpret_cast< QBrush*>(_v)); break;
2051 ✗ case 8: _t->setKeyAxis(*reinterpret_cast< QCPAxis**>(_v)); break;
2052 ✗ case 9: _t->setValueAxis(*reinterpret_cast< QCPAxis**>(_v)); break;
2053 ✗ case 10: _t->setSelectable(*reinterpret_cast< bool*>(_v)); break;
2054 ✗ case 11: _t->setSelected(*reinterpret_cast< bool*>(_v)); break;
2055 ✗ default: break;
2056 }
2057 } else if (_c == QMetaObject::ResetProperty) {
2058 }
2059 #endif // QT_NO_PROPERTIES
2060 }
2061
2062 QT_INIT_METAOBJECT const QMetaObject QCPAbstractPlottable::staticMetaObject = { {
2063 QMetaObject::SuperData::link<QCPLayerable::staticMetaObject>(),
2064 qt_meta_stringdata_QCPAbstractPlottable.data,
2065 qt_meta_data_QCPAbstractPlottable,
2066 qt_static_metacall,
2067 nullptr,
2068 nullptr
2069 } };
2070
2071
2072 ✗ const QMetaObject *QCPAbstractPlottable::metaObject() const
2073 {
2074 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
2075 }
2076
2077 ✗ void *QCPAbstractPlottable::qt_metacast(const char *_clname)
2078 {
2079 ✗ if (!_clname) return nullptr;
2080 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPAbstractPlottable.stringdata0))
2081 ✗ return static_cast<void*>(this);
2082 ✗ return QCPLayerable::qt_metacast(_clname);
2083 }
2084
2085 ✗ int QCPAbstractPlottable::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
2086 {
2087 ✗ _id = QCPLayerable::qt_metacall(_c, _id, _a);
2088 ✗ if (_id < 0)
2089 ✗ return _id;
2090 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
2091 ✗ if (_id < 4)
2092 ✗ qt_static_metacall(this, _c, _id, _a);
2093 ✗ _id -= 4;
2094 ✗ } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
2095 ✗ if (_id < 4)
2096 ✗ *reinterpret_cast<int*>(_a[0]) = -1;
2097 ✗ _id -= 4;
2098 }
2099 #ifndef QT_NO_PROPERTIES
2100 ✗ else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
2101 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
2102 ✗ qt_static_metacall(this, _c, _id, _a);
2103 ✗ _id -= 12;
2104 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
2105 ✗ _id -= 12;
2106 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
2107 ✗ _id -= 12;
2108 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
2109 ✗ _id -= 12;
2110 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
2111 ✗ _id -= 12;
2112 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
2113 ✗ _id -= 12;
2114 }
2115 #endif // QT_NO_PROPERTIES
2116 ✗ return _id;
2117 }
2118
2119 // SIGNAL 0
2120 ✗ void QCPAbstractPlottable::selectionChanged(bool _t1)
2121 {
2122 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
2123 ✗ QMetaObject::activate(this, &staticMetaObject, 0, _a);
2124 }
2125
2126 // SIGNAL 1
2127 ✗ void QCPAbstractPlottable::selectableChanged(bool _t1)
2128 {
2129 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
2130 ✗ QMetaObject::activate(this, &staticMetaObject, 1, _a);
2131 }
2132 struct qt_meta_stringdata_QCPAbstractItem_t {
2133 QByteArrayData data[11];
2134 char stringdata0[139];
2135 };
2136 #define QT_MOC_LITERAL(idx, ofs, len) \
2137 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
2138 qptrdiff(offsetof(qt_meta_stringdata_QCPAbstractItem_t, stringdata0) + ofs \
2139 - idx * sizeof(QByteArrayData)) \
2140 )
2141 static const qt_meta_stringdata_QCPAbstractItem_t qt_meta_stringdata_QCPAbstractItem = {
2142 {
2143 QT_MOC_LITERAL(0, 0, 15), // "QCPAbstractItem"
2144 QT_MOC_LITERAL(1, 16, 16), // "selectionChanged"
2145 QT_MOC_LITERAL(2, 33, 0), // ""
2146 QT_MOC_LITERAL(3, 34, 8), // "selected"
2147 QT_MOC_LITERAL(4, 43, 17), // "selectableChanged"
2148 QT_MOC_LITERAL(5, 61, 10), // "selectable"
2149 QT_MOC_LITERAL(6, 72, 13), // "setSelectable"
2150 QT_MOC_LITERAL(7, 86, 11), // "setSelected"
2151 QT_MOC_LITERAL(8, 98, 14), // "clipToAxisRect"
2152 QT_MOC_LITERAL(9, 113, 12), // "clipAxisRect"
2153 QT_MOC_LITERAL(10, 126, 12) // "QCPAxisRect*"
2154
2155 },
2156 "QCPAbstractItem\0selectionChanged\0\0"
2157 "selected\0selectableChanged\0selectable\0"
2158 "setSelectable\0setSelected\0clipToAxisRect\0"
2159 "clipAxisRect\0QCPAxisRect*"
2160 };
2161 #undef QT_MOC_LITERAL
2162
2163 static const uint qt_meta_data_QCPAbstractItem[] = {
2164
2165 // content:
2166 8, // revision
2167 0, // classname
2168 0, 0, // classinfo
2169 4, 14, // methods
2170 4, 46, // properties
2171 0, 0, // enums/sets
2172 0, 0, // constructors
2173 0, // flags
2174 2, // signalCount
2175
2176 // signals: name, argc, parameters, tag, flags
2177 1, 1, 34, 2, 0x06 /* Public */,
2178 4, 1, 37, 2, 0x06 /* Public */,
2179
2180 // slots: name, argc, parameters, tag, flags
2181 6, 1, 40, 2, 0x0a /* Public */,
2182 7, 1, 43, 2, 0x0a /* Public */,
2183
2184 // signals: parameters
2185 QMetaType::Void, QMetaType::Bool, 3,
2186 QMetaType::Void, QMetaType::Bool, 5,
2187
2188 // slots: parameters
2189 QMetaType::Void, QMetaType::Bool, 5,
2190 QMetaType::Void, QMetaType::Bool, 3,
2191
2192 // properties: name, type, flags
2193 8, QMetaType::Bool, 0x00095103,
2194 9, 0x80000000 | 10, 0x0009510b,
2195 5, QMetaType::Bool, 0x00495103,
2196 3, QMetaType::Bool, 0x00495103,
2197
2198 // properties: notify_signal_id
2199 0,
2200 0,
2201 1,
2202 0,
2203
2204 0 // eod
2205 };
2206
2207 ✗ void QCPAbstractItem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
2208 {
2209 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
2210 ✗ auto *_t = static_cast<QCPAbstractItem *>(_o);
2211 (void)_t;
2212 ✗ switch (_id) {
2213 ✗ case 0: _t->selectionChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
2214 ✗ case 1: _t->selectableChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
2215 ✗ case 2: _t->setSelectable((*reinterpret_cast< bool(*)>(_a[1]))); break;
2216 ✗ case 3: _t->setSelected((*reinterpret_cast< bool(*)>(_a[1]))); break;
2217 ✗ default: ;
2218 }
2219 ✗ } else if (_c == QMetaObject::IndexOfMethod) {
2220 ✗ int *result = reinterpret_cast<int *>(_a[0]);
2221 {
2222 using _t = void (QCPAbstractItem::*)(bool );
2223 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAbstractItem::selectionChanged)) {
2224 ✗ *result = 0;
2225 ✗ return;
2226 }
2227 }
2228 {
2229 using _t = void (QCPAbstractItem::*)(bool );
2230 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAbstractItem::selectableChanged)) {
2231 ✗ *result = 1;
2232 ✗ return;
2233 }
2234 }
2235 ✗ } else if (_c == QMetaObject::RegisterPropertyMetaType) {
2236 ✗ switch (_id) {
2237 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2238 ✗ case 1:
2239 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxisRect* >(); break;
2240 }
2241 }
2242
2243 #ifndef QT_NO_PROPERTIES
2244 ✗ else if (_c == QMetaObject::ReadProperty) {
2245 ✗ auto *_t = static_cast<QCPAbstractItem *>(_o);
2246 (void)_t;
2247 ✗ void *_v = _a[0];
2248 ✗ switch (_id) {
2249 ✗ case 0: *reinterpret_cast< bool*>(_v) = _t->clipToAxisRect(); break;
2250 ✗ case 1: *reinterpret_cast< QCPAxisRect**>(_v) = _t->clipAxisRect(); break;
2251 ✗ case 2: *reinterpret_cast< bool*>(_v) = _t->selectable(); break;
2252 ✗ case 3: *reinterpret_cast< bool*>(_v) = _t->selected(); break;
2253 ✗ default: break;
2254 }
2255 ✗ } else if (_c == QMetaObject::WriteProperty) {
2256 ✗ auto *_t = static_cast<QCPAbstractItem *>(_o);
2257 (void)_t;
2258 ✗ void *_v = _a[0];
2259 ✗ switch (_id) {
2260 ✗ case 0: _t->setClipToAxisRect(*reinterpret_cast< bool*>(_v)); break;
2261 ✗ case 1: _t->setClipAxisRect(*reinterpret_cast< QCPAxisRect**>(_v)); break;
2262 ✗ case 2: _t->setSelectable(*reinterpret_cast< bool*>(_v)); break;
2263 ✗ case 3: _t->setSelected(*reinterpret_cast< bool*>(_v)); break;
2264 ✗ default: break;
2265 }
2266 } else if (_c == QMetaObject::ResetProperty) {
2267 }
2268 #endif // QT_NO_PROPERTIES
2269 }
2270
2271 QT_INIT_METAOBJECT const QMetaObject QCPAbstractItem::staticMetaObject = { {
2272 QMetaObject::SuperData::link<QCPLayerable::staticMetaObject>(),
2273 qt_meta_stringdata_QCPAbstractItem.data,
2274 qt_meta_data_QCPAbstractItem,
2275 qt_static_metacall,
2276 nullptr,
2277 nullptr
2278 } };
2279
2280
2281 ✗ const QMetaObject *QCPAbstractItem::metaObject() const
2282 {
2283 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
2284 }
2285
2286 ✗ void *QCPAbstractItem::qt_metacast(const char *_clname)
2287 {
2288 ✗ if (!_clname) return nullptr;
2289 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPAbstractItem.stringdata0))
2290 ✗ return static_cast<void*>(this);
2291 ✗ return QCPLayerable::qt_metacast(_clname);
2292 }
2293
2294 ✗ int QCPAbstractItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
2295 {
2296 ✗ _id = QCPLayerable::qt_metacall(_c, _id, _a);
2297 ✗ if (_id < 0)
2298 ✗ return _id;
2299 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
2300 ✗ if (_id < 4)
2301 ✗ qt_static_metacall(this, _c, _id, _a);
2302 ✗ _id -= 4;
2303 ✗ } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
2304 ✗ if (_id < 4)
2305 ✗ *reinterpret_cast<int*>(_a[0]) = -1;
2306 ✗ _id -= 4;
2307 }
2308 #ifndef QT_NO_PROPERTIES
2309 ✗ else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
2310 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
2311 ✗ qt_static_metacall(this, _c, _id, _a);
2312 ✗ _id -= 4;
2313 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
2314 ✗ _id -= 4;
2315 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
2316 ✗ _id -= 4;
2317 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
2318 ✗ _id -= 4;
2319 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
2320 ✗ _id -= 4;
2321 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
2322 ✗ _id -= 4;
2323 }
2324 #endif // QT_NO_PROPERTIES
2325 ✗ return _id;
2326 }
2327
2328 // SIGNAL 0
2329 ✗ void QCPAbstractItem::selectionChanged(bool _t1)
2330 {
2331 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
2332 ✗ QMetaObject::activate(this, &staticMetaObject, 0, _a);
2333 }
2334
2335 // SIGNAL 1
2336 ✗ void QCPAbstractItem::selectableChanged(bool _t1)
2337 {
2338 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
2339 ✗ QMetaObject::activate(this, &staticMetaObject, 1, _a);
2340 }
2341 struct qt_meta_stringdata_QCustomPlot_t {
2342 QByteArrayData data[57];
2343 char stringdata0[801];
2344 };
2345 #define QT_MOC_LITERAL(idx, ofs, len) \
2346 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
2347 qptrdiff(offsetof(qt_meta_stringdata_QCustomPlot_t, stringdata0) + ofs \
2348 - idx * sizeof(QByteArrayData)) \
2349 )
2350 static const qt_meta_stringdata_QCustomPlot_t qt_meta_stringdata_QCustomPlot = {
2351 {
2352 QT_MOC_LITERAL(0, 0, 11), // "QCustomPlot"
2353 QT_MOC_LITERAL(1, 12, 16), // "mouseDoubleClick"
2354 QT_MOC_LITERAL(2, 29, 0), // ""
2355 QT_MOC_LITERAL(3, 30, 12), // "QMouseEvent*"
2356 QT_MOC_LITERAL(4, 43, 5), // "event"
2357 QT_MOC_LITERAL(5, 49, 10), // "mousePress"
2358 QT_MOC_LITERAL(6, 60, 9), // "mouseMove"
2359 QT_MOC_LITERAL(7, 70, 12), // "mouseRelease"
2360 QT_MOC_LITERAL(8, 83, 10), // "mouseWheel"
2361 QT_MOC_LITERAL(9, 94, 12), // "QWheelEvent*"
2362 QT_MOC_LITERAL(10, 107, 14), // "plottableClick"
2363 QT_MOC_LITERAL(11, 122, 21), // "QCPAbstractPlottable*"
2364 QT_MOC_LITERAL(12, 144, 9), // "plottable"
2365 QT_MOC_LITERAL(13, 154, 20), // "plottableDoubleClick"
2366 QT_MOC_LITERAL(14, 175, 9), // "itemClick"
2367 QT_MOC_LITERAL(15, 185, 16), // "QCPAbstractItem*"
2368 QT_MOC_LITERAL(16, 202, 4), // "item"
2369 QT_MOC_LITERAL(17, 207, 15), // "itemDoubleClick"
2370 QT_MOC_LITERAL(18, 223, 9), // "axisClick"
2371 QT_MOC_LITERAL(19, 233, 8), // "QCPAxis*"
2372 QT_MOC_LITERAL(20, 242, 4), // "axis"
2373 QT_MOC_LITERAL(21, 247, 23), // "QCPAxis::SelectablePart"
2374 QT_MOC_LITERAL(22, 271, 4), // "part"
2375 QT_MOC_LITERAL(23, 276, 15), // "axisDoubleClick"
2376 QT_MOC_LITERAL(24, 292, 11), // "legendClick"
2377 QT_MOC_LITERAL(25, 304, 10), // "QCPLegend*"
2378 QT_MOC_LITERAL(26, 315, 6), // "legend"
2379 QT_MOC_LITERAL(27, 322, 22), // "QCPAbstractLegendItem*"
2380 QT_MOC_LITERAL(28, 345, 17), // "legendDoubleClick"
2381 QT_MOC_LITERAL(29, 363, 10), // "titleClick"
2382 QT_MOC_LITERAL(30, 374, 13), // "QCPPlotTitle*"
2383 QT_MOC_LITERAL(31, 388, 5), // "title"
2384 QT_MOC_LITERAL(32, 394, 16), // "titleDoubleClick"
2385 QT_MOC_LITERAL(33, 411, 22), // "selectionChangedByUser"
2386 QT_MOC_LITERAL(34, 434, 12), // "beforeReplot"
2387 QT_MOC_LITERAL(35, 447, 11), // "afterReplot"
2388 QT_MOC_LITERAL(36, 459, 11), // "rescaleAxes"
2389 QT_MOC_LITERAL(37, 471, 21), // "onlyVisiblePlottables"
2390 QT_MOC_LITERAL(38, 493, 11), // "deselectAll"
2391 QT_MOC_LITERAL(39, 505, 6), // "replot"
2392 QT_MOC_LITERAL(40, 512, 28), // "QCustomPlot::RefreshPriority"
2393 QT_MOC_LITERAL(41, 541, 15), // "refreshPriority"
2394 QT_MOC_LITERAL(42, 557, 8), // "viewport"
2395 QT_MOC_LITERAL(43, 566, 10), // "background"
2396 QT_MOC_LITERAL(44, 577, 16), // "backgroundScaled"
2397 QT_MOC_LITERAL(45, 594, 20), // "backgroundScaledMode"
2398 QT_MOC_LITERAL(46, 615, 19), // "Qt::AspectRatioMode"
2399 QT_MOC_LITERAL(47, 635, 10), // "plotLayout"
2400 QT_MOC_LITERAL(48, 646, 14), // "QCPLayoutGrid*"
2401 QT_MOC_LITERAL(49, 661, 24), // "autoAddPlottableToLegend"
2402 QT_MOC_LITERAL(50, 686, 18), // "selectionTolerance"
2403 QT_MOC_LITERAL(51, 705, 20), // "noAntialiasingOnDrag"
2404 QT_MOC_LITERAL(52, 726, 19), // "multiSelectModifier"
2405 QT_MOC_LITERAL(53, 746, 20), // "Qt::KeyboardModifier"
2406 QT_MOC_LITERAL(54, 767, 15), // "LayerInsertMode"
2407 QT_MOC_LITERAL(55, 783, 8), // "limBelow"
2408 QT_MOC_LITERAL(56, 792, 8) // "limAbove"
2409
2410 },
2411 "QCustomPlot\0mouseDoubleClick\0\0"
2412 "QMouseEvent*\0event\0mousePress\0mouseMove\0"
2413 "mouseRelease\0mouseWheel\0QWheelEvent*\0"
2414 "plottableClick\0QCPAbstractPlottable*\0"
2415 "plottable\0plottableDoubleClick\0itemClick\0"
2416 "QCPAbstractItem*\0item\0itemDoubleClick\0"
2417 "axisClick\0QCPAxis*\0axis\0QCPAxis::SelectablePart\0"
2418 "part\0axisDoubleClick\0legendClick\0"
2419 "QCPLegend*\0legend\0QCPAbstractLegendItem*\0"
2420 "legendDoubleClick\0titleClick\0QCPPlotTitle*\0"
2421 "title\0titleDoubleClick\0selectionChangedByUser\0"
2422 "beforeReplot\0afterReplot\0rescaleAxes\0"
2423 "onlyVisiblePlottables\0deselectAll\0"
2424 "replot\0QCustomPlot::RefreshPriority\0"
2425 "refreshPriority\0viewport\0background\0"
2426 "backgroundScaled\0backgroundScaledMode\0"
2427 "Qt::AspectRatioMode\0plotLayout\0"
2428 "QCPLayoutGrid*\0autoAddPlottableToLegend\0"
2429 "selectionTolerance\0noAntialiasingOnDrag\0"
2430 "multiSelectModifier\0Qt::KeyboardModifier\0"
2431 "LayerInsertMode\0limBelow\0limAbove"
2432 };
2433 #undef QT_MOC_LITERAL
2434
2435 static const uint qt_meta_data_QCustomPlot[] = {
2436
2437 // content:
2438 8, // revision
2439 0, // classname
2440 0, 0, // classinfo
2441 23, 14, // methods
2442 9, 214, // properties
2443 1, 241, // enums/sets
2444 0, 0, // constructors
2445 0, // flags
2446 18, // signalCount
2447
2448 // signals: name, argc, parameters, tag, flags
2449 1, 1, 129, 2, 0x06 /* Public */,
2450 5, 1, 132, 2, 0x06 /* Public */,
2451 6, 1, 135, 2, 0x06 /* Public */,
2452 7, 1, 138, 2, 0x06 /* Public */,
2453 8, 1, 141, 2, 0x06 /* Public */,
2454 10, 2, 144, 2, 0x06 /* Public */,
2455 13, 2, 149, 2, 0x06 /* Public */,
2456 14, 2, 154, 2, 0x06 /* Public */,
2457 17, 2, 159, 2, 0x06 /* Public */,
2458 18, 3, 164, 2, 0x06 /* Public */,
2459 23, 3, 171, 2, 0x06 /* Public */,
2460 24, 3, 178, 2, 0x06 /* Public */,
2461 28, 3, 185, 2, 0x06 /* Public */,
2462 29, 2, 192, 2, 0x06 /* Public */,
2463 32, 2, 197, 2, 0x06 /* Public */,
2464 33, 0, 202, 2, 0x06 /* Public */,
2465 34, 0, 203, 2, 0x06 /* Public */,
2466 35, 0, 204, 2, 0x06 /* Public */,
2467
2468 // slots: name, argc, parameters, tag, flags
2469 36, 1, 205, 2, 0x0a /* Public */,
2470 36, 0, 208, 2, 0x2a /* Public | MethodCloned */,
2471 38, 0, 209, 2, 0x0a /* Public */,
2472 39, 1, 210, 2, 0x0a /* Public */,
2473 39, 0, 213, 2, 0x2a /* Public | MethodCloned */,
2474
2475 // signals: parameters
2476 QMetaType::Void, 0x80000000 | 3, 4,
2477 QMetaType::Void, 0x80000000 | 3, 4,
2478 QMetaType::Void, 0x80000000 | 3, 4,
2479 QMetaType::Void, 0x80000000 | 3, 4,
2480 QMetaType::Void, 0x80000000 | 9, 4,
2481 QMetaType::Void, 0x80000000 | 11, 0x80000000 | 3, 12, 4,
2482 QMetaType::Void, 0x80000000 | 11, 0x80000000 | 3, 12, 4,
2483 QMetaType::Void, 0x80000000 | 15, 0x80000000 | 3, 16, 4,
2484 QMetaType::Void, 0x80000000 | 15, 0x80000000 | 3, 16, 4,
2485 QMetaType::Void, 0x80000000 | 19, 0x80000000 | 21, 0x80000000 | 3, 20, 22, 4,
2486 QMetaType::Void, 0x80000000 | 19, 0x80000000 | 21, 0x80000000 | 3, 20, 22, 4,
2487 QMetaType::Void, 0x80000000 | 25, 0x80000000 | 27, 0x80000000 | 3, 26, 16, 4,
2488 QMetaType::Void, 0x80000000 | 25, 0x80000000 | 27, 0x80000000 | 3, 26, 16, 4,
2489 QMetaType::Void, 0x80000000 | 3, 0x80000000 | 30, 4, 31,
2490 QMetaType::Void, 0x80000000 | 3, 0x80000000 | 30, 4, 31,
2491 QMetaType::Void,
2492 QMetaType::Void,
2493 QMetaType::Void,
2494
2495 // slots: parameters
2496 QMetaType::Void, QMetaType::Bool, 37,
2497 QMetaType::Void,
2498 QMetaType::Void,
2499 QMetaType::Void, 0x80000000 | 40, 41,
2500 QMetaType::Void,
2501
2502 // properties: name, type, flags
2503 42, QMetaType::QRect, 0x00095103,
2504 43, QMetaType::QPixmap, 0x00095103,
2505 44, QMetaType::Bool, 0x00095103,
2506 45, 0x80000000 | 46, 0x0009510b,
2507 47, 0x80000000 | 48, 0x00095009,
2508 49, QMetaType::Bool, 0x00095103,
2509 50, QMetaType::Int, 0x00095103,
2510 51, QMetaType::Bool, 0x00095103,
2511 52, 0x80000000 | 53, 0x0009510b,
2512
2513 // enums: name, alias, flags, count, data
2514 54, 54, 0x0, 2, 246,
2515
2516 // enum data: key, value
2517 55, uint(QCustomPlot::limBelow),
2518 56, uint(QCustomPlot::limAbove),
2519
2520 0 // eod
2521 };
2522
2523 ✗ void QCustomPlot::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
2524 {
2525 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
2526 ✗ auto *_t = static_cast<QCustomPlot *>(_o);
2527 (void)_t;
2528 ✗ switch (_id) {
2529 ✗ case 0: _t->mouseDoubleClick((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
2530 ✗ case 1: _t->mousePress((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
2531 ✗ case 2: _t->mouseMove((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
2532 ✗ case 3: _t->mouseRelease((*reinterpret_cast< QMouseEvent*(*)>(_a[1]))); break;
2533 ✗ case 4: _t->mouseWheel((*reinterpret_cast< QWheelEvent*(*)>(_a[1]))); break;
2534 ✗ case 5: _t->plottableClick((*reinterpret_cast< QCPAbstractPlottable*(*)>(_a[1])),(*reinterpret_cast< QMouseEvent*(*)>(_a[2]))); break;
2535 ✗ case 6: _t->plottableDoubleClick((*reinterpret_cast< QCPAbstractPlottable*(*)>(_a[1])),(*reinterpret_cast< QMouseEvent*(*)>(_a[2]))); break;
2536 ✗ case 7: _t->itemClick((*reinterpret_cast< QCPAbstractItem*(*)>(_a[1])),(*reinterpret_cast< QMouseEvent*(*)>(_a[2]))); break;
2537 ✗ case 8: _t->itemDoubleClick((*reinterpret_cast< QCPAbstractItem*(*)>(_a[1])),(*reinterpret_cast< QMouseEvent*(*)>(_a[2]))); break;
2538 ✗ case 9: _t->axisClick((*reinterpret_cast< QCPAxis*(*)>(_a[1])),(*reinterpret_cast< QCPAxis::SelectablePart(*)>(_a[2])),(*reinterpret_cast< QMouseEvent*(*)>(_a[3]))); break;
2539 ✗ case 10: _t->axisDoubleClick((*reinterpret_cast< QCPAxis*(*)>(_a[1])),(*reinterpret_cast< QCPAxis::SelectablePart(*)>(_a[2])),(*reinterpret_cast< QMouseEvent*(*)>(_a[3]))); break;
2540 ✗ case 11: _t->legendClick((*reinterpret_cast< QCPLegend*(*)>(_a[1])),(*reinterpret_cast< QCPAbstractLegendItem*(*)>(_a[2])),(*reinterpret_cast< QMouseEvent*(*)>(_a[3]))); break;
2541 ✗ case 12: _t->legendDoubleClick((*reinterpret_cast< QCPLegend*(*)>(_a[1])),(*reinterpret_cast< QCPAbstractLegendItem*(*)>(_a[2])),(*reinterpret_cast< QMouseEvent*(*)>(_a[3]))); break;
2542 ✗ case 13: _t->titleClick((*reinterpret_cast< QMouseEvent*(*)>(_a[1])),(*reinterpret_cast< QCPPlotTitle*(*)>(_a[2]))); break;
2543 ✗ case 14: _t->titleDoubleClick((*reinterpret_cast< QMouseEvent*(*)>(_a[1])),(*reinterpret_cast< QCPPlotTitle*(*)>(_a[2]))); break;
2544 ✗ case 15: _t->selectionChangedByUser(); break;
2545 ✗ case 16: _t->beforeReplot(); break;
2546 ✗ case 17: _t->afterReplot(); break;
2547 ✗ case 18: _t->rescaleAxes((*reinterpret_cast< bool(*)>(_a[1]))); break;
2548 ✗ case 19: _t->rescaleAxes(); break;
2549 ✗ case 20: _t->deselectAll(); break;
2550 ✗ case 21: _t->replot((*reinterpret_cast< QCustomPlot::RefreshPriority(*)>(_a[1]))); break;
2551 ✗ case 22: _t->replot(); break;
2552 ✗ default: ;
2553 }
2554 ✗ } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
2555 ✗ switch (_id) {
2556 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2557 ✗ case 5:
2558 ✗ switch (*reinterpret_cast<int*>(_a[1])) {
2559 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2560 ✗ case 0:
2561 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAbstractPlottable* >(); break;
2562 }
2563 ✗ break;
2564 ✗ case 6:
2565 ✗ switch (*reinterpret_cast<int*>(_a[1])) {
2566 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2567 ✗ case 0:
2568 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAbstractPlottable* >(); break;
2569 }
2570 ✗ break;
2571 ✗ case 7:
2572 ✗ switch (*reinterpret_cast<int*>(_a[1])) {
2573 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2574 ✗ case 0:
2575 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAbstractItem* >(); break;
2576 }
2577 ✗ break;
2578 ✗ case 8:
2579 ✗ switch (*reinterpret_cast<int*>(_a[1])) {
2580 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2581 ✗ case 0:
2582 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAbstractItem* >(); break;
2583 }
2584 ✗ break;
2585 ✗ case 9:
2586 ✗ switch (*reinterpret_cast<int*>(_a[1])) {
2587 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2588 ✗ case 0:
2589 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxis* >(); break;
2590 ✗ case 1:
2591 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxis::SelectablePart >(); break;
2592 }
2593 ✗ break;
2594 ✗ case 10:
2595 ✗ switch (*reinterpret_cast<int*>(_a[1])) {
2596 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2597 ✗ case 0:
2598 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxis* >(); break;
2599 ✗ case 1:
2600 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxis::SelectablePart >(); break;
2601 }
2602 ✗ break;
2603 ✗ case 11:
2604 ✗ switch (*reinterpret_cast<int*>(_a[1])) {
2605 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2606 ✗ case 1:
2607 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAbstractLegendItem* >(); break;
2608 ✗ case 0:
2609 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLegend* >(); break;
2610 }
2611 ✗ break;
2612 ✗ case 12:
2613 ✗ switch (*reinterpret_cast<int*>(_a[1])) {
2614 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2615 ✗ case 1:
2616 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAbstractLegendItem* >(); break;
2617 ✗ case 0:
2618 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLegend* >(); break;
2619 }
2620 ✗ break;
2621 ✗ case 13:
2622 ✗ switch (*reinterpret_cast<int*>(_a[1])) {
2623 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2624 ✗ case 1:
2625 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPPlotTitle* >(); break;
2626 }
2627 ✗ break;
2628 ✗ case 14:
2629 ✗ switch (*reinterpret_cast<int*>(_a[1])) {
2630 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2631 ✗ case 1:
2632 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPPlotTitle* >(); break;
2633 }
2634 ✗ break;
2635 }
2636 ✗ } else if (_c == QMetaObject::IndexOfMethod) {
2637 ✗ int *result = reinterpret_cast<int *>(_a[0]);
2638 {
2639 using _t = void (QCustomPlot::*)(QMouseEvent * );
2640 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::mouseDoubleClick)) {
2641 ✗ *result = 0;
2642 ✗ return;
2643 }
2644 }
2645 {
2646 using _t = void (QCustomPlot::*)(QMouseEvent * );
2647 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::mousePress)) {
2648 ✗ *result = 1;
2649 ✗ return;
2650 }
2651 }
2652 {
2653 using _t = void (QCustomPlot::*)(QMouseEvent * );
2654 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::mouseMove)) {
2655 ✗ *result = 2;
2656 ✗ return;
2657 }
2658 }
2659 {
2660 using _t = void (QCustomPlot::*)(QMouseEvent * );
2661 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::mouseRelease)) {
2662 ✗ *result = 3;
2663 ✗ return;
2664 }
2665 }
2666 {
2667 using _t = void (QCustomPlot::*)(QWheelEvent * );
2668 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::mouseWheel)) {
2669 ✗ *result = 4;
2670 ✗ return;
2671 }
2672 }
2673 {
2674 using _t = void (QCustomPlot::*)(QCPAbstractPlottable * , QMouseEvent * );
2675 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::plottableClick)) {
2676 ✗ *result = 5;
2677 ✗ return;
2678 }
2679 }
2680 {
2681 using _t = void (QCustomPlot::*)(QCPAbstractPlottable * , QMouseEvent * );
2682 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::plottableDoubleClick)) {
2683 ✗ *result = 6;
2684 ✗ return;
2685 }
2686 }
2687 {
2688 using _t = void (QCustomPlot::*)(QCPAbstractItem * , QMouseEvent * );
2689 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::itemClick)) {
2690 ✗ *result = 7;
2691 ✗ return;
2692 }
2693 }
2694 {
2695 using _t = void (QCustomPlot::*)(QCPAbstractItem * , QMouseEvent * );
2696 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::itemDoubleClick)) {
2697 ✗ *result = 8;
2698 ✗ return;
2699 }
2700 }
2701 {
2702 using _t = void (QCustomPlot::*)(QCPAxis * , QCPAxis::SelectablePart , QMouseEvent * );
2703 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::axisClick)) {
2704 ✗ *result = 9;
2705 ✗ return;
2706 }
2707 }
2708 {
2709 using _t = void (QCustomPlot::*)(QCPAxis * , QCPAxis::SelectablePart , QMouseEvent * );
2710 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::axisDoubleClick)) {
2711 ✗ *result = 10;
2712 ✗ return;
2713 }
2714 }
2715 {
2716 using _t = void (QCustomPlot::*)(QCPLegend * , QCPAbstractLegendItem * , QMouseEvent * );
2717 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::legendClick)) {
2718 ✗ *result = 11;
2719 ✗ return;
2720 }
2721 }
2722 {
2723 using _t = void (QCustomPlot::*)(QCPLegend * , QCPAbstractLegendItem * , QMouseEvent * );
2724 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::legendDoubleClick)) {
2725 ✗ *result = 12;
2726 ✗ return;
2727 }
2728 }
2729 {
2730 using _t = void (QCustomPlot::*)(QMouseEvent * , QCPPlotTitle * );
2731 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::titleClick)) {
2732 ✗ *result = 13;
2733 ✗ return;
2734 }
2735 }
2736 {
2737 using _t = void (QCustomPlot::*)(QMouseEvent * , QCPPlotTitle * );
2738 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::titleDoubleClick)) {
2739 ✗ *result = 14;
2740 ✗ return;
2741 }
2742 }
2743 {
2744 using _t = void (QCustomPlot::*)();
2745 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::selectionChangedByUser)) {
2746 ✗ *result = 15;
2747 ✗ return;
2748 }
2749 }
2750 {
2751 using _t = void (QCustomPlot::*)();
2752 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::beforeReplot)) {
2753 ✗ *result = 16;
2754 ✗ return;
2755 }
2756 }
2757 {
2758 using _t = void (QCustomPlot::*)();
2759 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCustomPlot::afterReplot)) {
2760 ✗ *result = 17;
2761 ✗ return;
2762 }
2763 }
2764 ✗ } else if (_c == QMetaObject::RegisterPropertyMetaType) {
2765 ✗ switch (_id) {
2766 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
2767 ✗ case 4:
2768 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayoutGrid* >(); break;
2769 }
2770 }
2771
2772 #ifndef QT_NO_PROPERTIES
2773 ✗ else if (_c == QMetaObject::ReadProperty) {
2774 ✗ auto *_t = static_cast<QCustomPlot *>(_o);
2775 (void)_t;
2776 ✗ void *_v = _a[0];
2777 ✗ switch (_id) {
2778 ✗ case 0: *reinterpret_cast< QRect*>(_v) = _t->viewport(); break;
2779 ✗ case 1: *reinterpret_cast< QPixmap*>(_v) = _t->background(); break;
2780 ✗ case 2: *reinterpret_cast< bool*>(_v) = _t->backgroundScaled(); break;
2781 ✗ case 3: *reinterpret_cast< Qt::AspectRatioMode*>(_v) = _t->backgroundScaledMode(); break;
2782 ✗ case 4: *reinterpret_cast< QCPLayoutGrid**>(_v) = _t->plotLayout(); break;
2783 ✗ case 5: *reinterpret_cast< bool*>(_v) = _t->autoAddPlottableToLegend(); break;
2784 ✗ case 6: *reinterpret_cast< int*>(_v) = _t->selectionTolerance(); break;
2785 ✗ case 7: *reinterpret_cast< bool*>(_v) = _t->noAntialiasingOnDrag(); break;
2786 ✗ case 8: *reinterpret_cast< Qt::KeyboardModifier*>(_v) = _t->multiSelectModifier(); break;
2787 ✗ default: break;
2788 }
2789 ✗ } else if (_c == QMetaObject::WriteProperty) {
2790 ✗ auto *_t = static_cast<QCustomPlot *>(_o);
2791 (void)_t;
2792 ✗ void *_v = _a[0];
2793 ✗ switch (_id) {
2794 ✗ case 0: _t->setViewport(*reinterpret_cast< QRect*>(_v)); break;
2795 ✗ case 1: _t->setBackground(*reinterpret_cast< QPixmap*>(_v)); break;
2796 ✗ case 2: _t->setBackgroundScaled(*reinterpret_cast< bool*>(_v)); break;
2797 ✗ case 3: _t->setBackgroundScaledMode(*reinterpret_cast< Qt::AspectRatioMode*>(_v)); break;
2798 ✗ case 5: _t->setAutoAddPlottableToLegend(*reinterpret_cast< bool*>(_v)); break;
2799 ✗ case 6: _t->setSelectionTolerance(*reinterpret_cast< int*>(_v)); break;
2800 ✗ case 7: _t->setNoAntialiasingOnDrag(*reinterpret_cast< bool*>(_v)); break;
2801 ✗ case 8: _t->setMultiSelectModifier(*reinterpret_cast< Qt::KeyboardModifier*>(_v)); break;
2802 ✗ default: break;
2803 }
2804 } else if (_c == QMetaObject::ResetProperty) {
2805 }
2806 #endif // QT_NO_PROPERTIES
2807 }
2808
2809 QT_INIT_METAOBJECT const QMetaObject QCustomPlot::staticMetaObject = { {
2810 QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
2811 qt_meta_stringdata_QCustomPlot.data,
2812 qt_meta_data_QCustomPlot,
2813 qt_static_metacall,
2814 nullptr,
2815 nullptr
2816 } };
2817
2818
2819 ✗ const QMetaObject *QCustomPlot::metaObject() const
2820 {
2821 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
2822 }
2823
2824 ✗ void *QCustomPlot::qt_metacast(const char *_clname)
2825 {
2826 ✗ if (!_clname) return nullptr;
2827 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCustomPlot.stringdata0))
2828 ✗ return static_cast<void*>(this);
2829 ✗ return QWidget::qt_metacast(_clname);
2830 }
2831
2832 ✗ int QCustomPlot::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
2833 {
2834 ✗ _id = QWidget::qt_metacall(_c, _id, _a);
2835 ✗ if (_id < 0)
2836 ✗ return _id;
2837 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
2838 ✗ if (_id < 23)
2839 ✗ qt_static_metacall(this, _c, _id, _a);
2840 ✗ _id -= 23;
2841 ✗ } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
2842 ✗ if (_id < 23)
2843 ✗ qt_static_metacall(this, _c, _id, _a);
2844 ✗ _id -= 23;
2845 }
2846 #ifndef QT_NO_PROPERTIES
2847 ✗ else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
2848 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
2849 ✗ qt_static_metacall(this, _c, _id, _a);
2850 ✗ _id -= 9;
2851 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
2852 ✗ _id -= 9;
2853 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
2854 ✗ _id -= 9;
2855 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
2856 ✗ _id -= 9;
2857 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
2858 ✗ _id -= 9;
2859 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
2860 ✗ _id -= 9;
2861 }
2862 #endif // QT_NO_PROPERTIES
2863 ✗ return _id;
2864 }
2865
2866 // SIGNAL 0
2867 ✗ void QCustomPlot::mouseDoubleClick(QMouseEvent * _t1)
2868 {
2869 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
2870 ✗ QMetaObject::activate(this, &staticMetaObject, 0, _a);
2871 }
2872
2873 // SIGNAL 1
2874 ✗ void QCustomPlot::mousePress(QMouseEvent * _t1)
2875 {
2876 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
2877 ✗ QMetaObject::activate(this, &staticMetaObject, 1, _a);
2878 }
2879
2880 // SIGNAL 2
2881 ✗ void QCustomPlot::mouseMove(QMouseEvent * _t1)
2882 {
2883 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
2884 ✗ QMetaObject::activate(this, &staticMetaObject, 2, _a);
2885 }
2886
2887 // SIGNAL 3
2888 ✗ void QCustomPlot::mouseRelease(QMouseEvent * _t1)
2889 {
2890 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
2891 ✗ QMetaObject::activate(this, &staticMetaObject, 3, _a);
2892 }
2893
2894 // SIGNAL 4
2895 ✗ void QCustomPlot::mouseWheel(QWheelEvent * _t1)
2896 {
2897 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
2898 ✗ QMetaObject::activate(this, &staticMetaObject, 4, _a);
2899 }
2900
2901 // SIGNAL 5
2902 ✗ void QCustomPlot::plottableClick(QCPAbstractPlottable * _t1, QMouseEvent * _t2)
2903 {
2904 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
2905 ✗ QMetaObject::activate(this, &staticMetaObject, 5, _a);
2906 }
2907
2908 // SIGNAL 6
2909 ✗ void QCustomPlot::plottableDoubleClick(QCPAbstractPlottable * _t1, QMouseEvent * _t2)
2910 {
2911 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
2912 ✗ QMetaObject::activate(this, &staticMetaObject, 6, _a);
2913 }
2914
2915 // SIGNAL 7
2916 ✗ void QCustomPlot::itemClick(QCPAbstractItem * _t1, QMouseEvent * _t2)
2917 {
2918 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
2919 ✗ QMetaObject::activate(this, &staticMetaObject, 7, _a);
2920 }
2921
2922 // SIGNAL 8
2923 ✗ void QCustomPlot::itemDoubleClick(QCPAbstractItem * _t1, QMouseEvent * _t2)
2924 {
2925 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
2926 ✗ QMetaObject::activate(this, &staticMetaObject, 8, _a);
2927 }
2928
2929 // SIGNAL 9
2930 ✗ void QCustomPlot::axisClick(QCPAxis * _t1, QCPAxis::SelectablePart _t2, QMouseEvent * _t3)
2931 {
2932 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))) };
2933 ✗ QMetaObject::activate(this, &staticMetaObject, 9, _a);
2934 }
2935
2936 // SIGNAL 10
2937 ✗ void QCustomPlot::axisDoubleClick(QCPAxis * _t1, QCPAxis::SelectablePart _t2, QMouseEvent * _t3)
2938 {
2939 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))) };
2940 ✗ QMetaObject::activate(this, &staticMetaObject, 10, _a);
2941 }
2942
2943 // SIGNAL 11
2944 ✗ void QCustomPlot::legendClick(QCPLegend * _t1, QCPAbstractLegendItem * _t2, QMouseEvent * _t3)
2945 {
2946 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))) };
2947 ✗ QMetaObject::activate(this, &staticMetaObject, 11, _a);
2948 }
2949
2950 // SIGNAL 12
2951 ✗ void QCustomPlot::legendDoubleClick(QCPLegend * _t1, QCPAbstractLegendItem * _t2, QMouseEvent * _t3)
2952 {
2953 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))) };
2954 ✗ QMetaObject::activate(this, &staticMetaObject, 12, _a);
2955 }
2956
2957 // SIGNAL 13
2958 ✗ void QCustomPlot::titleClick(QMouseEvent * _t1, QCPPlotTitle * _t2)
2959 {
2960 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
2961 ✗ QMetaObject::activate(this, &staticMetaObject, 13, _a);
2962 }
2963
2964 // SIGNAL 14
2965 ✗ void QCustomPlot::titleDoubleClick(QMouseEvent * _t1, QCPPlotTitle * _t2)
2966 {
2967 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
2968 ✗ QMetaObject::activate(this, &staticMetaObject, 14, _a);
2969 }
2970
2971 // SIGNAL 15
2972 ✗ void QCustomPlot::selectionChangedByUser()
2973 {
2974 ✗ QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
2975 }
2976
2977 // SIGNAL 16
2978 ✗ void QCustomPlot::beforeReplot()
2979 {
2980 ✗ QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
2981 }
2982
2983 // SIGNAL 17
2984 ✗ void QCustomPlot::afterReplot()
2985 {
2986 ✗ QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
2987 }
2988 struct qt_meta_stringdata_QCPColorGradient_t {
2989 QByteArrayData data[17];
2990 char stringdata0[164];
2991 };
2992 #define QT_MOC_LITERAL(idx, ofs, len) \
2993 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
2994 qptrdiff(offsetof(qt_meta_stringdata_QCPColorGradient_t, stringdata0) + ofs \
2995 - idx * sizeof(QByteArrayData)) \
2996 )
2997 static const qt_meta_stringdata_QCPColorGradient_t qt_meta_stringdata_QCPColorGradient = {
2998 {
2999 QT_MOC_LITERAL(0, 0, 16), // "QCPColorGradient"
3000 QT_MOC_LITERAL(1, 17, 18), // "ColorInterpolation"
3001 QT_MOC_LITERAL(2, 36, 5), // "ciRGB"
3002 QT_MOC_LITERAL(3, 42, 5), // "ciHSV"
3003 QT_MOC_LITERAL(4, 48, 14), // "GradientPreset"
3004 QT_MOC_LITERAL(5, 63, 11), // "gpGrayscale"
3005 QT_MOC_LITERAL(6, 75, 5), // "gpHot"
3006 QT_MOC_LITERAL(7, 81, 6), // "gpCold"
3007 QT_MOC_LITERAL(8, 88, 7), // "gpNight"
3008 QT_MOC_LITERAL(9, 96, 7), // "gpCandy"
3009 QT_MOC_LITERAL(10, 104, 11), // "gpGeography"
3010 QT_MOC_LITERAL(11, 116, 5), // "gpIon"
3011 QT_MOC_LITERAL(12, 122, 9), // "gpThermal"
3012 QT_MOC_LITERAL(13, 132, 7), // "gpPolar"
3013 QT_MOC_LITERAL(14, 140, 10), // "gpSpectrum"
3014 QT_MOC_LITERAL(15, 151, 5), // "gpJet"
3015 QT_MOC_LITERAL(16, 157, 6) // "gpHues"
3016
3017 },
3018 "QCPColorGradient\0ColorInterpolation\0"
3019 "ciRGB\0ciHSV\0GradientPreset\0gpGrayscale\0"
3020 "gpHot\0gpCold\0gpNight\0gpCandy\0gpGeography\0"
3021 "gpIon\0gpThermal\0gpPolar\0gpSpectrum\0"
3022 "gpJet\0gpHues"
3023 };
3024 #undef QT_MOC_LITERAL
3025
3026 static const uint qt_meta_data_QCPColorGradient[] = {
3027
3028 // content:
3029 8, // revision
3030 0, // classname
3031 0, 0, // classinfo
3032 0, 0, // methods
3033 0, 0, // properties
3034 2, 14, // enums/sets
3035 0, 0, // constructors
3036 4, // flags
3037 0, // signalCount
3038
3039 // enums: name, alias, flags, count, data
3040 1, 1, 0x0, 2, 24,
3041 4, 4, 0x0, 12, 28,
3042
3043 // enum data: key, value
3044 2, uint(QCPColorGradient::ciRGB),
3045 3, uint(QCPColorGradient::ciHSV),
3046 5, uint(QCPColorGradient::gpGrayscale),
3047 6, uint(QCPColorGradient::gpHot),
3048 7, uint(QCPColorGradient::gpCold),
3049 8, uint(QCPColorGradient::gpNight),
3050 9, uint(QCPColorGradient::gpCandy),
3051 10, uint(QCPColorGradient::gpGeography),
3052 11, uint(QCPColorGradient::gpIon),
3053 12, uint(QCPColorGradient::gpThermal),
3054 13, uint(QCPColorGradient::gpPolar),
3055 14, uint(QCPColorGradient::gpSpectrum),
3056 15, uint(QCPColorGradient::gpJet),
3057 16, uint(QCPColorGradient::gpHues),
3058
3059 0 // eod
3060 };
3061
3062 QT_INIT_METAOBJECT const QMetaObject QCPColorGradient::staticMetaObject = { {
3063 nullptr,
3064 qt_meta_stringdata_QCPColorGradient.data,
3065 qt_meta_data_QCPColorGradient,
3066 nullptr,
3067 nullptr,
3068 nullptr
3069 } };
3070
3071 struct qt_meta_stringdata_QCPAxisRect_t {
3072 QByteArrayData data[8];
3073 char stringdata0[118];
3074 };
3075 #define QT_MOC_LITERAL(idx, ofs, len) \
3076 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
3077 qptrdiff(offsetof(qt_meta_stringdata_QCPAxisRect_t, stringdata0) + ofs \
3078 - idx * sizeof(QByteArrayData)) \
3079 )
3080 static const qt_meta_stringdata_QCPAxisRect_t qt_meta_stringdata_QCPAxisRect = {
3081 {
3082 QT_MOC_LITERAL(0, 0, 11), // "QCPAxisRect"
3083 QT_MOC_LITERAL(1, 12, 10), // "background"
3084 QT_MOC_LITERAL(2, 23, 16), // "backgroundScaled"
3085 QT_MOC_LITERAL(3, 40, 20), // "backgroundScaledMode"
3086 QT_MOC_LITERAL(4, 61, 19), // "Qt::AspectRatioMode"
3087 QT_MOC_LITERAL(5, 81, 9), // "rangeDrag"
3088 QT_MOC_LITERAL(6, 91, 16), // "Qt::Orientations"
3089 QT_MOC_LITERAL(7, 108, 9) // "rangeZoom"
3090
3091 },
3092 "QCPAxisRect\0background\0backgroundScaled\0"
3093 "backgroundScaledMode\0Qt::AspectRatioMode\0"
3094 "rangeDrag\0Qt::Orientations\0rangeZoom"
3095 };
3096 #undef QT_MOC_LITERAL
3097
3098 static const uint qt_meta_data_QCPAxisRect[] = {
3099
3100 // content:
3101 8, // revision
3102 0, // classname
3103 0, 0, // classinfo
3104 0, 0, // methods
3105 5, 14, // properties
3106 0, 0, // enums/sets
3107 0, 0, // constructors
3108 0, // flags
3109 0, // signalCount
3110
3111 // properties: name, type, flags
3112 1, QMetaType::QPixmap, 0x00095103,
3113 2, QMetaType::Bool, 0x00095103,
3114 3, 0x80000000 | 4, 0x0009510b,
3115 5, 0x80000000 | 6, 0x0009510b,
3116 7, 0x80000000 | 6, 0x0009510b,
3117
3118 0 // eod
3119 };
3120
3121 ✗ void QCPAxisRect::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
3122 {
3123
3124 #ifndef QT_NO_PROPERTIES
3125 ✗ if (_c == QMetaObject::ReadProperty) {
3126 ✗ auto *_t = static_cast<QCPAxisRect *>(_o);
3127 (void)_t;
3128 ✗ void *_v = _a[0];
3129 ✗ switch (_id) {
3130 ✗ case 0: *reinterpret_cast< QPixmap*>(_v) = _t->background(); break;
3131 ✗ case 1: *reinterpret_cast< bool*>(_v) = _t->backgroundScaled(); break;
3132 ✗ case 2: *reinterpret_cast< Qt::AspectRatioMode*>(_v) = _t->backgroundScaledMode(); break;
3133 ✗ case 3: *reinterpret_cast< Qt::Orientations*>(_v) = _t->rangeDrag(); break;
3134 ✗ case 4: *reinterpret_cast< Qt::Orientations*>(_v) = _t->rangeZoom(); break;
3135 ✗ default: break;
3136 }
3137 ✗ } else if (_c == QMetaObject::WriteProperty) {
3138 ✗ auto *_t = static_cast<QCPAxisRect *>(_o);
3139 (void)_t;
3140 ✗ void *_v = _a[0];
3141 ✗ switch (_id) {
3142 ✗ case 0: _t->setBackground(*reinterpret_cast< QPixmap*>(_v)); break;
3143 ✗ case 1: _t->setBackgroundScaled(*reinterpret_cast< bool*>(_v)); break;
3144 ✗ case 2: _t->setBackgroundScaledMode(*reinterpret_cast< Qt::AspectRatioMode*>(_v)); break;
3145 ✗ case 3: _t->setRangeDrag(*reinterpret_cast< Qt::Orientations*>(_v)); break;
3146 ✗ case 4: _t->setRangeZoom(*reinterpret_cast< Qt::Orientations*>(_v)); break;
3147 ✗ default: break;
3148 }
3149 } else if (_c == QMetaObject::ResetProperty) {
3150 }
3151 #endif // QT_NO_PROPERTIES
3152 (void)_o;
3153 (void)_id;
3154 (void)_c;
3155 (void)_a;
3156 }
3157
3158 QT_INIT_METAOBJECT const QMetaObject QCPAxisRect::staticMetaObject = { {
3159 QMetaObject::SuperData::link<QCPLayoutElement::staticMetaObject>(),
3160 qt_meta_stringdata_QCPAxisRect.data,
3161 qt_meta_data_QCPAxisRect,
3162 qt_static_metacall,
3163 nullptr,
3164 nullptr
3165 } };
3166
3167
3168 ✗ const QMetaObject *QCPAxisRect::metaObject() const
3169 {
3170 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
3171 }
3172
3173 ✗ void *QCPAxisRect::qt_metacast(const char *_clname)
3174 {
3175 ✗ if (!_clname) return nullptr;
3176 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPAxisRect.stringdata0))
3177 ✗ return static_cast<void*>(this);
3178 ✗ return QCPLayoutElement::qt_metacast(_clname);
3179 }
3180
3181 ✗ int QCPAxisRect::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
3182 {
3183 ✗ _id = QCPLayoutElement::qt_metacall(_c, _id, _a);
3184 ✗ if (_id < 0)
3185 ✗ return _id;
3186
3187 #ifndef QT_NO_PROPERTIES
3188 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
3189 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
3190 ✗ qt_static_metacall(this, _c, _id, _a);
3191 ✗ _id -= 5;
3192 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
3193 ✗ _id -= 5;
3194 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
3195 ✗ _id -= 5;
3196 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
3197 ✗ _id -= 5;
3198 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
3199 ✗ _id -= 5;
3200 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
3201 ✗ _id -= 5;
3202 }
3203 #endif // QT_NO_PROPERTIES
3204 ✗ return _id;
3205 }
3206 struct qt_meta_stringdata_QCPAbstractLegendItem_t {
3207 QByteArrayData data[14];
3208 char stringdata0[174];
3209 };
3210 #define QT_MOC_LITERAL(idx, ofs, len) \
3211 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
3212 qptrdiff(offsetof(qt_meta_stringdata_QCPAbstractLegendItem_t, stringdata0) + ofs \
3213 - idx * sizeof(QByteArrayData)) \
3214 )
3215 static const qt_meta_stringdata_QCPAbstractLegendItem_t qt_meta_stringdata_QCPAbstractLegendItem = {
3216 {
3217 QT_MOC_LITERAL(0, 0, 21), // "QCPAbstractLegendItem"
3218 QT_MOC_LITERAL(1, 22, 16), // "selectionChanged"
3219 QT_MOC_LITERAL(2, 39, 0), // ""
3220 QT_MOC_LITERAL(3, 40, 8), // "selected"
3221 QT_MOC_LITERAL(4, 49, 17), // "selectableChanged"
3222 QT_MOC_LITERAL(5, 67, 10), // "selectable"
3223 QT_MOC_LITERAL(6, 78, 13), // "setSelectable"
3224 QT_MOC_LITERAL(7, 92, 11), // "setSelected"
3225 QT_MOC_LITERAL(8, 104, 12), // "parentLegend"
3226 QT_MOC_LITERAL(9, 117, 10), // "QCPLegend*"
3227 QT_MOC_LITERAL(10, 128, 4), // "font"
3228 QT_MOC_LITERAL(11, 133, 9), // "textColor"
3229 QT_MOC_LITERAL(12, 143, 12), // "selectedFont"
3230 QT_MOC_LITERAL(13, 156, 17) // "selectedTextColor"
3231
3232 },
3233 "QCPAbstractLegendItem\0selectionChanged\0"
3234 "\0selected\0selectableChanged\0selectable\0"
3235 "setSelectable\0setSelected\0parentLegend\0"
3236 "QCPLegend*\0font\0textColor\0selectedFont\0"
3237 "selectedTextColor"
3238 };
3239 #undef QT_MOC_LITERAL
3240
3241 static const uint qt_meta_data_QCPAbstractLegendItem[] = {
3242
3243 // content:
3244 8, // revision
3245 0, // classname
3246 0, 0, // classinfo
3247 4, 14, // methods
3248 7, 46, // properties
3249 0, 0, // enums/sets
3250 0, 0, // constructors
3251 0, // flags
3252 2, // signalCount
3253
3254 // signals: name, argc, parameters, tag, flags
3255 1, 1, 34, 2, 0x06 /* Public */,
3256 4, 1, 37, 2, 0x06 /* Public */,
3257
3258 // slots: name, argc, parameters, tag, flags
3259 6, 1, 40, 2, 0x0a /* Public */,
3260 7, 1, 43, 2, 0x0a /* Public */,
3261
3262 // signals: parameters
3263 QMetaType::Void, QMetaType::Bool, 3,
3264 QMetaType::Void, QMetaType::Bool, 5,
3265
3266 // slots: parameters
3267 QMetaType::Void, QMetaType::Bool, 5,
3268 QMetaType::Void, QMetaType::Bool, 3,
3269
3270 // properties: name, type, flags
3271 8, 0x80000000 | 9, 0x00095009,
3272 10, QMetaType::QFont, 0x00095103,
3273 11, QMetaType::QColor, 0x00095103,
3274 12, QMetaType::QFont, 0x00095103,
3275 13, QMetaType::QColor, 0x00095103,
3276 5, QMetaType::Bool, 0x00495103,
3277 3, QMetaType::Bool, 0x00495103,
3278
3279 // properties: notify_signal_id
3280 0,
3281 0,
3282 0,
3283 0,
3284 0,
3285 0,
3286 1,
3287
3288 0 // eod
3289 };
3290
3291 ✗ void QCPAbstractLegendItem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
3292 {
3293 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
3294 ✗ auto *_t = static_cast<QCPAbstractLegendItem *>(_o);
3295 (void)_t;
3296 ✗ switch (_id) {
3297 ✗ case 0: _t->selectionChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
3298 ✗ case 1: _t->selectableChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
3299 ✗ case 2: _t->setSelectable((*reinterpret_cast< bool(*)>(_a[1]))); break;
3300 ✗ case 3: _t->setSelected((*reinterpret_cast< bool(*)>(_a[1]))); break;
3301 ✗ default: ;
3302 }
3303 ✗ } else if (_c == QMetaObject::IndexOfMethod) {
3304 ✗ int *result = reinterpret_cast<int *>(_a[0]);
3305 {
3306 using _t = void (QCPAbstractLegendItem::*)(bool );
3307 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAbstractLegendItem::selectionChanged)) {
3308 ✗ *result = 0;
3309 ✗ return;
3310 }
3311 }
3312 {
3313 using _t = void (QCPAbstractLegendItem::*)(bool );
3314 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPAbstractLegendItem::selectableChanged)) {
3315 ✗ *result = 1;
3316 ✗ return;
3317 }
3318 }
3319 ✗ } else if (_c == QMetaObject::RegisterPropertyMetaType) {
3320 ✗ switch (_id) {
3321 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
3322 ✗ case 0:
3323 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLegend* >(); break;
3324 }
3325 }
3326
3327 #ifndef QT_NO_PROPERTIES
3328 ✗ else if (_c == QMetaObject::ReadProperty) {
3329 ✗ auto *_t = static_cast<QCPAbstractLegendItem *>(_o);
3330 (void)_t;
3331 ✗ void *_v = _a[0];
3332 ✗ switch (_id) {
3333 ✗ case 0: *reinterpret_cast< QCPLegend**>(_v) = _t->parentLegend(); break;
3334 ✗ case 1: *reinterpret_cast< QFont*>(_v) = _t->font(); break;
3335 ✗ case 2: *reinterpret_cast< QColor*>(_v) = _t->textColor(); break;
3336 ✗ case 3: *reinterpret_cast< QFont*>(_v) = _t->selectedFont(); break;
3337 ✗ case 4: *reinterpret_cast< QColor*>(_v) = _t->selectedTextColor(); break;
3338 ✗ case 5: *reinterpret_cast< bool*>(_v) = _t->selectable(); break;
3339 ✗ case 6: *reinterpret_cast< bool*>(_v) = _t->selected(); break;
3340 ✗ default: break;
3341 }
3342 ✗ } else if (_c == QMetaObject::WriteProperty) {
3343 ✗ auto *_t = static_cast<QCPAbstractLegendItem *>(_o);
3344 (void)_t;
3345 ✗ void *_v = _a[0];
3346 ✗ switch (_id) {
3347 ✗ case 1: _t->setFont(*reinterpret_cast< QFont*>(_v)); break;
3348 ✗ case 2: _t->setTextColor(*reinterpret_cast< QColor*>(_v)); break;
3349 ✗ case 3: _t->setSelectedFont(*reinterpret_cast< QFont*>(_v)); break;
3350 ✗ case 4: _t->setSelectedTextColor(*reinterpret_cast< QColor*>(_v)); break;
3351 ✗ case 5: _t->setSelectable(*reinterpret_cast< bool*>(_v)); break;
3352 ✗ case 6: _t->setSelected(*reinterpret_cast< bool*>(_v)); break;
3353 ✗ default: break;
3354 }
3355 } else if (_c == QMetaObject::ResetProperty) {
3356 }
3357 #endif // QT_NO_PROPERTIES
3358 }
3359
3360 QT_INIT_METAOBJECT const QMetaObject QCPAbstractLegendItem::staticMetaObject = { {
3361 QMetaObject::SuperData::link<QCPLayoutElement::staticMetaObject>(),
3362 qt_meta_stringdata_QCPAbstractLegendItem.data,
3363 qt_meta_data_QCPAbstractLegendItem,
3364 qt_static_metacall,
3365 nullptr,
3366 nullptr
3367 } };
3368
3369
3370 ✗ const QMetaObject *QCPAbstractLegendItem::metaObject() const
3371 {
3372 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
3373 }
3374
3375 ✗ void *QCPAbstractLegendItem::qt_metacast(const char *_clname)
3376 {
3377 ✗ if (!_clname) return nullptr;
3378 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPAbstractLegendItem.stringdata0))
3379 ✗ return static_cast<void*>(this);
3380 ✗ return QCPLayoutElement::qt_metacast(_clname);
3381 }
3382
3383 ✗ int QCPAbstractLegendItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
3384 {
3385 ✗ _id = QCPLayoutElement::qt_metacall(_c, _id, _a);
3386 ✗ if (_id < 0)
3387 ✗ return _id;
3388 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
3389 ✗ if (_id < 4)
3390 ✗ qt_static_metacall(this, _c, _id, _a);
3391 ✗ _id -= 4;
3392 ✗ } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
3393 ✗ if (_id < 4)
3394 ✗ *reinterpret_cast<int*>(_a[0]) = -1;
3395 ✗ _id -= 4;
3396 }
3397 #ifndef QT_NO_PROPERTIES
3398 ✗ else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
3399 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
3400 ✗ qt_static_metacall(this, _c, _id, _a);
3401 ✗ _id -= 7;
3402 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
3403 ✗ _id -= 7;
3404 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
3405 ✗ _id -= 7;
3406 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
3407 ✗ _id -= 7;
3408 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
3409 ✗ _id -= 7;
3410 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
3411 ✗ _id -= 7;
3412 }
3413 #endif // QT_NO_PROPERTIES
3414 ✗ return _id;
3415 }
3416
3417 // SIGNAL 0
3418 ✗ void QCPAbstractLegendItem::selectionChanged(bool _t1)
3419 {
3420 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
3421 ✗ QMetaObject::activate(this, &staticMetaObject, 0, _a);
3422 }
3423
3424 // SIGNAL 1
3425 ✗ void QCPAbstractLegendItem::selectableChanged(bool _t1)
3426 {
3427 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
3428 ✗ QMetaObject::activate(this, &staticMetaObject, 1, _a);
3429 }
3430 struct qt_meta_stringdata_QCPPlottableLegendItem_t {
3431 QByteArrayData data[1];
3432 char stringdata0[23];
3433 };
3434 #define QT_MOC_LITERAL(idx, ofs, len) \
3435 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
3436 qptrdiff(offsetof(qt_meta_stringdata_QCPPlottableLegendItem_t, stringdata0) + ofs \
3437 - idx * sizeof(QByteArrayData)) \
3438 )
3439 static const qt_meta_stringdata_QCPPlottableLegendItem_t qt_meta_stringdata_QCPPlottableLegendItem = {
3440 {
3441 QT_MOC_LITERAL(0, 0, 22) // "QCPPlottableLegendItem"
3442
3443 },
3444 "QCPPlottableLegendItem"
3445 };
3446 #undef QT_MOC_LITERAL
3447
3448 static const uint qt_meta_data_QCPPlottableLegendItem[] = {
3449
3450 // content:
3451 8, // revision
3452 0, // classname
3453 0, 0, // classinfo
3454 0, 0, // methods
3455 0, 0, // properties
3456 0, 0, // enums/sets
3457 0, 0, // constructors
3458 0, // flags
3459 0, // signalCount
3460
3461 0 // eod
3462 };
3463
3464 ✗ void QCPPlottableLegendItem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
3465 {
3466 (void)_o;
3467 (void)_id;
3468 (void)_c;
3469 (void)_a;
3470 }
3471
3472 QT_INIT_METAOBJECT const QMetaObject QCPPlottableLegendItem::staticMetaObject = { {
3473 QMetaObject::SuperData::link<QCPAbstractLegendItem::staticMetaObject>(),
3474 qt_meta_stringdata_QCPPlottableLegendItem.data,
3475 qt_meta_data_QCPPlottableLegendItem,
3476 qt_static_metacall,
3477 nullptr,
3478 nullptr
3479 } };
3480
3481
3482 ✗ const QMetaObject *QCPPlottableLegendItem::metaObject() const
3483 {
3484 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
3485 }
3486
3487 ✗ void *QCPPlottableLegendItem::qt_metacast(const char *_clname)
3488 {
3489 ✗ if (!_clname) return nullptr;
3490 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPPlottableLegendItem.stringdata0))
3491 ✗ return static_cast<void*>(this);
3492 ✗ return QCPAbstractLegendItem::qt_metacast(_clname);
3493 }
3494
3495 ✗ int QCPPlottableLegendItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
3496 {
3497 ✗ _id = QCPAbstractLegendItem::qt_metacall(_c, _id, _a);
3498 ✗ return _id;
3499 }
3500 struct qt_meta_stringdata_QCPLegend_t {
3501 QByteArrayData data[27];
3502 char stringdata0[358];
3503 };
3504 #define QT_MOC_LITERAL(idx, ofs, len) \
3505 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
3506 qptrdiff(offsetof(qt_meta_stringdata_QCPLegend_t, stringdata0) + ofs \
3507 - idx * sizeof(QByteArrayData)) \
3508 )
3509 static const qt_meta_stringdata_QCPLegend_t qt_meta_stringdata_QCPLegend = {
3510 {
3511 QT_MOC_LITERAL(0, 0, 9), // "QCPLegend"
3512 QT_MOC_LITERAL(1, 10, 16), // "selectionChanged"
3513 QT_MOC_LITERAL(2, 27, 0), // ""
3514 QT_MOC_LITERAL(3, 28, 26), // "QCPLegend::SelectableParts"
3515 QT_MOC_LITERAL(4, 55, 5), // "parts"
3516 QT_MOC_LITERAL(5, 61, 17), // "selectableChanged"
3517 QT_MOC_LITERAL(6, 79, 18), // "setSelectableParts"
3518 QT_MOC_LITERAL(7, 98, 15), // "SelectableParts"
3519 QT_MOC_LITERAL(8, 114, 15), // "selectableParts"
3520 QT_MOC_LITERAL(9, 130, 16), // "setSelectedParts"
3521 QT_MOC_LITERAL(10, 147, 13), // "selectedParts"
3522 QT_MOC_LITERAL(11, 161, 9), // "borderPen"
3523 QT_MOC_LITERAL(12, 171, 5), // "brush"
3524 QT_MOC_LITERAL(13, 177, 4), // "font"
3525 QT_MOC_LITERAL(14, 182, 9), // "textColor"
3526 QT_MOC_LITERAL(15, 192, 8), // "iconSize"
3527 QT_MOC_LITERAL(16, 201, 15), // "iconTextPadding"
3528 QT_MOC_LITERAL(17, 217, 13), // "iconBorderPen"
3529 QT_MOC_LITERAL(18, 231, 17), // "selectedBorderPen"
3530 QT_MOC_LITERAL(19, 249, 21), // "selectedIconBorderPen"
3531 QT_MOC_LITERAL(20, 271, 13), // "selectedBrush"
3532 QT_MOC_LITERAL(21, 285, 12), // "selectedFont"
3533 QT_MOC_LITERAL(22, 298, 17), // "selectedTextColor"
3534 QT_MOC_LITERAL(23, 316, 14), // "SelectablePart"
3535 QT_MOC_LITERAL(24, 331, 6), // "spNone"
3536 QT_MOC_LITERAL(25, 338, 11), // "spLegendBox"
3537 QT_MOC_LITERAL(26, 350, 7) // "spItems"
3538
3539 },
3540 "QCPLegend\0selectionChanged\0\0"
3541 "QCPLegend::SelectableParts\0parts\0"
3542 "selectableChanged\0setSelectableParts\0"
3543 "SelectableParts\0selectableParts\0"
3544 "setSelectedParts\0selectedParts\0borderPen\0"
3545 "brush\0font\0textColor\0iconSize\0"
3546 "iconTextPadding\0iconBorderPen\0"
3547 "selectedBorderPen\0selectedIconBorderPen\0"
3548 "selectedBrush\0selectedFont\0selectedTextColor\0"
3549 "SelectablePart\0spNone\0spLegendBox\0"
3550 "spItems"
3551 };
3552 #undef QT_MOC_LITERAL
3553
3554 static const uint qt_meta_data_QCPLegend[] = {
3555
3556 // content:
3557 8, // revision
3558 0, // classname
3559 0, 0, // classinfo
3560 4, 14, // methods
3561 14, 46, // properties
3562 2, 102, // enums/sets
3563 0, 0, // constructors
3564 0, // flags
3565 2, // signalCount
3566
3567 // signals: name, argc, parameters, tag, flags
3568 1, 1, 34, 2, 0x06 /* Public */,
3569 5, 1, 37, 2, 0x06 /* Public */,
3570
3571 // slots: name, argc, parameters, tag, flags
3572 6, 1, 40, 2, 0x0a /* Public */,
3573 9, 1, 43, 2, 0x0a /* Public */,
3574
3575 // signals: parameters
3576 QMetaType::Void, 0x80000000 | 3, 4,
3577 QMetaType::Void, 0x80000000 | 3, 4,
3578
3579 // slots: parameters
3580 QMetaType::Void, 0x80000000 | 7, 8,
3581 QMetaType::Void, 0x80000000 | 7, 10,
3582
3583 // properties: name, type, flags
3584 11, QMetaType::QPen, 0x00095103,
3585 12, QMetaType::QBrush, 0x00095103,
3586 13, QMetaType::QFont, 0x00095103,
3587 14, QMetaType::QColor, 0x00095103,
3588 15, QMetaType::QSize, 0x00095103,
3589 16, QMetaType::Int, 0x00095103,
3590 17, QMetaType::QPen, 0x00095103,
3591 8, 0x80000000 | 7, 0x0049510b,
3592 10, 0x80000000 | 7, 0x0049510b,
3593 18, QMetaType::QPen, 0x00095103,
3594 19, QMetaType::QPen, 0x00095103,
3595 20, QMetaType::QBrush, 0x00095103,
3596 21, QMetaType::QFont, 0x00095103,
3597 22, QMetaType::QColor, 0x00095103,
3598
3599 // properties: notify_signal_id
3600 0,
3601 0,
3602 0,
3603 0,
3604 0,
3605 0,
3606 0,
3607 0,
3608 1,
3609 0,
3610 0,
3611 0,
3612 0,
3613 0,
3614
3615 // enums: name, alias, flags, count, data
3616 23, 23, 0x1, 3, 112,
3617 7, 23, 0x1, 3, 118,
3618
3619 // enum data: key, value
3620 24, uint(QCPLegend::spNone),
3621 25, uint(QCPLegend::spLegendBox),
3622 26, uint(QCPLegend::spItems),
3623 24, uint(QCPLegend::spNone),
3624 25, uint(QCPLegend::spLegendBox),
3625 26, uint(QCPLegend::spItems),
3626
3627 0 // eod
3628 };
3629
3630 ✗ void QCPLegend::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
3631 {
3632 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
3633 ✗ auto *_t = static_cast<QCPLegend *>(_o);
3634 (void)_t;
3635 ✗ switch (_id) {
3636 ✗ case 0: _t->selectionChanged((*reinterpret_cast< QCPLegend::SelectableParts(*)>(_a[1]))); break;
3637 ✗ case 1: _t->selectableChanged((*reinterpret_cast< QCPLegend::SelectableParts(*)>(_a[1]))); break;
3638 ✗ case 2: _t->setSelectableParts((*reinterpret_cast< const SelectableParts(*)>(_a[1]))); break;
3639 ✗ case 3: _t->setSelectedParts((*reinterpret_cast< const SelectableParts(*)>(_a[1]))); break;
3640 ✗ default: ;
3641 }
3642 ✗ } else if (_c == QMetaObject::IndexOfMethod) {
3643 ✗ int *result = reinterpret_cast<int *>(_a[0]);
3644 {
3645 using _t = void (QCPLegend::*)(QCPLegend::SelectableParts );
3646 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPLegend::selectionChanged)) {
3647 ✗ *result = 0;
3648 ✗ return;
3649 }
3650 }
3651 {
3652 using _t = void (QCPLegend::*)(QCPLegend::SelectableParts );
3653 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPLegend::selectableChanged)) {
3654 ✗ *result = 1;
3655 ✗ return;
3656 }
3657 }
3658 }
3659 #ifndef QT_NO_PROPERTIES
3660 ✗ else if (_c == QMetaObject::ReadProperty) {
3661 ✗ auto *_t = static_cast<QCPLegend *>(_o);
3662 (void)_t;
3663 ✗ void *_v = _a[0];
3664 ✗ switch (_id) {
3665 ✗ case 0: *reinterpret_cast< QPen*>(_v) = _t->borderPen(); break;
3666 ✗ case 1: *reinterpret_cast< QBrush*>(_v) = _t->brush(); break;
3667 ✗ case 2: *reinterpret_cast< QFont*>(_v) = _t->font(); break;
3668 ✗ case 3: *reinterpret_cast< QColor*>(_v) = _t->textColor(); break;
3669 ✗ case 4: *reinterpret_cast< QSize*>(_v) = _t->iconSize(); break;
3670 ✗ case 5: *reinterpret_cast< int*>(_v) = _t->iconTextPadding(); break;
3671 ✗ case 6: *reinterpret_cast< QPen*>(_v) = _t->iconBorderPen(); break;
3672 ✗ case 7: *reinterpret_cast<int*>(_v) = QFlag(_t->selectableParts()); break;
3673 ✗ case 8: *reinterpret_cast<int*>(_v) = QFlag(_t->selectedParts()); break;
3674 ✗ case 9: *reinterpret_cast< QPen*>(_v) = _t->selectedBorderPen(); break;
3675 ✗ case 10: *reinterpret_cast< QPen*>(_v) = _t->selectedIconBorderPen(); break;
3676 ✗ case 11: *reinterpret_cast< QBrush*>(_v) = _t->selectedBrush(); break;
3677 ✗ case 12: *reinterpret_cast< QFont*>(_v) = _t->selectedFont(); break;
3678 ✗ case 13: *reinterpret_cast< QColor*>(_v) = _t->selectedTextColor(); break;
3679 ✗ default: break;
3680 }
3681 ✗ } else if (_c == QMetaObject::WriteProperty) {
3682 ✗ auto *_t = static_cast<QCPLegend *>(_o);
3683 (void)_t;
3684 ✗ void *_v = _a[0];
3685 ✗ switch (_id) {
3686 ✗ case 0: _t->setBorderPen(*reinterpret_cast< QPen*>(_v)); break;
3687 ✗ case 1: _t->setBrush(*reinterpret_cast< QBrush*>(_v)); break;
3688 ✗ case 2: _t->setFont(*reinterpret_cast< QFont*>(_v)); break;
3689 ✗ case 3: _t->setTextColor(*reinterpret_cast< QColor*>(_v)); break;
3690 ✗ case 4: _t->setIconSize(*reinterpret_cast< QSize*>(_v)); break;
3691 ✗ case 5: _t->setIconTextPadding(*reinterpret_cast< int*>(_v)); break;
3692 ✗ case 6: _t->setIconBorderPen(*reinterpret_cast< QPen*>(_v)); break;
3693 ✗ case 7: _t->setSelectableParts(QFlag(*reinterpret_cast<int*>(_v))); break;
3694 ✗ case 8: _t->setSelectedParts(QFlag(*reinterpret_cast<int*>(_v))); break;
3695 ✗ case 9: _t->setSelectedBorderPen(*reinterpret_cast< QPen*>(_v)); break;
3696 ✗ case 10: _t->setSelectedIconBorderPen(*reinterpret_cast< QPen*>(_v)); break;
3697 ✗ case 11: _t->setSelectedBrush(*reinterpret_cast< QBrush*>(_v)); break;
3698 ✗ case 12: _t->setSelectedFont(*reinterpret_cast< QFont*>(_v)); break;
3699 ✗ case 13: _t->setSelectedTextColor(*reinterpret_cast< QColor*>(_v)); break;
3700 ✗ default: break;
3701 }
3702 } else if (_c == QMetaObject::ResetProperty) {
3703 }
3704 #endif // QT_NO_PROPERTIES
3705 }
3706
3707 QT_INIT_METAOBJECT const QMetaObject QCPLegend::staticMetaObject = { {
3708 QMetaObject::SuperData::link<QCPLayoutGrid::staticMetaObject>(),
3709 qt_meta_stringdata_QCPLegend.data,
3710 qt_meta_data_QCPLegend,
3711 qt_static_metacall,
3712 nullptr,
3713 nullptr
3714 } };
3715
3716
3717 ✗ const QMetaObject *QCPLegend::metaObject() const
3718 {
3719 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
3720 }
3721
3722 ✗ void *QCPLegend::qt_metacast(const char *_clname)
3723 {
3724 ✗ if (!_clname) return nullptr;
3725 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPLegend.stringdata0))
3726 ✗ return static_cast<void*>(this);
3727 ✗ return QCPLayoutGrid::qt_metacast(_clname);
3728 }
3729
3730 ✗ int QCPLegend::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
3731 {
3732 ✗ _id = QCPLayoutGrid::qt_metacall(_c, _id, _a);
3733 ✗ if (_id < 0)
3734 ✗ return _id;
3735 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
3736 ✗ if (_id < 4)
3737 ✗ qt_static_metacall(this, _c, _id, _a);
3738 ✗ _id -= 4;
3739 ✗ } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
3740 ✗ if (_id < 4)
3741 ✗ *reinterpret_cast<int*>(_a[0]) = -1;
3742 ✗ _id -= 4;
3743 }
3744 #ifndef QT_NO_PROPERTIES
3745 ✗ else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
3746 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
3747 ✗ qt_static_metacall(this, _c, _id, _a);
3748 ✗ _id -= 14;
3749 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
3750 ✗ _id -= 14;
3751 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
3752 ✗ _id -= 14;
3753 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
3754 ✗ _id -= 14;
3755 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
3756 ✗ _id -= 14;
3757 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
3758 ✗ _id -= 14;
3759 }
3760 #endif // QT_NO_PROPERTIES
3761 ✗ return _id;
3762 }
3763
3764 // SIGNAL 0
3765 ✗ void QCPLegend::selectionChanged(QCPLegend::SelectableParts _t1)
3766 {
3767 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
3768 ✗ QMetaObject::activate(this, &staticMetaObject, 0, _a);
3769 }
3770
3771 // SIGNAL 1
3772 ✗ void QCPLegend::selectableChanged(QCPLegend::SelectableParts _t1)
3773 {
3774 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
3775 ✗ QMetaObject::activate(this, &staticMetaObject, 1, _a);
3776 }
3777 struct qt_meta_stringdata_QCPPlotTitle_t {
3778 QByteArrayData data[13];
3779 char stringdata0[146];
3780 };
3781 #define QT_MOC_LITERAL(idx, ofs, len) \
3782 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
3783 qptrdiff(offsetof(qt_meta_stringdata_QCPPlotTitle_t, stringdata0) + ofs \
3784 - idx * sizeof(QByteArrayData)) \
3785 )
3786 static const qt_meta_stringdata_QCPPlotTitle_t qt_meta_stringdata_QCPPlotTitle = {
3787 {
3788 QT_MOC_LITERAL(0, 0, 12), // "QCPPlotTitle"
3789 QT_MOC_LITERAL(1, 13, 16), // "selectionChanged"
3790 QT_MOC_LITERAL(2, 30, 0), // ""
3791 QT_MOC_LITERAL(3, 31, 8), // "selected"
3792 QT_MOC_LITERAL(4, 40, 17), // "selectableChanged"
3793 QT_MOC_LITERAL(5, 58, 10), // "selectable"
3794 QT_MOC_LITERAL(6, 69, 13), // "setSelectable"
3795 QT_MOC_LITERAL(7, 83, 11), // "setSelected"
3796 QT_MOC_LITERAL(8, 95, 4), // "text"
3797 QT_MOC_LITERAL(9, 100, 4), // "font"
3798 QT_MOC_LITERAL(10, 105, 9), // "textColor"
3799 QT_MOC_LITERAL(11, 115, 12), // "selectedFont"
3800 QT_MOC_LITERAL(12, 128, 17) // "selectedTextColor"
3801
3802 },
3803 "QCPPlotTitle\0selectionChanged\0\0selected\0"
3804 "selectableChanged\0selectable\0setSelectable\0"
3805 "setSelected\0text\0font\0textColor\0"
3806 "selectedFont\0selectedTextColor"
3807 };
3808 #undef QT_MOC_LITERAL
3809
3810 static const uint qt_meta_data_QCPPlotTitle[] = {
3811
3812 // content:
3813 8, // revision
3814 0, // classname
3815 0, 0, // classinfo
3816 4, 14, // methods
3817 7, 46, // properties
3818 0, 0, // enums/sets
3819 0, 0, // constructors
3820 0, // flags
3821 2, // signalCount
3822
3823 // signals: name, argc, parameters, tag, flags
3824 1, 1, 34, 2, 0x06 /* Public */,
3825 4, 1, 37, 2, 0x06 /* Public */,
3826
3827 // slots: name, argc, parameters, tag, flags
3828 6, 1, 40, 2, 0x0a /* Public */,
3829 7, 1, 43, 2, 0x0a /* Public */,
3830
3831 // signals: parameters
3832 QMetaType::Void, QMetaType::Bool, 3,
3833 QMetaType::Void, QMetaType::Bool, 5,
3834
3835 // slots: parameters
3836 QMetaType::Void, QMetaType::Bool, 5,
3837 QMetaType::Void, QMetaType::Bool, 3,
3838
3839 // properties: name, type, flags
3840 8, QMetaType::QString, 0x00095103,
3841 9, QMetaType::QFont, 0x00095103,
3842 10, QMetaType::QColor, 0x00095103,
3843 11, QMetaType::QFont, 0x00095103,
3844 12, QMetaType::QColor, 0x00095103,
3845 5, QMetaType::Bool, 0x00495103,
3846 3, QMetaType::Bool, 0x00495103,
3847
3848 // properties: notify_signal_id
3849 0,
3850 0,
3851 0,
3852 0,
3853 0,
3854 1,
3855 0,
3856
3857 0 // eod
3858 };
3859
3860 ✗ void QCPPlotTitle::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
3861 {
3862 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
3863 ✗ auto *_t = static_cast<QCPPlotTitle *>(_o);
3864 (void)_t;
3865 ✗ switch (_id) {
3866 ✗ case 0: _t->selectionChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
3867 ✗ case 1: _t->selectableChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
3868 ✗ case 2: _t->setSelectable((*reinterpret_cast< bool(*)>(_a[1]))); break;
3869 ✗ case 3: _t->setSelected((*reinterpret_cast< bool(*)>(_a[1]))); break;
3870 ✗ default: ;
3871 }
3872 ✗ } else if (_c == QMetaObject::IndexOfMethod) {
3873 ✗ int *result = reinterpret_cast<int *>(_a[0]);
3874 {
3875 using _t = void (QCPPlotTitle::*)(bool );
3876 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPPlotTitle::selectionChanged)) {
3877 ✗ *result = 0;
3878 ✗ return;
3879 }
3880 }
3881 {
3882 using _t = void (QCPPlotTitle::*)(bool );
3883 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPPlotTitle::selectableChanged)) {
3884 ✗ *result = 1;
3885 ✗ return;
3886 }
3887 }
3888 }
3889 #ifndef QT_NO_PROPERTIES
3890 ✗ else if (_c == QMetaObject::ReadProperty) {
3891 ✗ auto *_t = static_cast<QCPPlotTitle *>(_o);
3892 (void)_t;
3893 ✗ void *_v = _a[0];
3894 ✗ switch (_id) {
3895 ✗ case 0: *reinterpret_cast< QString*>(_v) = _t->text(); break;
3896 ✗ case 1: *reinterpret_cast< QFont*>(_v) = _t->font(); break;
3897 ✗ case 2: *reinterpret_cast< QColor*>(_v) = _t->textColor(); break;
3898 ✗ case 3: *reinterpret_cast< QFont*>(_v) = _t->selectedFont(); break;
3899 ✗ case 4: *reinterpret_cast< QColor*>(_v) = _t->selectedTextColor(); break;
3900 ✗ case 5: *reinterpret_cast< bool*>(_v) = _t->selectable(); break;
3901 ✗ case 6: *reinterpret_cast< bool*>(_v) = _t->selected(); break;
3902 ✗ default: break;
3903 }
3904 ✗ } else if (_c == QMetaObject::WriteProperty) {
3905 ✗ auto *_t = static_cast<QCPPlotTitle *>(_o);
3906 (void)_t;
3907 ✗ void *_v = _a[0];
3908 ✗ switch (_id) {
3909 ✗ case 0: _t->setText(*reinterpret_cast< QString*>(_v)); break;
3910 ✗ case 1: _t->setFont(*reinterpret_cast< QFont*>(_v)); break;
3911 ✗ case 2: _t->setTextColor(*reinterpret_cast< QColor*>(_v)); break;
3912 ✗ case 3: _t->setSelectedFont(*reinterpret_cast< QFont*>(_v)); break;
3913 ✗ case 4: _t->setSelectedTextColor(*reinterpret_cast< QColor*>(_v)); break;
3914 ✗ case 5: _t->setSelectable(*reinterpret_cast< bool*>(_v)); break;
3915 ✗ case 6: _t->setSelected(*reinterpret_cast< bool*>(_v)); break;
3916 ✗ default: break;
3917 }
3918 } else if (_c == QMetaObject::ResetProperty) {
3919 }
3920 #endif // QT_NO_PROPERTIES
3921 }
3922
3923 QT_INIT_METAOBJECT const QMetaObject QCPPlotTitle::staticMetaObject = { {
3924 QMetaObject::SuperData::link<QCPLayoutElement::staticMetaObject>(),
3925 qt_meta_stringdata_QCPPlotTitle.data,
3926 qt_meta_data_QCPPlotTitle,
3927 qt_static_metacall,
3928 nullptr,
3929 nullptr
3930 } };
3931
3932
3933 ✗ const QMetaObject *QCPPlotTitle::metaObject() const
3934 {
3935 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
3936 }
3937
3938 ✗ void *QCPPlotTitle::qt_metacast(const char *_clname)
3939 {
3940 ✗ if (!_clname) return nullptr;
3941 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPPlotTitle.stringdata0))
3942 ✗ return static_cast<void*>(this);
3943 ✗ return QCPLayoutElement::qt_metacast(_clname);
3944 }
3945
3946 ✗ int QCPPlotTitle::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
3947 {
3948 ✗ _id = QCPLayoutElement::qt_metacall(_c, _id, _a);
3949 ✗ if (_id < 0)
3950 ✗ return _id;
3951 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
3952 ✗ if (_id < 4)
3953 ✗ qt_static_metacall(this, _c, _id, _a);
3954 ✗ _id -= 4;
3955 ✗ } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
3956 ✗ if (_id < 4)
3957 ✗ *reinterpret_cast<int*>(_a[0]) = -1;
3958 ✗ _id -= 4;
3959 }
3960 #ifndef QT_NO_PROPERTIES
3961 ✗ else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
3962 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
3963 ✗ qt_static_metacall(this, _c, _id, _a);
3964 ✗ _id -= 7;
3965 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
3966 ✗ _id -= 7;
3967 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
3968 ✗ _id -= 7;
3969 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
3970 ✗ _id -= 7;
3971 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
3972 ✗ _id -= 7;
3973 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
3974 ✗ _id -= 7;
3975 }
3976 #endif // QT_NO_PROPERTIES
3977 ✗ return _id;
3978 }
3979
3980 // SIGNAL 0
3981 ✗ void QCPPlotTitle::selectionChanged(bool _t1)
3982 {
3983 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
3984 ✗ QMetaObject::activate(this, &staticMetaObject, 0, _a);
3985 }
3986
3987 // SIGNAL 1
3988 ✗ void QCPPlotTitle::selectableChanged(bool _t1)
3989 {
3990 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
3991 ✗ QMetaObject::activate(this, &staticMetaObject, 1, _a);
3992 }
3993 struct qt_meta_stringdata_QCPColorScaleAxisRectPrivate_t {
3994 QByteArrayData data[7];
3995 char stringdata0[128];
3996 };
3997 #define QT_MOC_LITERAL(idx, ofs, len) \
3998 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
3999 qptrdiff(offsetof(qt_meta_stringdata_QCPColorScaleAxisRectPrivate_t, stringdata0) + ofs \
4000 - idx * sizeof(QByteArrayData)) \
4001 )
4002 static const qt_meta_stringdata_QCPColorScaleAxisRectPrivate_t qt_meta_stringdata_QCPColorScaleAxisRectPrivate = {
4003 {
4004 QT_MOC_LITERAL(0, 0, 28), // "QCPColorScaleAxisRectPrivate"
4005 QT_MOC_LITERAL(1, 29, 20), // "axisSelectionChanged"
4006 QT_MOC_LITERAL(2, 50, 0), // ""
4007 QT_MOC_LITERAL(3, 51, 24), // "QCPAxis::SelectableParts"
4008 QT_MOC_LITERAL(4, 76, 13), // "selectedParts"
4009 QT_MOC_LITERAL(5, 90, 21), // "axisSelectableChanged"
4010 QT_MOC_LITERAL(6, 112, 15) // "selectableParts"
4011
4012 },
4013 "QCPColorScaleAxisRectPrivate\0"
4014 "axisSelectionChanged\0\0QCPAxis::SelectableParts\0"
4015 "selectedParts\0axisSelectableChanged\0"
4016 "selectableParts"
4017 };
4018 #undef QT_MOC_LITERAL
4019
4020 static const uint qt_meta_data_QCPColorScaleAxisRectPrivate[] = {
4021
4022 // content:
4023 8, // revision
4024 0, // classname
4025 0, 0, // classinfo
4026 2, 14, // methods
4027 0, 0, // properties
4028 0, 0, // enums/sets
4029 0, 0, // constructors
4030 0, // flags
4031 0, // signalCount
4032
4033 // slots: name, argc, parameters, tag, flags
4034 1, 1, 24, 2, 0x09 /* Protected */,
4035 5, 1, 27, 2, 0x09 /* Protected */,
4036
4037 // slots: parameters
4038 QMetaType::Void, 0x80000000 | 3, 4,
4039 QMetaType::Void, 0x80000000 | 3, 6,
4040
4041 0 // eod
4042 };
4043
4044 ✗ void QCPColorScaleAxisRectPrivate::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
4045 {
4046 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
4047 ✗ auto *_t = static_cast<QCPColorScaleAxisRectPrivate *>(_o);
4048 (void)_t;
4049 ✗ switch (_id) {
4050 ✗ case 0: _t->axisSelectionChanged((*reinterpret_cast< QCPAxis::SelectableParts(*)>(_a[1]))); break;
4051 ✗ case 1: _t->axisSelectableChanged((*reinterpret_cast< QCPAxis::SelectableParts(*)>(_a[1]))); break;
4052 ✗ default: ;
4053 }
4054 }
4055 }
4056
4057 QT_INIT_METAOBJECT const QMetaObject QCPColorScaleAxisRectPrivate::staticMetaObject = { {
4058 QMetaObject::SuperData::link<QCPAxisRect::staticMetaObject>(),
4059 qt_meta_stringdata_QCPColorScaleAxisRectPrivate.data,
4060 qt_meta_data_QCPColorScaleAxisRectPrivate,
4061 qt_static_metacall,
4062 nullptr,
4063 nullptr
4064 } };
4065
4066
4067 ✗ const QMetaObject *QCPColorScaleAxisRectPrivate::metaObject() const
4068 {
4069 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
4070 }
4071
4072 ✗ void *QCPColorScaleAxisRectPrivate::qt_metacast(const char *_clname)
4073 {
4074 ✗ if (!_clname) return nullptr;
4075 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPColorScaleAxisRectPrivate.stringdata0))
4076 ✗ return static_cast<void*>(this);
4077 ✗ return QCPAxisRect::qt_metacast(_clname);
4078 }
4079
4080 ✗ int QCPColorScaleAxisRectPrivate::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
4081 {
4082 ✗ _id = QCPAxisRect::qt_metacall(_c, _id, _a);
4083 ✗ if (_id < 0)
4084 ✗ return _id;
4085 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
4086 ✗ if (_id < 2)
4087 ✗ qt_static_metacall(this, _c, _id, _a);
4088 ✗ _id -= 2;
4089 ✗ } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
4090 ✗ if (_id < 2)
4091 ✗ *reinterpret_cast<int*>(_a[0]) = -1;
4092 ✗ _id -= 2;
4093 }
4094 ✗ return _id;
4095 }
4096 struct qt_meta_stringdata_QCPColorScale_t {
4097 QByteArrayData data[23];
4098 char stringdata0[278];
4099 };
4100 #define QT_MOC_LITERAL(idx, ofs, len) \
4101 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
4102 qptrdiff(offsetof(qt_meta_stringdata_QCPColorScale_t, stringdata0) + ofs \
4103 - idx * sizeof(QByteArrayData)) \
4104 )
4105 static const qt_meta_stringdata_QCPColorScale_t qt_meta_stringdata_QCPColorScale = {
4106 {
4107 QT_MOC_LITERAL(0, 0, 13), // "QCPColorScale"
4108 QT_MOC_LITERAL(1, 14, 16), // "dataRangeChanged"
4109 QT_MOC_LITERAL(2, 31, 0), // ""
4110 QT_MOC_LITERAL(3, 32, 8), // "QCPRange"
4111 QT_MOC_LITERAL(4, 41, 8), // "newRange"
4112 QT_MOC_LITERAL(5, 50, 20), // "dataScaleTypeChanged"
4113 QT_MOC_LITERAL(6, 71, 18), // "QCPAxis::ScaleType"
4114 QT_MOC_LITERAL(7, 90, 9), // "scaleType"
4115 QT_MOC_LITERAL(8, 100, 15), // "gradientChanged"
4116 QT_MOC_LITERAL(9, 116, 16), // "QCPColorGradient"
4117 QT_MOC_LITERAL(10, 133, 11), // "newGradient"
4118 QT_MOC_LITERAL(11, 145, 12), // "setDataRange"
4119 QT_MOC_LITERAL(12, 158, 9), // "dataRange"
4120 QT_MOC_LITERAL(13, 168, 16), // "setDataScaleType"
4121 QT_MOC_LITERAL(14, 185, 11), // "setGradient"
4122 QT_MOC_LITERAL(15, 197, 8), // "gradient"
4123 QT_MOC_LITERAL(16, 206, 4), // "type"
4124 QT_MOC_LITERAL(17, 211, 17), // "QCPAxis::AxisType"
4125 QT_MOC_LITERAL(18, 229, 13), // "dataScaleType"
4126 QT_MOC_LITERAL(19, 243, 5), // "label"
4127 QT_MOC_LITERAL(20, 249, 8), // "barWidth"
4128 QT_MOC_LITERAL(21, 258, 9), // "rangeDrag"
4129 QT_MOC_LITERAL(22, 268, 9) // "rangeZoom"
4130
4131 },
4132 "QCPColorScale\0dataRangeChanged\0\0"
4133 "QCPRange\0newRange\0dataScaleTypeChanged\0"
4134 "QCPAxis::ScaleType\0scaleType\0"
4135 "gradientChanged\0QCPColorGradient\0"
4136 "newGradient\0setDataRange\0dataRange\0"
4137 "setDataScaleType\0setGradient\0gradient\0"
4138 "type\0QCPAxis::AxisType\0dataScaleType\0"
4139 "label\0barWidth\0rangeDrag\0rangeZoom"
4140 };
4141 #undef QT_MOC_LITERAL
4142
4143 static const uint qt_meta_data_QCPColorScale[] = {
4144
4145 // content:
4146 8, // revision
4147 0, // classname
4148 0, 0, // classinfo
4149 6, 14, // methods
4150 8, 62, // properties
4151 0, 0, // enums/sets
4152 0, 0, // constructors
4153 0, // flags
4154 3, // signalCount
4155
4156 // signals: name, argc, parameters, tag, flags
4157 1, 1, 44, 2, 0x06 /* Public */,
4158 5, 1, 47, 2, 0x06 /* Public */,
4159 8, 1, 50, 2, 0x06 /* Public */,
4160
4161 // slots: name, argc, parameters, tag, flags
4162 11, 1, 53, 2, 0x0a /* Public */,
4163 13, 1, 56, 2, 0x0a /* Public */,
4164 14, 1, 59, 2, 0x0a /* Public */,
4165
4166 // signals: parameters
4167 QMetaType::Void, 0x80000000 | 3, 4,
4168 QMetaType::Void, 0x80000000 | 6, 7,
4169 QMetaType::Void, 0x80000000 | 9, 10,
4170
4171 // slots: parameters
4172 QMetaType::Void, 0x80000000 | 3, 12,
4173 QMetaType::Void, 0x80000000 | 6, 7,
4174 QMetaType::Void, 0x80000000 | 9, 15,
4175
4176 // properties: name, type, flags
4177 16, 0x80000000 | 17, 0x0009510b,
4178 12, 0x80000000 | 3, 0x0049510b,
4179 18, 0x80000000 | 6, 0x0049510b,
4180 15, 0x80000000 | 9, 0x0049510b,
4181 19, QMetaType::QString, 0x00095103,
4182 20, QMetaType::Int, 0x00095103,
4183 21, QMetaType::Bool, 0x00095103,
4184 22, QMetaType::Bool, 0x00095103,
4185
4186 // properties: notify_signal_id
4187 0,
4188 0,
4189 1,
4190 2,
4191 0,
4192 0,
4193 0,
4194 0,
4195
4196 0 // eod
4197 };
4198
4199 ✗ void QCPColorScale::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
4200 {
4201 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
4202 ✗ auto *_t = static_cast<QCPColorScale *>(_o);
4203 (void)_t;
4204 ✗ switch (_id) {
4205 ✗ case 0: _t->dataRangeChanged((*reinterpret_cast< QCPRange(*)>(_a[1]))); break;
4206 ✗ case 1: _t->dataScaleTypeChanged((*reinterpret_cast< QCPAxis::ScaleType(*)>(_a[1]))); break;
4207 ✗ case 2: _t->gradientChanged((*reinterpret_cast< QCPColorGradient(*)>(_a[1]))); break;
4208 ✗ case 3: _t->setDataRange((*reinterpret_cast< const QCPRange(*)>(_a[1]))); break;
4209 ✗ case 4: _t->setDataScaleType((*reinterpret_cast< QCPAxis::ScaleType(*)>(_a[1]))); break;
4210 ✗ case 5: _t->setGradient((*reinterpret_cast< const QCPColorGradient(*)>(_a[1]))); break;
4211 ✗ default: ;
4212 }
4213 ✗ } else if (_c == QMetaObject::IndexOfMethod) {
4214 ✗ int *result = reinterpret_cast<int *>(_a[0]);
4215 {
4216 using _t = void (QCPColorScale::*)(QCPRange );
4217 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPColorScale::dataRangeChanged)) {
4218 ✗ *result = 0;
4219 ✗ return;
4220 }
4221 }
4222 {
4223 using _t = void (QCPColorScale::*)(QCPAxis::ScaleType );
4224 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPColorScale::dataScaleTypeChanged)) {
4225 ✗ *result = 1;
4226 ✗ return;
4227 }
4228 }
4229 {
4230 using _t = void (QCPColorScale::*)(QCPColorGradient );
4231 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPColorScale::gradientChanged)) {
4232 ✗ *result = 2;
4233 ✗ return;
4234 }
4235 }
4236 }
4237 #ifndef QT_NO_PROPERTIES
4238 ✗ else if (_c == QMetaObject::ReadProperty) {
4239 ✗ auto *_t = static_cast<QCPColorScale *>(_o);
4240 (void)_t;
4241 ✗ void *_v = _a[0];
4242 ✗ switch (_id) {
4243 ✗ case 0: *reinterpret_cast< QCPAxis::AxisType*>(_v) = _t->type(); break;
4244 ✗ case 1: *reinterpret_cast< QCPRange*>(_v) = _t->dataRange(); break;
4245 ✗ case 2: *reinterpret_cast< QCPAxis::ScaleType*>(_v) = _t->dataScaleType(); break;
4246 ✗ case 3: *reinterpret_cast< QCPColorGradient*>(_v) = _t->gradient(); break;
4247 ✗ case 4: *reinterpret_cast< QString*>(_v) = _t->label(); break;
4248 ✗ case 5: *reinterpret_cast< int*>(_v) = _t->barWidth(); break;
4249 ✗ case 6: *reinterpret_cast< bool*>(_v) = _t->rangeDrag(); break;
4250 ✗ case 7: *reinterpret_cast< bool*>(_v) = _t->rangeZoom(); break;
4251 ✗ default: break;
4252 }
4253 ✗ } else if (_c == QMetaObject::WriteProperty) {
4254 ✗ auto *_t = static_cast<QCPColorScale *>(_o);
4255 (void)_t;
4256 ✗ void *_v = _a[0];
4257 ✗ switch (_id) {
4258 ✗ case 0: _t->setType(*reinterpret_cast< QCPAxis::AxisType*>(_v)); break;
4259 ✗ case 1: _t->setDataRange(*reinterpret_cast< QCPRange*>(_v)); break;
4260 ✗ case 2: _t->setDataScaleType(*reinterpret_cast< QCPAxis::ScaleType*>(_v)); break;
4261 ✗ case 3: _t->setGradient(*reinterpret_cast< QCPColorGradient*>(_v)); break;
4262 ✗ case 4: _t->setLabel(*reinterpret_cast< QString*>(_v)); break;
4263 ✗ case 5: _t->setBarWidth(*reinterpret_cast< int*>(_v)); break;
4264 ✗ case 6: _t->setRangeDrag(*reinterpret_cast< bool*>(_v)); break;
4265 ✗ case 7: _t->setRangeZoom(*reinterpret_cast< bool*>(_v)); break;
4266 ✗ default: break;
4267 }
4268 } else if (_c == QMetaObject::ResetProperty) {
4269 }
4270 #endif // QT_NO_PROPERTIES
4271 }
4272
4273 static const QMetaObject::SuperData qt_meta_extradata_QCPColorScale[] = {
4274 QMetaObject::SuperData::link<QCPAxis::staticMetaObject>(),
4275 nullptr
4276 };
4277
4278 QT_INIT_METAOBJECT const QMetaObject QCPColorScale::staticMetaObject = { {
4279 QMetaObject::SuperData::link<QCPLayoutElement::staticMetaObject>(),
4280 qt_meta_stringdata_QCPColorScale.data,
4281 qt_meta_data_QCPColorScale,
4282 qt_static_metacall,
4283 qt_meta_extradata_QCPColorScale,
4284 nullptr
4285 } };
4286
4287
4288 ✗ const QMetaObject *QCPColorScale::metaObject() const
4289 {
4290 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
4291 }
4292
4293 ✗ void *QCPColorScale::qt_metacast(const char *_clname)
4294 {
4295 ✗ if (!_clname) return nullptr;
4296 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPColorScale.stringdata0))
4297 ✗ return static_cast<void*>(this);
4298 ✗ return QCPLayoutElement::qt_metacast(_clname);
4299 }
4300
4301 ✗ int QCPColorScale::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
4302 {
4303 ✗ _id = QCPLayoutElement::qt_metacall(_c, _id, _a);
4304 ✗ if (_id < 0)
4305 ✗ return _id;
4306 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
4307 ✗ if (_id < 6)
4308 ✗ qt_static_metacall(this, _c, _id, _a);
4309 ✗ _id -= 6;
4310 ✗ } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
4311 ✗ if (_id < 6)
4312 ✗ *reinterpret_cast<int*>(_a[0]) = -1;
4313 ✗ _id -= 6;
4314 }
4315 #ifndef QT_NO_PROPERTIES
4316 ✗ else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
4317 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
4318 ✗ qt_static_metacall(this, _c, _id, _a);
4319 ✗ _id -= 8;
4320 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
4321 ✗ _id -= 8;
4322 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
4323 ✗ _id -= 8;
4324 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
4325 ✗ _id -= 8;
4326 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
4327 ✗ _id -= 8;
4328 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
4329 ✗ _id -= 8;
4330 }
4331 #endif // QT_NO_PROPERTIES
4332 ✗ return _id;
4333 }
4334
4335 // SIGNAL 0
4336 ✗ void QCPColorScale::dataRangeChanged(QCPRange _t1)
4337 {
4338 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
4339 ✗ QMetaObject::activate(this, &staticMetaObject, 0, _a);
4340 }
4341
4342 // SIGNAL 1
4343 ✗ void QCPColorScale::dataScaleTypeChanged(QCPAxis::ScaleType _t1)
4344 {
4345 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
4346 ✗ QMetaObject::activate(this, &staticMetaObject, 1, _a);
4347 }
4348
4349 // SIGNAL 2
4350 ✗ void QCPColorScale::gradientChanged(QCPColorGradient _t1)
4351 {
4352 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
4353 ✗ QMetaObject::activate(this, &staticMetaObject, 2, _a);
4354 }
4355 struct qt_meta_stringdata_QCPGraph_t {
4356 QByteArrayData data[23];
4357 char stringdata0[251];
4358 };
4359 #define QT_MOC_LITERAL(idx, ofs, len) \
4360 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
4361 qptrdiff(offsetof(qt_meta_stringdata_QCPGraph_t, stringdata0) + ofs \
4362 - idx * sizeof(QByteArrayData)) \
4363 )
4364 static const qt_meta_stringdata_QCPGraph_t qt_meta_stringdata_QCPGraph = {
4365 {
4366 QT_MOC_LITERAL(0, 0, 8), // "QCPGraph"
4367 QT_MOC_LITERAL(1, 9, 9), // "lineStyle"
4368 QT_MOC_LITERAL(2, 19, 9), // "LineStyle"
4369 QT_MOC_LITERAL(3, 29, 12), // "scatterStyle"
4370 QT_MOC_LITERAL(4, 42, 15), // "QCPScatterStyle"
4371 QT_MOC_LITERAL(5, 58, 9), // "errorType"
4372 QT_MOC_LITERAL(6, 68, 9), // "ErrorType"
4373 QT_MOC_LITERAL(7, 78, 8), // "errorPen"
4374 QT_MOC_LITERAL(8, 87, 12), // "errorBarSize"
4375 QT_MOC_LITERAL(9, 100, 18), // "errorBarSkipSymbol"
4376 QT_MOC_LITERAL(10, 119, 16), // "channelFillGraph"
4377 QT_MOC_LITERAL(11, 136, 9), // "QCPGraph*"
4378 QT_MOC_LITERAL(12, 146, 16), // "adaptiveSampling"
4379 QT_MOC_LITERAL(13, 163, 6), // "lsNone"
4380 QT_MOC_LITERAL(14, 170, 6), // "lsLine"
4381 QT_MOC_LITERAL(15, 177, 10), // "lsStepLeft"
4382 QT_MOC_LITERAL(16, 188, 11), // "lsStepRight"
4383 QT_MOC_LITERAL(17, 200, 12), // "lsStepCenter"
4384 QT_MOC_LITERAL(18, 213, 9), // "lsImpulse"
4385 QT_MOC_LITERAL(19, 223, 6), // "etNone"
4386 QT_MOC_LITERAL(20, 230, 5), // "etKey"
4387 QT_MOC_LITERAL(21, 236, 7), // "etValue"
4388 QT_MOC_LITERAL(22, 244, 6) // "etBoth"
4389
4390 },
4391 "QCPGraph\0lineStyle\0LineStyle\0scatterStyle\0"
4392 "QCPScatterStyle\0errorType\0ErrorType\0"
4393 "errorPen\0errorBarSize\0errorBarSkipSymbol\0"
4394 "channelFillGraph\0QCPGraph*\0adaptiveSampling\0"
4395 "lsNone\0lsLine\0lsStepLeft\0lsStepRight\0"
4396 "lsStepCenter\0lsImpulse\0etNone\0etKey\0"
4397 "etValue\0etBoth"
4398 };
4399 #undef QT_MOC_LITERAL
4400
4401 static const uint qt_meta_data_QCPGraph[] = {
4402
4403 // content:
4404 8, // revision
4405 0, // classname
4406 0, 0, // classinfo
4407 0, 0, // methods
4408 8, 14, // properties
4409 2, 38, // enums/sets
4410 0, 0, // constructors
4411 0, // flags
4412 0, // signalCount
4413
4414 // properties: name, type, flags
4415 1, 0x80000000 | 2, 0x0009510b,
4416 3, 0x80000000 | 4, 0x0009510b,
4417 5, 0x80000000 | 6, 0x0009510b,
4418 7, QMetaType::QPen, 0x00095103,
4419 8, QMetaType::Double, 0x00095103,
4420 9, QMetaType::Bool, 0x00095103,
4421 10, 0x80000000 | 11, 0x0009510b,
4422 12, QMetaType::Bool, 0x00095103,
4423
4424 // enums: name, alias, flags, count, data
4425 2, 2, 0x0, 6, 48,
4426 6, 6, 0x0, 4, 60,
4427
4428 // enum data: key, value
4429 13, uint(QCPGraph::lsNone),
4430 14, uint(QCPGraph::lsLine),
4431 15, uint(QCPGraph::lsStepLeft),
4432 16, uint(QCPGraph::lsStepRight),
4433 17, uint(QCPGraph::lsStepCenter),
4434 18, uint(QCPGraph::lsImpulse),
4435 19, uint(QCPGraph::etNone),
4436 20, uint(QCPGraph::etKey),
4437 21, uint(QCPGraph::etValue),
4438 22, uint(QCPGraph::etBoth),
4439
4440 0 // eod
4441 };
4442
4443 ✗ void QCPGraph::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
4444 {
4445 ✗ if (_c == QMetaObject::RegisterPropertyMetaType) {
4446 ✗ switch (_id) {
4447 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
4448 ✗ case 6:
4449 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPGraph* >(); break;
4450 }
4451 }
4452
4453 #ifndef QT_NO_PROPERTIES
4454 ✗ else if (_c == QMetaObject::ReadProperty) {
4455 ✗ auto *_t = static_cast<QCPGraph *>(_o);
4456 (void)_t;
4457 ✗ void *_v = _a[0];
4458 ✗ switch (_id) {
4459 ✗ case 0: *reinterpret_cast< LineStyle*>(_v) = _t->lineStyle(); break;
4460 ✗ case 1: *reinterpret_cast< QCPScatterStyle*>(_v) = _t->scatterStyle(); break;
4461 ✗ case 2: *reinterpret_cast< ErrorType*>(_v) = _t->errorType(); break;
4462 ✗ case 3: *reinterpret_cast< QPen*>(_v) = _t->errorPen(); break;
4463 ✗ case 4: *reinterpret_cast< double*>(_v) = _t->errorBarSize(); break;
4464 ✗ case 5: *reinterpret_cast< bool*>(_v) = _t->errorBarSkipSymbol(); break;
4465 ✗ case 6: *reinterpret_cast< QCPGraph**>(_v) = _t->channelFillGraph(); break;
4466 ✗ case 7: *reinterpret_cast< bool*>(_v) = _t->adaptiveSampling(); break;
4467 ✗ default: break;
4468 }
4469 ✗ } else if (_c == QMetaObject::WriteProperty) {
4470 ✗ auto *_t = static_cast<QCPGraph *>(_o);
4471 (void)_t;
4472 ✗ void *_v = _a[0];
4473 ✗ switch (_id) {
4474 ✗ case 0: _t->setLineStyle(*reinterpret_cast< LineStyle*>(_v)); break;
4475 ✗ case 1: _t->setScatterStyle(*reinterpret_cast< QCPScatterStyle*>(_v)); break;
4476 ✗ case 2: _t->setErrorType(*reinterpret_cast< ErrorType*>(_v)); break;
4477 ✗ case 3: _t->setErrorPen(*reinterpret_cast< QPen*>(_v)); break;
4478 ✗ case 4: _t->setErrorBarSize(*reinterpret_cast< double*>(_v)); break;
4479 ✗ case 5: _t->setErrorBarSkipSymbol(*reinterpret_cast< bool*>(_v)); break;
4480 ✗ case 6: _t->setChannelFillGraph(*reinterpret_cast< QCPGraph**>(_v)); break;
4481 ✗ case 7: _t->setAdaptiveSampling(*reinterpret_cast< bool*>(_v)); break;
4482 ✗ default: break;
4483 }
4484 } else if (_c == QMetaObject::ResetProperty) {
4485 }
4486 #endif // QT_NO_PROPERTIES
4487 (void)_o;
4488 }
4489
4490 QT_INIT_METAOBJECT const QMetaObject QCPGraph::staticMetaObject = { {
4491 QMetaObject::SuperData::link<QCPAbstractPlottable::staticMetaObject>(),
4492 qt_meta_stringdata_QCPGraph.data,
4493 qt_meta_data_QCPGraph,
4494 qt_static_metacall,
4495 nullptr,
4496 nullptr
4497 } };
4498
4499
4500 ✗ const QMetaObject *QCPGraph::metaObject() const
4501 {
4502 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
4503 }
4504
4505 ✗ void *QCPGraph::qt_metacast(const char *_clname)
4506 {
4507 ✗ if (!_clname) return nullptr;
4508 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPGraph.stringdata0))
4509 ✗ return static_cast<void*>(this);
4510 ✗ return QCPAbstractPlottable::qt_metacast(_clname);
4511 }
4512
4513 ✗ int QCPGraph::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
4514 {
4515 ✗ _id = QCPAbstractPlottable::qt_metacall(_c, _id, _a);
4516 ✗ if (_id < 0)
4517 ✗ return _id;
4518
4519 #ifndef QT_NO_PROPERTIES
4520 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
4521 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
4522 ✗ qt_static_metacall(this, _c, _id, _a);
4523 ✗ _id -= 8;
4524 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
4525 ✗ _id -= 8;
4526 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
4527 ✗ _id -= 8;
4528 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
4529 ✗ _id -= 8;
4530 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
4531 ✗ _id -= 8;
4532 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
4533 ✗ _id -= 8;
4534 }
4535 #endif // QT_NO_PROPERTIES
4536 ✗ return _id;
4537 }
4538 struct qt_meta_stringdata_QCPCurve_t {
4539 QByteArrayData data[5];
4540 char stringdata0[58];
4541 };
4542 #define QT_MOC_LITERAL(idx, ofs, len) \
4543 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
4544 qptrdiff(offsetof(qt_meta_stringdata_QCPCurve_t, stringdata0) + ofs \
4545 - idx * sizeof(QByteArrayData)) \
4546 )
4547 static const qt_meta_stringdata_QCPCurve_t qt_meta_stringdata_QCPCurve = {
4548 {
4549 QT_MOC_LITERAL(0, 0, 8), // "QCPCurve"
4550 QT_MOC_LITERAL(1, 9, 12), // "scatterStyle"
4551 QT_MOC_LITERAL(2, 22, 15), // "QCPScatterStyle"
4552 QT_MOC_LITERAL(3, 38, 9), // "lineStyle"
4553 QT_MOC_LITERAL(4, 48, 9) // "LineStyle"
4554
4555 },
4556 "QCPCurve\0scatterStyle\0QCPScatterStyle\0"
4557 "lineStyle\0LineStyle"
4558 };
4559 #undef QT_MOC_LITERAL
4560
4561 static const uint qt_meta_data_QCPCurve[] = {
4562
4563 // content:
4564 8, // revision
4565 0, // classname
4566 0, 0, // classinfo
4567 0, 0, // methods
4568 2, 14, // properties
4569 0, 0, // enums/sets
4570 0, 0, // constructors
4571 0, // flags
4572 0, // signalCount
4573
4574 // properties: name, type, flags
4575 1, 0x80000000 | 2, 0x0009510b,
4576 3, 0x80000000 | 4, 0x0009510b,
4577
4578 0 // eod
4579 };
4580
4581 ✗ void QCPCurve::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
4582 {
4583
4584 #ifndef QT_NO_PROPERTIES
4585 ✗ if (_c == QMetaObject::ReadProperty) {
4586 ✗ auto *_t = static_cast<QCPCurve *>(_o);
4587 (void)_t;
4588 ✗ void *_v = _a[0];
4589 ✗ switch (_id) {
4590 ✗ case 0: *reinterpret_cast< QCPScatterStyle*>(_v) = _t->scatterStyle(); break;
4591 ✗ case 1: *reinterpret_cast< LineStyle*>(_v) = _t->lineStyle(); break;
4592 ✗ default: break;
4593 }
4594 ✗ } else if (_c == QMetaObject::WriteProperty) {
4595 ✗ auto *_t = static_cast<QCPCurve *>(_o);
4596 (void)_t;
4597 ✗ void *_v = _a[0];
4598 ✗ switch (_id) {
4599 ✗ case 0: _t->setScatterStyle(*reinterpret_cast< QCPScatterStyle*>(_v)); break;
4600 ✗ case 1: _t->setLineStyle(*reinterpret_cast< LineStyle*>(_v)); break;
4601 ✗ default: break;
4602 }
4603 } else if (_c == QMetaObject::ResetProperty) {
4604 }
4605 #endif // QT_NO_PROPERTIES
4606 (void)_o;
4607 (void)_id;
4608 (void)_c;
4609 (void)_a;
4610 }
4611
4612 QT_INIT_METAOBJECT const QMetaObject QCPCurve::staticMetaObject = { {
4613 QMetaObject::SuperData::link<QCPAbstractPlottable::staticMetaObject>(),
4614 qt_meta_stringdata_QCPCurve.data,
4615 qt_meta_data_QCPCurve,
4616 qt_static_metacall,
4617 nullptr,
4618 nullptr
4619 } };
4620
4621
4622 ✗ const QMetaObject *QCPCurve::metaObject() const
4623 {
4624 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
4625 }
4626
4627 ✗ void *QCPCurve::qt_metacast(const char *_clname)
4628 {
4629 ✗ if (!_clname) return nullptr;
4630 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPCurve.stringdata0))
4631 ✗ return static_cast<void*>(this);
4632 ✗ return QCPAbstractPlottable::qt_metacast(_clname);
4633 }
4634
4635 ✗ int QCPCurve::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
4636 {
4637 ✗ _id = QCPAbstractPlottable::qt_metacall(_c, _id, _a);
4638 ✗ if (_id < 0)
4639 ✗ return _id;
4640
4641 #ifndef QT_NO_PROPERTIES
4642 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
4643 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
4644 ✗ qt_static_metacall(this, _c, _id, _a);
4645 ✗ _id -= 2;
4646 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
4647 ✗ _id -= 2;
4648 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
4649 ✗ _id -= 2;
4650 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
4651 ✗ _id -= 2;
4652 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
4653 ✗ _id -= 2;
4654 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
4655 ✗ _id -= 2;
4656 }
4657 #endif // QT_NO_PROPERTIES
4658 ✗ return _id;
4659 }
4660 struct qt_meta_stringdata_QCPBarsGroup_t {
4661 QByteArrayData data[4];
4662 char stringdata0[45];
4663 };
4664 #define QT_MOC_LITERAL(idx, ofs, len) \
4665 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
4666 qptrdiff(offsetof(qt_meta_stringdata_QCPBarsGroup_t, stringdata0) + ofs \
4667 - idx * sizeof(QByteArrayData)) \
4668 )
4669 static const qt_meta_stringdata_QCPBarsGroup_t qt_meta_stringdata_QCPBarsGroup = {
4670 {
4671 QT_MOC_LITERAL(0, 0, 12), // "QCPBarsGroup"
4672 QT_MOC_LITERAL(1, 13, 11), // "spacingType"
4673 QT_MOC_LITERAL(2, 25, 11), // "SpacingType"
4674 QT_MOC_LITERAL(3, 37, 7) // "spacing"
4675
4676 },
4677 "QCPBarsGroup\0spacingType\0SpacingType\0"
4678 "spacing"
4679 };
4680 #undef QT_MOC_LITERAL
4681
4682 static const uint qt_meta_data_QCPBarsGroup[] = {
4683
4684 // content:
4685 8, // revision
4686 0, // classname
4687 0, 0, // classinfo
4688 0, 0, // methods
4689 2, 14, // properties
4690 0, 0, // enums/sets
4691 0, 0, // constructors
4692 0, // flags
4693 0, // signalCount
4694
4695 // properties: name, type, flags
4696 1, 0x80000000 | 2, 0x0009510b,
4697 3, QMetaType::Double, 0x00095103,
4698
4699 0 // eod
4700 };
4701
4702 ✗ void QCPBarsGroup::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
4703 {
4704
4705 #ifndef QT_NO_PROPERTIES
4706 ✗ if (_c == QMetaObject::ReadProperty) {
4707 ✗ auto *_t = static_cast<QCPBarsGroup *>(_o);
4708 (void)_t;
4709 ✗ void *_v = _a[0];
4710 ✗ switch (_id) {
4711 ✗ case 0: *reinterpret_cast< SpacingType*>(_v) = _t->spacingType(); break;
4712 ✗ case 1: *reinterpret_cast< double*>(_v) = _t->spacing(); break;
4713 ✗ default: break;
4714 }
4715 ✗ } else if (_c == QMetaObject::WriteProperty) {
4716 ✗ auto *_t = static_cast<QCPBarsGroup *>(_o);
4717 (void)_t;
4718 ✗ void *_v = _a[0];
4719 ✗ switch (_id) {
4720 ✗ case 0: _t->setSpacingType(*reinterpret_cast< SpacingType*>(_v)); break;
4721 ✗ case 1: _t->setSpacing(*reinterpret_cast< double*>(_v)); break;
4722 ✗ default: break;
4723 }
4724 } else if (_c == QMetaObject::ResetProperty) {
4725 }
4726 #endif // QT_NO_PROPERTIES
4727 (void)_o;
4728 (void)_id;
4729 (void)_c;
4730 (void)_a;
4731 }
4732
4733 QT_INIT_METAOBJECT const QMetaObject QCPBarsGroup::staticMetaObject = { {
4734 QMetaObject::SuperData::link<QObject::staticMetaObject>(),
4735 qt_meta_stringdata_QCPBarsGroup.data,
4736 qt_meta_data_QCPBarsGroup,
4737 qt_static_metacall,
4738 nullptr,
4739 nullptr
4740 } };
4741
4742
4743 ✗ const QMetaObject *QCPBarsGroup::metaObject() const
4744 {
4745 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
4746 }
4747
4748 ✗ void *QCPBarsGroup::qt_metacast(const char *_clname)
4749 {
4750 ✗ if (!_clname) return nullptr;
4751 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPBarsGroup.stringdata0))
4752 ✗ return static_cast<void*>(this);
4753 ✗ return QObject::qt_metacast(_clname);
4754 }
4755
4756 ✗ int QCPBarsGroup::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
4757 {
4758 ✗ _id = QObject::qt_metacall(_c, _id, _a);
4759 ✗ if (_id < 0)
4760 ✗ return _id;
4761
4762 #ifndef QT_NO_PROPERTIES
4763 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
4764 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
4765 ✗ qt_static_metacall(this, _c, _id, _a);
4766 ✗ _id -= 2;
4767 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
4768 ✗ _id -= 2;
4769 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
4770 ✗ _id -= 2;
4771 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
4772 ✗ _id -= 2;
4773 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
4774 ✗ _id -= 2;
4775 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
4776 ✗ _id -= 2;
4777 }
4778 #endif // QT_NO_PROPERTIES
4779 ✗ return _id;
4780 }
4781 struct qt_meta_stringdata_QCPBars_t {
4782 QByteArrayData data[13];
4783 char stringdata0[135];
4784 };
4785 #define QT_MOC_LITERAL(idx, ofs, len) \
4786 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
4787 qptrdiff(offsetof(qt_meta_stringdata_QCPBars_t, stringdata0) + ofs \
4788 - idx * sizeof(QByteArrayData)) \
4789 )
4790 static const qt_meta_stringdata_QCPBars_t qt_meta_stringdata_QCPBars = {
4791 {
4792 QT_MOC_LITERAL(0, 0, 7), // "QCPBars"
4793 QT_MOC_LITERAL(1, 8, 5), // "width"
4794 QT_MOC_LITERAL(2, 14, 9), // "widthType"
4795 QT_MOC_LITERAL(3, 24, 9), // "WidthType"
4796 QT_MOC_LITERAL(4, 34, 9), // "barsGroup"
4797 QT_MOC_LITERAL(5, 44, 13), // "QCPBarsGroup*"
4798 QT_MOC_LITERAL(6, 58, 9), // "baseValue"
4799 QT_MOC_LITERAL(7, 68, 8), // "barBelow"
4800 QT_MOC_LITERAL(8, 77, 8), // "QCPBars*"
4801 QT_MOC_LITERAL(9, 86, 8), // "barAbove"
4802 QT_MOC_LITERAL(10, 95, 10), // "wtAbsolute"
4803 QT_MOC_LITERAL(11, 106, 15), // "wtAxisRectRatio"
4804 QT_MOC_LITERAL(12, 122, 12) // "wtPlotCoords"
4805
4806 },
4807 "QCPBars\0width\0widthType\0WidthType\0"
4808 "barsGroup\0QCPBarsGroup*\0baseValue\0"
4809 "barBelow\0QCPBars*\0barAbove\0wtAbsolute\0"
4810 "wtAxisRectRatio\0wtPlotCoords"
4811 };
4812 #undef QT_MOC_LITERAL
4813
4814 static const uint qt_meta_data_QCPBars[] = {
4815
4816 // content:
4817 8, // revision
4818 0, // classname
4819 0, 0, // classinfo
4820 0, 0, // methods
4821 6, 14, // properties
4822 1, 32, // enums/sets
4823 0, 0, // constructors
4824 0, // flags
4825 0, // signalCount
4826
4827 // properties: name, type, flags
4828 1, QMetaType::Double, 0x00095103,
4829 2, 0x80000000 | 3, 0x0009510b,
4830 4, 0x80000000 | 5, 0x0009510b,
4831 6, QMetaType::Double, 0x00095103,
4832 7, 0x80000000 | 8, 0x00095009,
4833 9, 0x80000000 | 8, 0x00095009,
4834
4835 // enums: name, alias, flags, count, data
4836 3, 3, 0x0, 3, 37,
4837
4838 // enum data: key, value
4839 10, uint(QCPBars::wtAbsolute),
4840 11, uint(QCPBars::wtAxisRectRatio),
4841 12, uint(QCPBars::wtPlotCoords),
4842
4843 0 // eod
4844 };
4845
4846 ✗ void QCPBars::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
4847 {
4848 ✗ if (_c == QMetaObject::RegisterPropertyMetaType) {
4849 ✗ switch (_id) {
4850 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
4851 ✗ case 5:
4852 case 4:
4853 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPBars* >(); break;
4854 ✗ case 2:
4855 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPBarsGroup* >(); break;
4856 }
4857 }
4858
4859 #ifndef QT_NO_PROPERTIES
4860 ✗ else if (_c == QMetaObject::ReadProperty) {
4861 ✗ auto *_t = static_cast<QCPBars *>(_o);
4862 (void)_t;
4863 ✗ void *_v = _a[0];
4864 ✗ switch (_id) {
4865 ✗ case 0: *reinterpret_cast< double*>(_v) = _t->width(); break;
4866 ✗ case 1: *reinterpret_cast< WidthType*>(_v) = _t->widthType(); break;
4867 ✗ case 2: *reinterpret_cast< QCPBarsGroup**>(_v) = _t->barsGroup(); break;
4868 ✗ case 3: *reinterpret_cast< double*>(_v) = _t->baseValue(); break;
4869 ✗ case 4: *reinterpret_cast< QCPBars**>(_v) = _t->barBelow(); break;
4870 ✗ case 5: *reinterpret_cast< QCPBars**>(_v) = _t->barAbove(); break;
4871 ✗ default: break;
4872 }
4873 ✗ } else if (_c == QMetaObject::WriteProperty) {
4874 ✗ auto *_t = static_cast<QCPBars *>(_o);
4875 (void)_t;
4876 ✗ void *_v = _a[0];
4877 ✗ switch (_id) {
4878 ✗ case 0: _t->setWidth(*reinterpret_cast< double*>(_v)); break;
4879 ✗ case 1: _t->setWidthType(*reinterpret_cast< WidthType*>(_v)); break;
4880 ✗ case 2: _t->setBarsGroup(*reinterpret_cast< QCPBarsGroup**>(_v)); break;
4881 ✗ case 3: _t->setBaseValue(*reinterpret_cast< double*>(_v)); break;
4882 ✗ default: break;
4883 }
4884 } else if (_c == QMetaObject::ResetProperty) {
4885 }
4886 #endif // QT_NO_PROPERTIES
4887 (void)_o;
4888 }
4889
4890 QT_INIT_METAOBJECT const QMetaObject QCPBars::staticMetaObject = { {
4891 QMetaObject::SuperData::link<QCPAbstractPlottable::staticMetaObject>(),
4892 qt_meta_stringdata_QCPBars.data,
4893 qt_meta_data_QCPBars,
4894 qt_static_metacall,
4895 nullptr,
4896 nullptr
4897 } };
4898
4899
4900 ✗ const QMetaObject *QCPBars::metaObject() const
4901 {
4902 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
4903 }
4904
4905 ✗ void *QCPBars::qt_metacast(const char *_clname)
4906 {
4907 ✗ if (!_clname) return nullptr;
4908 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPBars.stringdata0))
4909 ✗ return static_cast<void*>(this);
4910 ✗ return QCPAbstractPlottable::qt_metacast(_clname);
4911 }
4912
4913 ✗ int QCPBars::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
4914 {
4915 ✗ _id = QCPAbstractPlottable::qt_metacall(_c, _id, _a);
4916 ✗ if (_id < 0)
4917 ✗ return _id;
4918
4919 #ifndef QT_NO_PROPERTIES
4920 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
4921 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
4922 ✗ qt_static_metacall(this, _c, _id, _a);
4923 ✗ _id -= 6;
4924 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
4925 ✗ _id -= 6;
4926 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
4927 ✗ _id -= 6;
4928 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
4929 ✗ _id -= 6;
4930 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
4931 ✗ _id -= 6;
4932 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
4933 ✗ _id -= 6;
4934 }
4935 #endif // QT_NO_PROPERTIES
4936 ✗ return _id;
4937 }
4938 struct qt_meta_stringdata_QCPStatisticalBox_t {
4939 QByteArrayData data[16];
4940 char stringdata0[181];
4941 };
4942 #define QT_MOC_LITERAL(idx, ofs, len) \
4943 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
4944 qptrdiff(offsetof(qt_meta_stringdata_QCPStatisticalBox_t, stringdata0) + ofs \
4945 - idx * sizeof(QByteArrayData)) \
4946 )
4947 static const qt_meta_stringdata_QCPStatisticalBox_t qt_meta_stringdata_QCPStatisticalBox = {
4948 {
4949 QT_MOC_LITERAL(0, 0, 17), // "QCPStatisticalBox"
4950 QT_MOC_LITERAL(1, 18, 3), // "key"
4951 QT_MOC_LITERAL(2, 22, 7), // "minimum"
4952 QT_MOC_LITERAL(3, 30, 13), // "lowerQuartile"
4953 QT_MOC_LITERAL(4, 44, 6), // "median"
4954 QT_MOC_LITERAL(5, 51, 13), // "upperQuartile"
4955 QT_MOC_LITERAL(6, 65, 7), // "maximum"
4956 QT_MOC_LITERAL(7, 73, 8), // "outliers"
4957 QT_MOC_LITERAL(8, 82, 15), // "QVector<double>"
4958 QT_MOC_LITERAL(9, 98, 5), // "width"
4959 QT_MOC_LITERAL(10, 104, 12), // "whiskerWidth"
4960 QT_MOC_LITERAL(11, 117, 10), // "whiskerPen"
4961 QT_MOC_LITERAL(12, 128, 13), // "whiskerBarPen"
4962 QT_MOC_LITERAL(13, 142, 9), // "medianPen"
4963 QT_MOC_LITERAL(14, 152, 12), // "outlierStyle"
4964 QT_MOC_LITERAL(15, 165, 15) // "QCPScatterStyle"
4965
4966 },
4967 "QCPStatisticalBox\0key\0minimum\0"
4968 "lowerQuartile\0median\0upperQuartile\0"
4969 "maximum\0outliers\0QVector<double>\0width\0"
4970 "whiskerWidth\0whiskerPen\0whiskerBarPen\0"
4971 "medianPen\0outlierStyle\0QCPScatterStyle"
4972 };
4973 #undef QT_MOC_LITERAL
4974
4975 static const uint qt_meta_data_QCPStatisticalBox[] = {
4976
4977 // content:
4978 8, // revision
4979 0, // classname
4980 0, 0, // classinfo
4981 0, 0, // methods
4982 13, 14, // properties
4983 0, 0, // enums/sets
4984 0, 0, // constructors
4985 0, // flags
4986 0, // signalCount
4987
4988 // properties: name, type, flags
4989 1, QMetaType::Double, 0x00095103,
4990 2, QMetaType::Double, 0x00095103,
4991 3, QMetaType::Double, 0x00095103,
4992 4, QMetaType::Double, 0x00095103,
4993 5, QMetaType::Double, 0x00095103,
4994 6, QMetaType::Double, 0x00095103,
4995 7, 0x80000000 | 8, 0x0009510b,
4996 9, QMetaType::Double, 0x00095103,
4997 10, QMetaType::Double, 0x00095103,
4998 11, QMetaType::QPen, 0x00095103,
4999 12, QMetaType::QPen, 0x00095103,
5000 13, QMetaType::QPen, 0x00095103,
5001 14, 0x80000000 | 15, 0x0009510b,
5002
5003 0 // eod
5004 };
5005
5006 ✗ void QCPStatisticalBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
5007 {
5008 ✗ if (_c == QMetaObject::RegisterPropertyMetaType) {
5009 ✗ switch (_id) {
5010 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
5011 ✗ case 6:
5012 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QVector<double> >(); break;
5013 }
5014 }
5015
5016 #ifndef QT_NO_PROPERTIES
5017 ✗ else if (_c == QMetaObject::ReadProperty) {
5018 ✗ auto *_t = static_cast<QCPStatisticalBox *>(_o);
5019 (void)_t;
5020 ✗ void *_v = _a[0];
5021 ✗ switch (_id) {
5022 ✗ case 0: *reinterpret_cast< double*>(_v) = _t->key(); break;
5023 ✗ case 1: *reinterpret_cast< double*>(_v) = _t->minimum(); break;
5024 ✗ case 2: *reinterpret_cast< double*>(_v) = _t->lowerQuartile(); break;
5025 ✗ case 3: *reinterpret_cast< double*>(_v) = _t->median(); break;
5026 ✗ case 4: *reinterpret_cast< double*>(_v) = _t->upperQuartile(); break;
5027 ✗ case 5: *reinterpret_cast< double*>(_v) = _t->maximum(); break;
5028 ✗ case 6: *reinterpret_cast< QVector<double>*>(_v) = _t->outliers(); break;
5029 ✗ case 7: *reinterpret_cast< double*>(_v) = _t->width(); break;
5030 ✗ case 8: *reinterpret_cast< double*>(_v) = _t->whiskerWidth(); break;
5031 ✗ case 9: *reinterpret_cast< QPen*>(_v) = _t->whiskerPen(); break;
5032 ✗ case 10: *reinterpret_cast< QPen*>(_v) = _t->whiskerBarPen(); break;
5033 ✗ case 11: *reinterpret_cast< QPen*>(_v) = _t->medianPen(); break;
5034 ✗ case 12: *reinterpret_cast< QCPScatterStyle*>(_v) = _t->outlierStyle(); break;
5035 ✗ default: break;
5036 }
5037 ✗ } else if (_c == QMetaObject::WriteProperty) {
5038 ✗ auto *_t = static_cast<QCPStatisticalBox *>(_o);
5039 (void)_t;
5040 ✗ void *_v = _a[0];
5041 ✗ switch (_id) {
5042 ✗ case 0: _t->setKey(*reinterpret_cast< double*>(_v)); break;
5043 ✗ case 1: _t->setMinimum(*reinterpret_cast< double*>(_v)); break;
5044 ✗ case 2: _t->setLowerQuartile(*reinterpret_cast< double*>(_v)); break;
5045 ✗ case 3: _t->setMedian(*reinterpret_cast< double*>(_v)); break;
5046 ✗ case 4: _t->setUpperQuartile(*reinterpret_cast< double*>(_v)); break;
5047 ✗ case 5: _t->setMaximum(*reinterpret_cast< double*>(_v)); break;
5048 ✗ case 6: _t->setOutliers(*reinterpret_cast< QVector<double>*>(_v)); break;
5049 ✗ case 7: _t->setWidth(*reinterpret_cast< double*>(_v)); break;
5050 ✗ case 8: _t->setWhiskerWidth(*reinterpret_cast< double*>(_v)); break;
5051 ✗ case 9: _t->setWhiskerPen(*reinterpret_cast< QPen*>(_v)); break;
5052 ✗ case 10: _t->setWhiskerBarPen(*reinterpret_cast< QPen*>(_v)); break;
5053 ✗ case 11: _t->setMedianPen(*reinterpret_cast< QPen*>(_v)); break;
5054 ✗ case 12: _t->setOutlierStyle(*reinterpret_cast< QCPScatterStyle*>(_v)); break;
5055 ✗ default: break;
5056 }
5057 } else if (_c == QMetaObject::ResetProperty) {
5058 }
5059 #endif // QT_NO_PROPERTIES
5060 (void)_o;
5061 }
5062
5063 QT_INIT_METAOBJECT const QMetaObject QCPStatisticalBox::staticMetaObject = { {
5064 QMetaObject::SuperData::link<QCPAbstractPlottable::staticMetaObject>(),
5065 qt_meta_stringdata_QCPStatisticalBox.data,
5066 qt_meta_data_QCPStatisticalBox,
5067 qt_static_metacall,
5068 nullptr,
5069 nullptr
5070 } };
5071
5072
5073 ✗ const QMetaObject *QCPStatisticalBox::metaObject() const
5074 {
5075 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
5076 }
5077
5078 ✗ void *QCPStatisticalBox::qt_metacast(const char *_clname)
5079 {
5080 ✗ if (!_clname) return nullptr;
5081 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPStatisticalBox.stringdata0))
5082 ✗ return static_cast<void*>(this);
5083 ✗ return QCPAbstractPlottable::qt_metacast(_clname);
5084 }
5085
5086 ✗ int QCPStatisticalBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
5087 {
5088 ✗ _id = QCPAbstractPlottable::qt_metacall(_c, _id, _a);
5089 ✗ if (_id < 0)
5090 ✗ return _id;
5091
5092 #ifndef QT_NO_PROPERTIES
5093 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
5094 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
5095 ✗ qt_static_metacall(this, _c, _id, _a);
5096 ✗ _id -= 13;
5097 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
5098 ✗ _id -= 13;
5099 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
5100 ✗ _id -= 13;
5101 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
5102 ✗ _id -= 13;
5103 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
5104 ✗ _id -= 13;
5105 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
5106 ✗ _id -= 13;
5107 }
5108 #endif // QT_NO_PROPERTIES
5109 ✗ return _id;
5110 }
5111 struct qt_meta_stringdata_QCPColorMap_t {
5112 QByteArrayData data[25];
5113 char stringdata0[334];
5114 };
5115 #define QT_MOC_LITERAL(idx, ofs, len) \
5116 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
5117 qptrdiff(offsetof(qt_meta_stringdata_QCPColorMap_t, stringdata0) + ofs \
5118 - idx * sizeof(QByteArrayData)) \
5119 )
5120 static const qt_meta_stringdata_QCPColorMap_t qt_meta_stringdata_QCPColorMap = {
5121 {
5122 QT_MOC_LITERAL(0, 0, 11), // "QCPColorMap"
5123 QT_MOC_LITERAL(1, 12, 16), // "dataRangeChanged"
5124 QT_MOC_LITERAL(2, 29, 0), // ""
5125 QT_MOC_LITERAL(3, 30, 8), // "QCPRange"
5126 QT_MOC_LITERAL(4, 39, 8), // "newRange"
5127 QT_MOC_LITERAL(5, 48, 20), // "dataScaleTypeChanged"
5128 QT_MOC_LITERAL(6, 69, 18), // "QCPAxis::ScaleType"
5129 QT_MOC_LITERAL(7, 88, 9), // "scaleType"
5130 QT_MOC_LITERAL(8, 98, 15), // "gradientChanged"
5131 QT_MOC_LITERAL(9, 114, 16), // "QCPColorGradient"
5132 QT_MOC_LITERAL(10, 131, 11), // "newGradient"
5133 QT_MOC_LITERAL(11, 143, 12), // "setDataRange"
5134 QT_MOC_LITERAL(12, 156, 9), // "dataRange"
5135 QT_MOC_LITERAL(13, 166, 16), // "setDataScaleType"
5136 QT_MOC_LITERAL(14, 183, 11), // "setGradient"
5137 QT_MOC_LITERAL(15, 195, 8), // "gradient"
5138 QT_MOC_LITERAL(16, 204, 16), // "updateLegendIcon"
5139 QT_MOC_LITERAL(17, 221, 22), // "Qt::TransformationMode"
5140 QT_MOC_LITERAL(18, 244, 13), // "transformMode"
5141 QT_MOC_LITERAL(19, 258, 9), // "thumbSize"
5142 QT_MOC_LITERAL(20, 268, 13), // "dataScaleType"
5143 QT_MOC_LITERAL(21, 282, 11), // "interpolate"
5144 QT_MOC_LITERAL(22, 294, 13), // "tightBoundary"
5145 QT_MOC_LITERAL(23, 308, 10), // "colorScale"
5146 QT_MOC_LITERAL(24, 319, 14) // "QCPColorScale*"
5147
5148 },
5149 "QCPColorMap\0dataRangeChanged\0\0QCPRange\0"
5150 "newRange\0dataScaleTypeChanged\0"
5151 "QCPAxis::ScaleType\0scaleType\0"
5152 "gradientChanged\0QCPColorGradient\0"
5153 "newGradient\0setDataRange\0dataRange\0"
5154 "setDataScaleType\0setGradient\0gradient\0"
5155 "updateLegendIcon\0Qt::TransformationMode\0"
5156 "transformMode\0thumbSize\0dataScaleType\0"
5157 "interpolate\0tightBoundary\0colorScale\0"
5158 "QCPColorScale*"
5159 };
5160 #undef QT_MOC_LITERAL
5161
5162 static const uint qt_meta_data_QCPColorMap[] = {
5163
5164 // content:
5165 8, // revision
5166 0, // classname
5167 0, 0, // classinfo
5168 9, 14, // methods
5169 6, 86, // properties
5170 0, 0, // enums/sets
5171 0, 0, // constructors
5172 0, // flags
5173 3, // signalCount
5174
5175 // signals: name, argc, parameters, tag, flags
5176 1, 1, 59, 2, 0x06 /* Public */,
5177 5, 1, 62, 2, 0x06 /* Public */,
5178 8, 1, 65, 2, 0x06 /* Public */,
5179
5180 // slots: name, argc, parameters, tag, flags
5181 11, 1, 68, 2, 0x0a /* Public */,
5182 13, 1, 71, 2, 0x0a /* Public */,
5183 14, 1, 74, 2, 0x0a /* Public */,
5184 16, 2, 77, 2, 0x0a /* Public */,
5185 16, 1, 82, 2, 0x2a /* Public | MethodCloned */,
5186 16, 0, 85, 2, 0x2a /* Public | MethodCloned */,
5187
5188 // signals: parameters
5189 QMetaType::Void, 0x80000000 | 3, 4,
5190 QMetaType::Void, 0x80000000 | 6, 7,
5191 QMetaType::Void, 0x80000000 | 9, 10,
5192
5193 // slots: parameters
5194 QMetaType::Void, 0x80000000 | 3, 12,
5195 QMetaType::Void, 0x80000000 | 6, 7,
5196 QMetaType::Void, 0x80000000 | 9, 15,
5197 QMetaType::Void, 0x80000000 | 17, QMetaType::QSize, 18, 19,
5198 QMetaType::Void, 0x80000000 | 17, 18,
5199 QMetaType::Void,
5200
5201 // properties: name, type, flags
5202 12, 0x80000000 | 3, 0x0049510b,
5203 20, 0x80000000 | 6, 0x0049510b,
5204 15, 0x80000000 | 9, 0x0049510b,
5205 21, QMetaType::Bool, 0x00095103,
5206 22, QMetaType::Bool, 0x00095103,
5207 23, 0x80000000 | 24, 0x0009510b,
5208
5209 // properties: notify_signal_id
5210 0,
5211 1,
5212 2,
5213 0,
5214 0,
5215 0,
5216
5217 0 // eod
5218 };
5219
5220 ✗ void QCPColorMap::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
5221 {
5222 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
5223 ✗ auto *_t = static_cast<QCPColorMap *>(_o);
5224 (void)_t;
5225 ✗ switch (_id) {
5226 ✗ case 0: _t->dataRangeChanged((*reinterpret_cast< QCPRange(*)>(_a[1]))); break;
5227 ✗ case 1: _t->dataScaleTypeChanged((*reinterpret_cast< QCPAxis::ScaleType(*)>(_a[1]))); break;
5228 ✗ case 2: _t->gradientChanged((*reinterpret_cast< QCPColorGradient(*)>(_a[1]))); break;
5229 ✗ case 3: _t->setDataRange((*reinterpret_cast< const QCPRange(*)>(_a[1]))); break;
5230 ✗ case 4: _t->setDataScaleType((*reinterpret_cast< QCPAxis::ScaleType(*)>(_a[1]))); break;
5231 ✗ case 5: _t->setGradient((*reinterpret_cast< const QCPColorGradient(*)>(_a[1]))); break;
5232 ✗ case 6: _t->updateLegendIcon((*reinterpret_cast< Qt::TransformationMode(*)>(_a[1])),(*reinterpret_cast< const QSize(*)>(_a[2]))); break;
5233 ✗ case 7: _t->updateLegendIcon((*reinterpret_cast< Qt::TransformationMode(*)>(_a[1]))); break;
5234 ✗ case 8: _t->updateLegendIcon(); break;
5235 ✗ default: ;
5236 }
5237 ✗ } else if (_c == QMetaObject::IndexOfMethod) {
5238 ✗ int *result = reinterpret_cast<int *>(_a[0]);
5239 {
5240 using _t = void (QCPColorMap::*)(QCPRange );
5241 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPColorMap::dataRangeChanged)) {
5242 ✗ *result = 0;
5243 ✗ return;
5244 }
5245 }
5246 {
5247 using _t = void (QCPColorMap::*)(QCPAxis::ScaleType );
5248 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPColorMap::dataScaleTypeChanged)) {
5249 ✗ *result = 1;
5250 ✗ return;
5251 }
5252 }
5253 {
5254 using _t = void (QCPColorMap::*)(QCPColorGradient );
5255 ✗ if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QCPColorMap::gradientChanged)) {
5256 ✗ *result = 2;
5257 ✗ return;
5258 }
5259 }
5260 ✗ } else if (_c == QMetaObject::RegisterPropertyMetaType) {
5261 ✗ switch (_id) {
5262 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
5263 ✗ case 5:
5264 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPColorScale* >(); break;
5265 }
5266 }
5267
5268 #ifndef QT_NO_PROPERTIES
5269 ✗ else if (_c == QMetaObject::ReadProperty) {
5270 ✗ auto *_t = static_cast<QCPColorMap *>(_o);
5271 (void)_t;
5272 ✗ void *_v = _a[0];
5273 ✗ switch (_id) {
5274 ✗ case 0: *reinterpret_cast< QCPRange*>(_v) = _t->dataRange(); break;
5275 ✗ case 1: *reinterpret_cast< QCPAxis::ScaleType*>(_v) = _t->dataScaleType(); break;
5276 ✗ case 2: *reinterpret_cast< QCPColorGradient*>(_v) = _t->gradient(); break;
5277 ✗ case 3: *reinterpret_cast< bool*>(_v) = _t->interpolate(); break;
5278 ✗ case 4: *reinterpret_cast< bool*>(_v) = _t->tightBoundary(); break;
5279 ✗ case 5: *reinterpret_cast< QCPColorScale**>(_v) = _t->colorScale(); break;
5280 ✗ default: break;
5281 }
5282 ✗ } else if (_c == QMetaObject::WriteProperty) {
5283 ✗ auto *_t = static_cast<QCPColorMap *>(_o);
5284 (void)_t;
5285 ✗ void *_v = _a[0];
5286 ✗ switch (_id) {
5287 ✗ case 0: _t->setDataRange(*reinterpret_cast< QCPRange*>(_v)); break;
5288 ✗ case 1: _t->setDataScaleType(*reinterpret_cast< QCPAxis::ScaleType*>(_v)); break;
5289 ✗ case 2: _t->setGradient(*reinterpret_cast< QCPColorGradient*>(_v)); break;
5290 ✗ case 3: _t->setInterpolate(*reinterpret_cast< bool*>(_v)); break;
5291 ✗ case 4: _t->setTightBoundary(*reinterpret_cast< bool*>(_v)); break;
5292 ✗ case 5: _t->setColorScale(*reinterpret_cast< QCPColorScale**>(_v)); break;
5293 ✗ default: break;
5294 }
5295 } else if (_c == QMetaObject::ResetProperty) {
5296 }
5297 #endif // QT_NO_PROPERTIES
5298 }
5299
5300 static const QMetaObject::SuperData qt_meta_extradata_QCPColorMap[] = {
5301 QMetaObject::SuperData::link<QCPAxis::staticMetaObject>(),
5302 nullptr
5303 };
5304
5305 QT_INIT_METAOBJECT const QMetaObject QCPColorMap::staticMetaObject = { {
5306 QMetaObject::SuperData::link<QCPAbstractPlottable::staticMetaObject>(),
5307 qt_meta_stringdata_QCPColorMap.data,
5308 qt_meta_data_QCPColorMap,
5309 qt_static_metacall,
5310 qt_meta_extradata_QCPColorMap,
5311 nullptr
5312 } };
5313
5314
5315 ✗ const QMetaObject *QCPColorMap::metaObject() const
5316 {
5317 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
5318 }
5319
5320 ✗ void *QCPColorMap::qt_metacast(const char *_clname)
5321 {
5322 ✗ if (!_clname) return nullptr;
5323 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPColorMap.stringdata0))
5324 ✗ return static_cast<void*>(this);
5325 ✗ return QCPAbstractPlottable::qt_metacast(_clname);
5326 }
5327
5328 ✗ int QCPColorMap::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
5329 {
5330 ✗ _id = QCPAbstractPlottable::qt_metacall(_c, _id, _a);
5331 ✗ if (_id < 0)
5332 ✗ return _id;
5333 ✗ if (_c == QMetaObject::InvokeMetaMethod) {
5334 ✗ if (_id < 9)
5335 ✗ qt_static_metacall(this, _c, _id, _a);
5336 ✗ _id -= 9;
5337 ✗ } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
5338 ✗ if (_id < 9)
5339 ✗ *reinterpret_cast<int*>(_a[0]) = -1;
5340 ✗ _id -= 9;
5341 }
5342 #ifndef QT_NO_PROPERTIES
5343 ✗ else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
5344 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
5345 ✗ qt_static_metacall(this, _c, _id, _a);
5346 ✗ _id -= 6;
5347 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
5348 ✗ _id -= 6;
5349 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
5350 ✗ _id -= 6;
5351 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
5352 ✗ _id -= 6;
5353 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
5354 ✗ _id -= 6;
5355 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
5356 ✗ _id -= 6;
5357 }
5358 #endif // QT_NO_PROPERTIES
5359 ✗ return _id;
5360 }
5361
5362 // SIGNAL 0
5363 ✗ void QCPColorMap::dataRangeChanged(QCPRange _t1)
5364 {
5365 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
5366 ✗ QMetaObject::activate(this, &staticMetaObject, 0, _a);
5367 }
5368
5369 // SIGNAL 1
5370 ✗ void QCPColorMap::dataScaleTypeChanged(QCPAxis::ScaleType _t1)
5371 {
5372 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
5373 ✗ QMetaObject::activate(this, &staticMetaObject, 1, _a);
5374 }
5375
5376 // SIGNAL 2
5377 ✗ void QCPColorMap::gradientChanged(QCPColorGradient _t1)
5378 {
5379 ✗ void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
5380 ✗ QMetaObject::activate(this, &staticMetaObject, 2, _a);
5381 }
5382 struct qt_meta_stringdata_QCPFinancial_t {
5383 QByteArrayData data[11];
5384 char stringdata0[125];
5385 };
5386 #define QT_MOC_LITERAL(idx, ofs, len) \
5387 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
5388 qptrdiff(offsetof(qt_meta_stringdata_QCPFinancial_t, stringdata0) + ofs \
5389 - idx * sizeof(QByteArrayData)) \
5390 )
5391 static const qt_meta_stringdata_QCPFinancial_t qt_meta_stringdata_QCPFinancial = {
5392 {
5393 QT_MOC_LITERAL(0, 0, 12), // "QCPFinancial"
5394 QT_MOC_LITERAL(1, 13, 10), // "chartStyle"
5395 QT_MOC_LITERAL(2, 24, 10), // "ChartStyle"
5396 QT_MOC_LITERAL(3, 35, 5), // "width"
5397 QT_MOC_LITERAL(4, 41, 10), // "twoColored"
5398 QT_MOC_LITERAL(5, 52, 13), // "brushPositive"
5399 QT_MOC_LITERAL(6, 66, 13), // "brushNegative"
5400 QT_MOC_LITERAL(7, 80, 11), // "penPositive"
5401 QT_MOC_LITERAL(8, 92, 11), // "penNegative"
5402 QT_MOC_LITERAL(9, 104, 6), // "csOhlc"
5403 QT_MOC_LITERAL(10, 111, 13) // "csCandlestick"
5404
5405 },
5406 "QCPFinancial\0chartStyle\0ChartStyle\0"
5407 "width\0twoColored\0brushPositive\0"
5408 "brushNegative\0penPositive\0penNegative\0"
5409 "csOhlc\0csCandlestick"
5410 };
5411 #undef QT_MOC_LITERAL
5412
5413 static const uint qt_meta_data_QCPFinancial[] = {
5414
5415 // content:
5416 8, // revision
5417 0, // classname
5418 0, 0, // classinfo
5419 0, 0, // methods
5420 7, 14, // properties
5421 1, 35, // enums/sets
5422 0, 0, // constructors
5423 0, // flags
5424 0, // signalCount
5425
5426 // properties: name, type, flags
5427 1, 0x80000000 | 2, 0x0009510b,
5428 3, QMetaType::Double, 0x00095103,
5429 4, QMetaType::Bool, 0x00095103,
5430 5, QMetaType::QBrush, 0x00095103,
5431 6, QMetaType::QBrush, 0x00095103,
5432 7, QMetaType::QPen, 0x00095103,
5433 8, QMetaType::QPen, 0x00095103,
5434
5435 // enums: name, alias, flags, count, data
5436 2, 2, 0x0, 2, 40,
5437
5438 // enum data: key, value
5439 9, uint(QCPFinancial::csOhlc),
5440 10, uint(QCPFinancial::csCandlestick),
5441
5442 0 // eod
5443 };
5444
5445 ✗ void QCPFinancial::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
5446 {
5447
5448 #ifndef QT_NO_PROPERTIES
5449 ✗ if (_c == QMetaObject::ReadProperty) {
5450 ✗ auto *_t = static_cast<QCPFinancial *>(_o);
5451 (void)_t;
5452 ✗ void *_v = _a[0];
5453 ✗ switch (_id) {
5454 ✗ case 0: *reinterpret_cast< ChartStyle*>(_v) = _t->chartStyle(); break;
5455 ✗ case 1: *reinterpret_cast< double*>(_v) = _t->width(); break;
5456 ✗ case 2: *reinterpret_cast< bool*>(_v) = _t->twoColored(); break;
5457 ✗ case 3: *reinterpret_cast< QBrush*>(_v) = _t->brushPositive(); break;
5458 ✗ case 4: *reinterpret_cast< QBrush*>(_v) = _t->brushNegative(); break;
5459 ✗ case 5: *reinterpret_cast< QPen*>(_v) = _t->penPositive(); break;
5460 ✗ case 6: *reinterpret_cast< QPen*>(_v) = _t->penNegative(); break;
5461 ✗ default: break;
5462 }
5463 ✗ } else if (_c == QMetaObject::WriteProperty) {
5464 ✗ auto *_t = static_cast<QCPFinancial *>(_o);
5465 (void)_t;
5466 ✗ void *_v = _a[0];
5467 ✗ switch (_id) {
5468 ✗ case 0: _t->setChartStyle(*reinterpret_cast< ChartStyle*>(_v)); break;
5469 ✗ case 1: _t->setWidth(*reinterpret_cast< double*>(_v)); break;
5470 ✗ case 2: _t->setTwoColored(*reinterpret_cast< bool*>(_v)); break;
5471 ✗ case 3: _t->setBrushPositive(*reinterpret_cast< QBrush*>(_v)); break;
5472 ✗ case 4: _t->setBrushNegative(*reinterpret_cast< QBrush*>(_v)); break;
5473 ✗ case 5: _t->setPenPositive(*reinterpret_cast< QPen*>(_v)); break;
5474 ✗ case 6: _t->setPenNegative(*reinterpret_cast< QPen*>(_v)); break;
5475 ✗ default: break;
5476 }
5477 } else if (_c == QMetaObject::ResetProperty) {
5478 }
5479 #endif // QT_NO_PROPERTIES
5480 (void)_o;
5481 (void)_id;
5482 (void)_c;
5483 (void)_a;
5484 }
5485
5486 QT_INIT_METAOBJECT const QMetaObject QCPFinancial::staticMetaObject = { {
5487 QMetaObject::SuperData::link<QCPAbstractPlottable::staticMetaObject>(),
5488 qt_meta_stringdata_QCPFinancial.data,
5489 qt_meta_data_QCPFinancial,
5490 qt_static_metacall,
5491 nullptr,
5492 nullptr
5493 } };
5494
5495
5496 ✗ const QMetaObject *QCPFinancial::metaObject() const
5497 {
5498 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
5499 }
5500
5501 ✗ void *QCPFinancial::qt_metacast(const char *_clname)
5502 {
5503 ✗ if (!_clname) return nullptr;
5504 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPFinancial.stringdata0))
5505 ✗ return static_cast<void*>(this);
5506 ✗ return QCPAbstractPlottable::qt_metacast(_clname);
5507 }
5508
5509 ✗ int QCPFinancial::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
5510 {
5511 ✗ _id = QCPAbstractPlottable::qt_metacall(_c, _id, _a);
5512 ✗ if (_id < 0)
5513 ✗ return _id;
5514
5515 #ifndef QT_NO_PROPERTIES
5516 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
5517 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
5518 ✗ qt_static_metacall(this, _c, _id, _a);
5519 ✗ _id -= 7;
5520 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
5521 ✗ _id -= 7;
5522 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
5523 ✗ _id -= 7;
5524 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
5525 ✗ _id -= 7;
5526 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
5527 ✗ _id -= 7;
5528 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
5529 ✗ _id -= 7;
5530 }
5531 #endif // QT_NO_PROPERTIES
5532 ✗ return _id;
5533 }
5534 struct qt_meta_stringdata_QCPItemStraightLine_t {
5535 QByteArrayData data[3];
5536 char stringdata0[36];
5537 };
5538 #define QT_MOC_LITERAL(idx, ofs, len) \
5539 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
5540 qptrdiff(offsetof(qt_meta_stringdata_QCPItemStraightLine_t, stringdata0) + ofs \
5541 - idx * sizeof(QByteArrayData)) \
5542 )
5543 static const qt_meta_stringdata_QCPItemStraightLine_t qt_meta_stringdata_QCPItemStraightLine = {
5544 {
5545 QT_MOC_LITERAL(0, 0, 19), // "QCPItemStraightLine"
5546 QT_MOC_LITERAL(1, 20, 3), // "pen"
5547 QT_MOC_LITERAL(2, 24, 11) // "selectedPen"
5548
5549 },
5550 "QCPItemStraightLine\0pen\0selectedPen"
5551 };
5552 #undef QT_MOC_LITERAL
5553
5554 static const uint qt_meta_data_QCPItemStraightLine[] = {
5555
5556 // content:
5557 8, // revision
5558 0, // classname
5559 0, 0, // classinfo
5560 0, 0, // methods
5561 2, 14, // properties
5562 0, 0, // enums/sets
5563 0, 0, // constructors
5564 0, // flags
5565 0, // signalCount
5566
5567 // properties: name, type, flags
5568 1, QMetaType::QPen, 0x00095103,
5569 2, QMetaType::QPen, 0x00095103,
5570
5571 0 // eod
5572 };
5573
5574 ✗ void QCPItemStraightLine::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
5575 {
5576
5577 #ifndef QT_NO_PROPERTIES
5578 ✗ if (_c == QMetaObject::ReadProperty) {
5579 ✗ auto *_t = static_cast<QCPItemStraightLine *>(_o);
5580 (void)_t;
5581 ✗ void *_v = _a[0];
5582 ✗ switch (_id) {
5583 ✗ case 0: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
5584 ✗ case 1: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
5585 ✗ default: break;
5586 }
5587 ✗ } else if (_c == QMetaObject::WriteProperty) {
5588 ✗ auto *_t = static_cast<QCPItemStraightLine *>(_o);
5589 (void)_t;
5590 ✗ void *_v = _a[0];
5591 ✗ switch (_id) {
5592 ✗ case 0: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
5593 ✗ case 1: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
5594 ✗ default: break;
5595 }
5596 } else if (_c == QMetaObject::ResetProperty) {
5597 }
5598 #endif // QT_NO_PROPERTIES
5599 (void)_o;
5600 (void)_id;
5601 (void)_c;
5602 (void)_a;
5603 }
5604
5605 QT_INIT_METAOBJECT const QMetaObject QCPItemStraightLine::staticMetaObject = { {
5606 QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
5607 qt_meta_stringdata_QCPItemStraightLine.data,
5608 qt_meta_data_QCPItemStraightLine,
5609 qt_static_metacall,
5610 nullptr,
5611 nullptr
5612 } };
5613
5614
5615 ✗ const QMetaObject *QCPItemStraightLine::metaObject() const
5616 {
5617 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
5618 }
5619
5620 ✗ void *QCPItemStraightLine::qt_metacast(const char *_clname)
5621 {
5622 ✗ if (!_clname) return nullptr;
5623 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPItemStraightLine.stringdata0))
5624 ✗ return static_cast<void*>(this);
5625 ✗ return QCPAbstractItem::qt_metacast(_clname);
5626 }
5627
5628 ✗ int QCPItemStraightLine::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
5629 {
5630 ✗ _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
5631 ✗ if (_id < 0)
5632 ✗ return _id;
5633
5634 #ifndef QT_NO_PROPERTIES
5635 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
5636 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
5637 ✗ qt_static_metacall(this, _c, _id, _a);
5638 ✗ _id -= 2;
5639 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
5640 ✗ _id -= 2;
5641 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
5642 ✗ _id -= 2;
5643 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
5644 ✗ _id -= 2;
5645 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
5646 ✗ _id -= 2;
5647 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
5648 ✗ _id -= 2;
5649 }
5650 #endif // QT_NO_PROPERTIES
5651 ✗ return _id;
5652 }
5653 struct qt_meta_stringdata_QCPItemLine_t {
5654 QByteArrayData data[6];
5655 char stringdata0[52];
5656 };
5657 #define QT_MOC_LITERAL(idx, ofs, len) \
5658 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
5659 qptrdiff(offsetof(qt_meta_stringdata_QCPItemLine_t, stringdata0) + ofs \
5660 - idx * sizeof(QByteArrayData)) \
5661 )
5662 static const qt_meta_stringdata_QCPItemLine_t qt_meta_stringdata_QCPItemLine = {
5663 {
5664 QT_MOC_LITERAL(0, 0, 11), // "QCPItemLine"
5665 QT_MOC_LITERAL(1, 12, 3), // "pen"
5666 QT_MOC_LITERAL(2, 16, 11), // "selectedPen"
5667 QT_MOC_LITERAL(3, 28, 4), // "head"
5668 QT_MOC_LITERAL(4, 33, 13), // "QCPLineEnding"
5669 QT_MOC_LITERAL(5, 47, 4) // "tail"
5670
5671 },
5672 "QCPItemLine\0pen\0selectedPen\0head\0"
5673 "QCPLineEnding\0tail"
5674 };
5675 #undef QT_MOC_LITERAL
5676
5677 static const uint qt_meta_data_QCPItemLine[] = {
5678
5679 // content:
5680 8, // revision
5681 0, // classname
5682 0, 0, // classinfo
5683 0, 0, // methods
5684 4, 14, // properties
5685 0, 0, // enums/sets
5686 0, 0, // constructors
5687 0, // flags
5688 0, // signalCount
5689
5690 // properties: name, type, flags
5691 1, QMetaType::QPen, 0x00095103,
5692 2, QMetaType::QPen, 0x00095103,
5693 3, 0x80000000 | 4, 0x0009510b,
5694 5, 0x80000000 | 4, 0x0009510b,
5695
5696 0 // eod
5697 };
5698
5699 ✗ void QCPItemLine::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
5700 {
5701
5702 #ifndef QT_NO_PROPERTIES
5703 ✗ if (_c == QMetaObject::ReadProperty) {
5704 ✗ auto *_t = static_cast<QCPItemLine *>(_o);
5705 (void)_t;
5706 ✗ void *_v = _a[0];
5707 ✗ switch (_id) {
5708 ✗ case 0: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
5709 ✗ case 1: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
5710 ✗ case 2: *reinterpret_cast< QCPLineEnding*>(_v) = _t->head(); break;
5711 ✗ case 3: *reinterpret_cast< QCPLineEnding*>(_v) = _t->tail(); break;
5712 ✗ default: break;
5713 }
5714 ✗ } else if (_c == QMetaObject::WriteProperty) {
5715 ✗ auto *_t = static_cast<QCPItemLine *>(_o);
5716 (void)_t;
5717 ✗ void *_v = _a[0];
5718 ✗ switch (_id) {
5719 ✗ case 0: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
5720 ✗ case 1: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
5721 ✗ case 2: _t->setHead(*reinterpret_cast< QCPLineEnding*>(_v)); break;
5722 ✗ case 3: _t->setTail(*reinterpret_cast< QCPLineEnding*>(_v)); break;
5723 ✗ default: break;
5724 }
5725 } else if (_c == QMetaObject::ResetProperty) {
5726 }
5727 #endif // QT_NO_PROPERTIES
5728 (void)_o;
5729 (void)_id;
5730 (void)_c;
5731 (void)_a;
5732 }
5733
5734 QT_INIT_METAOBJECT const QMetaObject QCPItemLine::staticMetaObject = { {
5735 QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
5736 qt_meta_stringdata_QCPItemLine.data,
5737 qt_meta_data_QCPItemLine,
5738 qt_static_metacall,
5739 nullptr,
5740 nullptr
5741 } };
5742
5743
5744 ✗ const QMetaObject *QCPItemLine::metaObject() const
5745 {
5746 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
5747 }
5748
5749 ✗ void *QCPItemLine::qt_metacast(const char *_clname)
5750 {
5751 ✗ if (!_clname) return nullptr;
5752 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPItemLine.stringdata0))
5753 ✗ return static_cast<void*>(this);
5754 ✗ return QCPAbstractItem::qt_metacast(_clname);
5755 }
5756
5757 ✗ int QCPItemLine::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
5758 {
5759 ✗ _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
5760 ✗ if (_id < 0)
5761 ✗ return _id;
5762
5763 #ifndef QT_NO_PROPERTIES
5764 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
5765 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
5766 ✗ qt_static_metacall(this, _c, _id, _a);
5767 ✗ _id -= 4;
5768 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
5769 ✗ _id -= 4;
5770 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
5771 ✗ _id -= 4;
5772 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
5773 ✗ _id -= 4;
5774 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
5775 ✗ _id -= 4;
5776 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
5777 ✗ _id -= 4;
5778 }
5779 #endif // QT_NO_PROPERTIES
5780 ✗ return _id;
5781 }
5782 struct qt_meta_stringdata_QCPItemCurve_t {
5783 QByteArrayData data[6];
5784 char stringdata0[53];
5785 };
5786 #define QT_MOC_LITERAL(idx, ofs, len) \
5787 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
5788 qptrdiff(offsetof(qt_meta_stringdata_QCPItemCurve_t, stringdata0) + ofs \
5789 - idx * sizeof(QByteArrayData)) \
5790 )
5791 static const qt_meta_stringdata_QCPItemCurve_t qt_meta_stringdata_QCPItemCurve = {
5792 {
5793 QT_MOC_LITERAL(0, 0, 12), // "QCPItemCurve"
5794 QT_MOC_LITERAL(1, 13, 3), // "pen"
5795 QT_MOC_LITERAL(2, 17, 11), // "selectedPen"
5796 QT_MOC_LITERAL(3, 29, 4), // "head"
5797 QT_MOC_LITERAL(4, 34, 13), // "QCPLineEnding"
5798 QT_MOC_LITERAL(5, 48, 4) // "tail"
5799
5800 },
5801 "QCPItemCurve\0pen\0selectedPen\0head\0"
5802 "QCPLineEnding\0tail"
5803 };
5804 #undef QT_MOC_LITERAL
5805
5806 static const uint qt_meta_data_QCPItemCurve[] = {
5807
5808 // content:
5809 8, // revision
5810 0, // classname
5811 0, 0, // classinfo
5812 0, 0, // methods
5813 4, 14, // properties
5814 0, 0, // enums/sets
5815 0, 0, // constructors
5816 0, // flags
5817 0, // signalCount
5818
5819 // properties: name, type, flags
5820 1, QMetaType::QPen, 0x00095103,
5821 2, QMetaType::QPen, 0x00095103,
5822 3, 0x80000000 | 4, 0x0009510b,
5823 5, 0x80000000 | 4, 0x0009510b,
5824
5825 0 // eod
5826 };
5827
5828 ✗ void QCPItemCurve::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
5829 {
5830
5831 #ifndef QT_NO_PROPERTIES
5832 ✗ if (_c == QMetaObject::ReadProperty) {
5833 ✗ auto *_t = static_cast<QCPItemCurve *>(_o);
5834 (void)_t;
5835 ✗ void *_v = _a[0];
5836 ✗ switch (_id) {
5837 ✗ case 0: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
5838 ✗ case 1: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
5839 ✗ case 2: *reinterpret_cast< QCPLineEnding*>(_v) = _t->head(); break;
5840 ✗ case 3: *reinterpret_cast< QCPLineEnding*>(_v) = _t->tail(); break;
5841 ✗ default: break;
5842 }
5843 ✗ } else if (_c == QMetaObject::WriteProperty) {
5844 ✗ auto *_t = static_cast<QCPItemCurve *>(_o);
5845 (void)_t;
5846 ✗ void *_v = _a[0];
5847 ✗ switch (_id) {
5848 ✗ case 0: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
5849 ✗ case 1: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
5850 ✗ case 2: _t->setHead(*reinterpret_cast< QCPLineEnding*>(_v)); break;
5851 ✗ case 3: _t->setTail(*reinterpret_cast< QCPLineEnding*>(_v)); break;
5852 ✗ default: break;
5853 }
5854 } else if (_c == QMetaObject::ResetProperty) {
5855 }
5856 #endif // QT_NO_PROPERTIES
5857 (void)_o;
5858 (void)_id;
5859 (void)_c;
5860 (void)_a;
5861 }
5862
5863 QT_INIT_METAOBJECT const QMetaObject QCPItemCurve::staticMetaObject = { {
5864 QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
5865 qt_meta_stringdata_QCPItemCurve.data,
5866 qt_meta_data_QCPItemCurve,
5867 qt_static_metacall,
5868 nullptr,
5869 nullptr
5870 } };
5871
5872
5873 ✗ const QMetaObject *QCPItemCurve::metaObject() const
5874 {
5875 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
5876 }
5877
5878 ✗ void *QCPItemCurve::qt_metacast(const char *_clname)
5879 {
5880 ✗ if (!_clname) return nullptr;
5881 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPItemCurve.stringdata0))
5882 ✗ return static_cast<void*>(this);
5883 ✗ return QCPAbstractItem::qt_metacast(_clname);
5884 }
5885
5886 ✗ int QCPItemCurve::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
5887 {
5888 ✗ _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
5889 ✗ if (_id < 0)
5890 ✗ return _id;
5891
5892 #ifndef QT_NO_PROPERTIES
5893 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
5894 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
5895 ✗ qt_static_metacall(this, _c, _id, _a);
5896 ✗ _id -= 4;
5897 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
5898 ✗ _id -= 4;
5899 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
5900 ✗ _id -= 4;
5901 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
5902 ✗ _id -= 4;
5903 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
5904 ✗ _id -= 4;
5905 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
5906 ✗ _id -= 4;
5907 }
5908 #endif // QT_NO_PROPERTIES
5909 ✗ return _id;
5910 }
5911 struct qt_meta_stringdata_QCPItemRect_t {
5912 QByteArrayData data[5];
5913 char stringdata0[48];
5914 };
5915 #define QT_MOC_LITERAL(idx, ofs, len) \
5916 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
5917 qptrdiff(offsetof(qt_meta_stringdata_QCPItemRect_t, stringdata0) + ofs \
5918 - idx * sizeof(QByteArrayData)) \
5919 )
5920 static const qt_meta_stringdata_QCPItemRect_t qt_meta_stringdata_QCPItemRect = {
5921 {
5922 QT_MOC_LITERAL(0, 0, 11), // "QCPItemRect"
5923 QT_MOC_LITERAL(1, 12, 3), // "pen"
5924 QT_MOC_LITERAL(2, 16, 11), // "selectedPen"
5925 QT_MOC_LITERAL(3, 28, 5), // "brush"
5926 QT_MOC_LITERAL(4, 34, 13) // "selectedBrush"
5927
5928 },
5929 "QCPItemRect\0pen\0selectedPen\0brush\0"
5930 "selectedBrush"
5931 };
5932 #undef QT_MOC_LITERAL
5933
5934 static const uint qt_meta_data_QCPItemRect[] = {
5935
5936 // content:
5937 8, // revision
5938 0, // classname
5939 0, 0, // classinfo
5940 0, 0, // methods
5941 4, 14, // properties
5942 0, 0, // enums/sets
5943 0, 0, // constructors
5944 0, // flags
5945 0, // signalCount
5946
5947 // properties: name, type, flags
5948 1, QMetaType::QPen, 0x00095103,
5949 2, QMetaType::QPen, 0x00095103,
5950 3, QMetaType::QBrush, 0x00095103,
5951 4, QMetaType::QBrush, 0x00095103,
5952
5953 0 // eod
5954 };
5955
5956 ✗ void QCPItemRect::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
5957 {
5958
5959 #ifndef QT_NO_PROPERTIES
5960 ✗ if (_c == QMetaObject::ReadProperty) {
5961 ✗ auto *_t = static_cast<QCPItemRect *>(_o);
5962 (void)_t;
5963 ✗ void *_v = _a[0];
5964 ✗ switch (_id) {
5965 ✗ case 0: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
5966 ✗ case 1: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
5967 ✗ case 2: *reinterpret_cast< QBrush*>(_v) = _t->brush(); break;
5968 ✗ case 3: *reinterpret_cast< QBrush*>(_v) = _t->selectedBrush(); break;
5969 ✗ default: break;
5970 }
5971 ✗ } else if (_c == QMetaObject::WriteProperty) {
5972 ✗ auto *_t = static_cast<QCPItemRect *>(_o);
5973 (void)_t;
5974 ✗ void *_v = _a[0];
5975 ✗ switch (_id) {
5976 ✗ case 0: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
5977 ✗ case 1: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
5978 ✗ case 2: _t->setBrush(*reinterpret_cast< QBrush*>(_v)); break;
5979 ✗ case 3: _t->setSelectedBrush(*reinterpret_cast< QBrush*>(_v)); break;
5980 ✗ default: break;
5981 }
5982 } else if (_c == QMetaObject::ResetProperty) {
5983 }
5984 #endif // QT_NO_PROPERTIES
5985 (void)_o;
5986 (void)_id;
5987 (void)_c;
5988 (void)_a;
5989 }
5990
5991 QT_INIT_METAOBJECT const QMetaObject QCPItemRect::staticMetaObject = { {
5992 QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
5993 qt_meta_stringdata_QCPItemRect.data,
5994 qt_meta_data_QCPItemRect,
5995 qt_static_metacall,
5996 nullptr,
5997 nullptr
5998 } };
5999
6000
6001 ✗ const QMetaObject *QCPItemRect::metaObject() const
6002 {
6003 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
6004 }
6005
6006 ✗ void *QCPItemRect::qt_metacast(const char *_clname)
6007 {
6008 ✗ if (!_clname) return nullptr;
6009 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPItemRect.stringdata0))
6010 ✗ return static_cast<void*>(this);
6011 ✗ return QCPAbstractItem::qt_metacast(_clname);
6012 }
6013
6014 ✗ int QCPItemRect::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
6015 {
6016 ✗ _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
6017 ✗ if (_id < 0)
6018 ✗ return _id;
6019
6020 #ifndef QT_NO_PROPERTIES
6021 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
6022 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
6023 ✗ qt_static_metacall(this, _c, _id, _a);
6024 ✗ _id -= 4;
6025 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
6026 ✗ _id -= 4;
6027 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
6028 ✗ _id -= 4;
6029 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
6030 ✗ _id -= 4;
6031 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
6032 ✗ _id -= 4;
6033 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
6034 ✗ _id -= 4;
6035 }
6036 #endif // QT_NO_PROPERTIES
6037 ✗ return _id;
6038 }
6039 struct qt_meta_stringdata_QCPItemText_t {
6040 QByteArrayData data[16];
6041 char stringdata0[163];
6042 };
6043 #define QT_MOC_LITERAL(idx, ofs, len) \
6044 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
6045 qptrdiff(offsetof(qt_meta_stringdata_QCPItemText_t, stringdata0) + ofs \
6046 - idx * sizeof(QByteArrayData)) \
6047 )
6048 static const qt_meta_stringdata_QCPItemText_t qt_meta_stringdata_QCPItemText = {
6049 {
6050 QT_MOC_LITERAL(0, 0, 11), // "QCPItemText"
6051 QT_MOC_LITERAL(1, 12, 5), // "color"
6052 QT_MOC_LITERAL(2, 18, 13), // "selectedColor"
6053 QT_MOC_LITERAL(3, 32, 3), // "pen"
6054 QT_MOC_LITERAL(4, 36, 11), // "selectedPen"
6055 QT_MOC_LITERAL(5, 48, 5), // "brush"
6056 QT_MOC_LITERAL(6, 54, 13), // "selectedBrush"
6057 QT_MOC_LITERAL(7, 68, 4), // "font"
6058 QT_MOC_LITERAL(8, 73, 12), // "selectedFont"
6059 QT_MOC_LITERAL(9, 86, 4), // "text"
6060 QT_MOC_LITERAL(10, 91, 17), // "positionAlignment"
6061 QT_MOC_LITERAL(11, 109, 13), // "Qt::Alignment"
6062 QT_MOC_LITERAL(12, 123, 13), // "textAlignment"
6063 QT_MOC_LITERAL(13, 137, 8), // "rotation"
6064 QT_MOC_LITERAL(14, 146, 7), // "padding"
6065 QT_MOC_LITERAL(15, 154, 8) // "QMargins"
6066
6067 },
6068 "QCPItemText\0color\0selectedColor\0pen\0"
6069 "selectedPen\0brush\0selectedBrush\0font\0"
6070 "selectedFont\0text\0positionAlignment\0"
6071 "Qt::Alignment\0textAlignment\0rotation\0"
6072 "padding\0QMargins"
6073 };
6074 #undef QT_MOC_LITERAL
6075
6076 static const uint qt_meta_data_QCPItemText[] = {
6077
6078 // content:
6079 8, // revision
6080 0, // classname
6081 0, 0, // classinfo
6082 0, 0, // methods
6083 13, 14, // properties
6084 0, 0, // enums/sets
6085 0, 0, // constructors
6086 0, // flags
6087 0, // signalCount
6088
6089 // properties: name, type, flags
6090 1, QMetaType::QColor, 0x00095103,
6091 2, QMetaType::QColor, 0x00095103,
6092 3, QMetaType::QPen, 0x00095103,
6093 4, QMetaType::QPen, 0x00095103,
6094 5, QMetaType::QBrush, 0x00095103,
6095 6, QMetaType::QBrush, 0x00095103,
6096 7, QMetaType::QFont, 0x00095103,
6097 8, QMetaType::QFont, 0x00095103,
6098 9, QMetaType::QString, 0x00095103,
6099 10, 0x80000000 | 11, 0x0009510b,
6100 12, 0x80000000 | 11, 0x0009510b,
6101 13, QMetaType::Double, 0x00095103,
6102 14, 0x80000000 | 15, 0x0009510b,
6103
6104 0 // eod
6105 };
6106
6107 ✗ void QCPItemText::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
6108 {
6109
6110 #ifndef QT_NO_PROPERTIES
6111 ✗ if (_c == QMetaObject::ReadProperty) {
6112 ✗ auto *_t = static_cast<QCPItemText *>(_o);
6113 (void)_t;
6114 ✗ void *_v = _a[0];
6115 ✗ switch (_id) {
6116 ✗ case 0: *reinterpret_cast< QColor*>(_v) = _t->color(); break;
6117 ✗ case 1: *reinterpret_cast< QColor*>(_v) = _t->selectedColor(); break;
6118 ✗ case 2: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
6119 ✗ case 3: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
6120 ✗ case 4: *reinterpret_cast< QBrush*>(_v) = _t->brush(); break;
6121 ✗ case 5: *reinterpret_cast< QBrush*>(_v) = _t->selectedBrush(); break;
6122 ✗ case 6: *reinterpret_cast< QFont*>(_v) = _t->font(); break;
6123 ✗ case 7: *reinterpret_cast< QFont*>(_v) = _t->selectedFont(); break;
6124 ✗ case 8: *reinterpret_cast< QString*>(_v) = _t->text(); break;
6125 ✗ case 9: *reinterpret_cast< Qt::Alignment*>(_v) = _t->positionAlignment(); break;
6126 ✗ case 10: *reinterpret_cast< Qt::Alignment*>(_v) = _t->textAlignment(); break;
6127 ✗ case 11: *reinterpret_cast< double*>(_v) = _t->rotation(); break;
6128 ✗ case 12: *reinterpret_cast< QMargins*>(_v) = _t->padding(); break;
6129 ✗ default: break;
6130 }
6131 ✗ } else if (_c == QMetaObject::WriteProperty) {
6132 ✗ auto *_t = static_cast<QCPItemText *>(_o);
6133 (void)_t;
6134 ✗ void *_v = _a[0];
6135 ✗ switch (_id) {
6136 ✗ case 0: _t->setColor(*reinterpret_cast< QColor*>(_v)); break;
6137 ✗ case 1: _t->setSelectedColor(*reinterpret_cast< QColor*>(_v)); break;
6138 ✗ case 2: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
6139 ✗ case 3: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
6140 ✗ case 4: _t->setBrush(*reinterpret_cast< QBrush*>(_v)); break;
6141 ✗ case 5: _t->setSelectedBrush(*reinterpret_cast< QBrush*>(_v)); break;
6142 ✗ case 6: _t->setFont(*reinterpret_cast< QFont*>(_v)); break;
6143 ✗ case 7: _t->setSelectedFont(*reinterpret_cast< QFont*>(_v)); break;
6144 ✗ case 8: _t->setText(*reinterpret_cast< QString*>(_v)); break;
6145 ✗ case 9: _t->setPositionAlignment(*reinterpret_cast< Qt::Alignment*>(_v)); break;
6146 ✗ case 10: _t->setTextAlignment(*reinterpret_cast< Qt::Alignment*>(_v)); break;
6147 ✗ case 11: _t->setRotation(*reinterpret_cast< double*>(_v)); break;
6148 ✗ case 12: _t->setPadding(*reinterpret_cast< QMargins*>(_v)); break;
6149 ✗ default: break;
6150 }
6151 } else if (_c == QMetaObject::ResetProperty) {
6152 }
6153 #endif // QT_NO_PROPERTIES
6154 (void)_o;
6155 (void)_id;
6156 (void)_c;
6157 (void)_a;
6158 }
6159
6160 QT_INIT_METAOBJECT const QMetaObject QCPItemText::staticMetaObject = { {
6161 QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
6162 qt_meta_stringdata_QCPItemText.data,
6163 qt_meta_data_QCPItemText,
6164 qt_static_metacall,
6165 nullptr,
6166 nullptr
6167 } };
6168
6169
6170 ✗ const QMetaObject *QCPItemText::metaObject() const
6171 {
6172 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
6173 }
6174
6175 ✗ void *QCPItemText::qt_metacast(const char *_clname)
6176 {
6177 ✗ if (!_clname) return nullptr;
6178 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPItemText.stringdata0))
6179 ✗ return static_cast<void*>(this);
6180 ✗ return QCPAbstractItem::qt_metacast(_clname);
6181 }
6182
6183 ✗ int QCPItemText::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
6184 {
6185 ✗ _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
6186 ✗ if (_id < 0)
6187 ✗ return _id;
6188
6189 #ifndef QT_NO_PROPERTIES
6190 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
6191 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
6192 ✗ qt_static_metacall(this, _c, _id, _a);
6193 ✗ _id -= 13;
6194 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
6195 ✗ _id -= 13;
6196 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
6197 ✗ _id -= 13;
6198 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
6199 ✗ _id -= 13;
6200 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
6201 ✗ _id -= 13;
6202 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
6203 ✗ _id -= 13;
6204 }
6205 #endif // QT_NO_PROPERTIES
6206 ✗ return _id;
6207 }
6208 struct qt_meta_stringdata_QCPItemEllipse_t {
6209 QByteArrayData data[5];
6210 char stringdata0[51];
6211 };
6212 #define QT_MOC_LITERAL(idx, ofs, len) \
6213 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
6214 qptrdiff(offsetof(qt_meta_stringdata_QCPItemEllipse_t, stringdata0) + ofs \
6215 - idx * sizeof(QByteArrayData)) \
6216 )
6217 static const qt_meta_stringdata_QCPItemEllipse_t qt_meta_stringdata_QCPItemEllipse = {
6218 {
6219 QT_MOC_LITERAL(0, 0, 14), // "QCPItemEllipse"
6220 QT_MOC_LITERAL(1, 15, 3), // "pen"
6221 QT_MOC_LITERAL(2, 19, 11), // "selectedPen"
6222 QT_MOC_LITERAL(3, 31, 5), // "brush"
6223 QT_MOC_LITERAL(4, 37, 13) // "selectedBrush"
6224
6225 },
6226 "QCPItemEllipse\0pen\0selectedPen\0brush\0"
6227 "selectedBrush"
6228 };
6229 #undef QT_MOC_LITERAL
6230
6231 static const uint qt_meta_data_QCPItemEllipse[] = {
6232
6233 // content:
6234 8, // revision
6235 0, // classname
6236 0, 0, // classinfo
6237 0, 0, // methods
6238 4, 14, // properties
6239 0, 0, // enums/sets
6240 0, 0, // constructors
6241 0, // flags
6242 0, // signalCount
6243
6244 // properties: name, type, flags
6245 1, QMetaType::QPen, 0x00095103,
6246 2, QMetaType::QPen, 0x00095103,
6247 3, QMetaType::QBrush, 0x00095103,
6248 4, QMetaType::QBrush, 0x00095103,
6249
6250 0 // eod
6251 };
6252
6253 ✗ void QCPItemEllipse::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
6254 {
6255
6256 #ifndef QT_NO_PROPERTIES
6257 ✗ if (_c == QMetaObject::ReadProperty) {
6258 ✗ auto *_t = static_cast<QCPItemEllipse *>(_o);
6259 (void)_t;
6260 ✗ void *_v = _a[0];
6261 ✗ switch (_id) {
6262 ✗ case 0: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
6263 ✗ case 1: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
6264 ✗ case 2: *reinterpret_cast< QBrush*>(_v) = _t->brush(); break;
6265 ✗ case 3: *reinterpret_cast< QBrush*>(_v) = _t->selectedBrush(); break;
6266 ✗ default: break;
6267 }
6268 ✗ } else if (_c == QMetaObject::WriteProperty) {
6269 ✗ auto *_t = static_cast<QCPItemEllipse *>(_o);
6270 (void)_t;
6271 ✗ void *_v = _a[0];
6272 ✗ switch (_id) {
6273 ✗ case 0: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
6274 ✗ case 1: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
6275 ✗ case 2: _t->setBrush(*reinterpret_cast< QBrush*>(_v)); break;
6276 ✗ case 3: _t->setSelectedBrush(*reinterpret_cast< QBrush*>(_v)); break;
6277 ✗ default: break;
6278 }
6279 } else if (_c == QMetaObject::ResetProperty) {
6280 }
6281 #endif // QT_NO_PROPERTIES
6282 (void)_o;
6283 (void)_id;
6284 (void)_c;
6285 (void)_a;
6286 }
6287
6288 QT_INIT_METAOBJECT const QMetaObject QCPItemEllipse::staticMetaObject = { {
6289 QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
6290 qt_meta_stringdata_QCPItemEllipse.data,
6291 qt_meta_data_QCPItemEllipse,
6292 qt_static_metacall,
6293 nullptr,
6294 nullptr
6295 } };
6296
6297
6298 ✗ const QMetaObject *QCPItemEllipse::metaObject() const
6299 {
6300 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
6301 }
6302
6303 ✗ void *QCPItemEllipse::qt_metacast(const char *_clname)
6304 {
6305 ✗ if (!_clname) return nullptr;
6306 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPItemEllipse.stringdata0))
6307 ✗ return static_cast<void*>(this);
6308 ✗ return QCPAbstractItem::qt_metacast(_clname);
6309 }
6310
6311 ✗ int QCPItemEllipse::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
6312 {
6313 ✗ _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
6314 ✗ if (_id < 0)
6315 ✗ return _id;
6316
6317 #ifndef QT_NO_PROPERTIES
6318 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
6319 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
6320 ✗ qt_static_metacall(this, _c, _id, _a);
6321 ✗ _id -= 4;
6322 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
6323 ✗ _id -= 4;
6324 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
6325 ✗ _id -= 4;
6326 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
6327 ✗ _id -= 4;
6328 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
6329 ✗ _id -= 4;
6330 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
6331 ✗ _id -= 4;
6332 }
6333 #endif // QT_NO_PROPERTIES
6334 ✗ return _id;
6335 }
6336 struct qt_meta_stringdata_QCPItemPixmap_t {
6337 QByteArrayData data[9];
6338 char stringdata0[122];
6339 };
6340 #define QT_MOC_LITERAL(idx, ofs, len) \
6341 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
6342 qptrdiff(offsetof(qt_meta_stringdata_QCPItemPixmap_t, stringdata0) + ofs \
6343 - idx * sizeof(QByteArrayData)) \
6344 )
6345 static const qt_meta_stringdata_QCPItemPixmap_t qt_meta_stringdata_QCPItemPixmap = {
6346 {
6347 QT_MOC_LITERAL(0, 0, 13), // "QCPItemPixmap"
6348 QT_MOC_LITERAL(1, 14, 6), // "pixmap"
6349 QT_MOC_LITERAL(2, 21, 6), // "scaled"
6350 QT_MOC_LITERAL(3, 28, 15), // "aspectRatioMode"
6351 QT_MOC_LITERAL(4, 44, 19), // "Qt::AspectRatioMode"
6352 QT_MOC_LITERAL(5, 64, 18), // "transformationMode"
6353 QT_MOC_LITERAL(6, 83, 22), // "Qt::TransformationMode"
6354 QT_MOC_LITERAL(7, 106, 3), // "pen"
6355 QT_MOC_LITERAL(8, 110, 11) // "selectedPen"
6356
6357 },
6358 "QCPItemPixmap\0pixmap\0scaled\0aspectRatioMode\0"
6359 "Qt::AspectRatioMode\0transformationMode\0"
6360 "Qt::TransformationMode\0pen\0selectedPen"
6361 };
6362 #undef QT_MOC_LITERAL
6363
6364 static const uint qt_meta_data_QCPItemPixmap[] = {
6365
6366 // content:
6367 8, // revision
6368 0, // classname
6369 0, 0, // classinfo
6370 0, 0, // methods
6371 6, 14, // properties
6372 0, 0, // enums/sets
6373 0, 0, // constructors
6374 0, // flags
6375 0, // signalCount
6376
6377 // properties: name, type, flags
6378 1, QMetaType::QPixmap, 0x00095103,
6379 2, QMetaType::Bool, 0x00095103,
6380 3, 0x80000000 | 4, 0x00095009,
6381 5, 0x80000000 | 6, 0x00095009,
6382 7, QMetaType::QPen, 0x00095103,
6383 8, QMetaType::QPen, 0x00095103,
6384
6385 0 // eod
6386 };
6387
6388 ✗ void QCPItemPixmap::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
6389 {
6390
6391 #ifndef QT_NO_PROPERTIES
6392 ✗ if (_c == QMetaObject::ReadProperty) {
6393 ✗ auto *_t = static_cast<QCPItemPixmap *>(_o);
6394 (void)_t;
6395 ✗ void *_v = _a[0];
6396 ✗ switch (_id) {
6397 ✗ case 0: *reinterpret_cast< QPixmap*>(_v) = _t->pixmap(); break;
6398 ✗ case 1: *reinterpret_cast< bool*>(_v) = _t->scaled(); break;
6399 ✗ case 2: *reinterpret_cast< Qt::AspectRatioMode*>(_v) = _t->aspectRatioMode(); break;
6400 ✗ case 3: *reinterpret_cast< Qt::TransformationMode*>(_v) = _t->transformationMode(); break;
6401 ✗ case 4: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
6402 ✗ case 5: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
6403 ✗ default: break;
6404 }
6405 ✗ } else if (_c == QMetaObject::WriteProperty) {
6406 ✗ auto *_t = static_cast<QCPItemPixmap *>(_o);
6407 (void)_t;
6408 ✗ void *_v = _a[0];
6409 ✗ switch (_id) {
6410 ✗ case 0: _t->setPixmap(*reinterpret_cast< QPixmap*>(_v)); break;
6411 ✗ case 1: _t->setScaled(*reinterpret_cast< bool*>(_v)); break;
6412 ✗ case 4: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
6413 ✗ case 5: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
6414 ✗ default: break;
6415 }
6416 } else if (_c == QMetaObject::ResetProperty) {
6417 }
6418 #endif // QT_NO_PROPERTIES
6419 (void)_o;
6420 (void)_id;
6421 (void)_c;
6422 (void)_a;
6423 }
6424
6425 QT_INIT_METAOBJECT const QMetaObject QCPItemPixmap::staticMetaObject = { {
6426 QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
6427 qt_meta_stringdata_QCPItemPixmap.data,
6428 qt_meta_data_QCPItemPixmap,
6429 qt_static_metacall,
6430 nullptr,
6431 nullptr
6432 } };
6433
6434
6435 ✗ const QMetaObject *QCPItemPixmap::metaObject() const
6436 {
6437 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
6438 }
6439
6440 ✗ void *QCPItemPixmap::qt_metacast(const char *_clname)
6441 {
6442 ✗ if (!_clname) return nullptr;
6443 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPItemPixmap.stringdata0))
6444 ✗ return static_cast<void*>(this);
6445 ✗ return QCPAbstractItem::qt_metacast(_clname);
6446 }
6447
6448 ✗ int QCPItemPixmap::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
6449 {
6450 ✗ _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
6451 ✗ if (_id < 0)
6452 ✗ return _id;
6453
6454 #ifndef QT_NO_PROPERTIES
6455 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
6456 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
6457 ✗ qt_static_metacall(this, _c, _id, _a);
6458 ✗ _id -= 6;
6459 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
6460 ✗ _id -= 6;
6461 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
6462 ✗ _id -= 6;
6463 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
6464 ✗ _id -= 6;
6465 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
6466 ✗ _id -= 6;
6467 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
6468 ✗ _id -= 6;
6469 }
6470 #endif // QT_NO_PROPERTIES
6471 ✗ return _id;
6472 }
6473 struct qt_meta_stringdata_QCPItemTracer_t {
6474 QByteArrayData data[17];
6475 char stringdata0[156];
6476 };
6477 #define QT_MOC_LITERAL(idx, ofs, len) \
6478 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
6479 qptrdiff(offsetof(qt_meta_stringdata_QCPItemTracer_t, stringdata0) + ofs \
6480 - idx * sizeof(QByteArrayData)) \
6481 )
6482 static const qt_meta_stringdata_QCPItemTracer_t qt_meta_stringdata_QCPItemTracer = {
6483 {
6484 QT_MOC_LITERAL(0, 0, 13), // "QCPItemTracer"
6485 QT_MOC_LITERAL(1, 14, 3), // "pen"
6486 QT_MOC_LITERAL(2, 18, 11), // "selectedPen"
6487 QT_MOC_LITERAL(3, 30, 5), // "brush"
6488 QT_MOC_LITERAL(4, 36, 13), // "selectedBrush"
6489 QT_MOC_LITERAL(5, 50, 4), // "size"
6490 QT_MOC_LITERAL(6, 55, 5), // "style"
6491 QT_MOC_LITERAL(7, 61, 11), // "TracerStyle"
6492 QT_MOC_LITERAL(8, 73, 5), // "graph"
6493 QT_MOC_LITERAL(9, 79, 9), // "QCPGraph*"
6494 QT_MOC_LITERAL(10, 89, 8), // "graphKey"
6495 QT_MOC_LITERAL(11, 98, 13), // "interpolating"
6496 QT_MOC_LITERAL(12, 112, 6), // "tsNone"
6497 QT_MOC_LITERAL(13, 119, 6), // "tsPlus"
6498 QT_MOC_LITERAL(14, 126, 11), // "tsCrosshair"
6499 QT_MOC_LITERAL(15, 138, 8), // "tsCircle"
6500 QT_MOC_LITERAL(16, 147, 8) // "tsSquare"
6501
6502 },
6503 "QCPItemTracer\0pen\0selectedPen\0brush\0"
6504 "selectedBrush\0size\0style\0TracerStyle\0"
6505 "graph\0QCPGraph*\0graphKey\0interpolating\0"
6506 "tsNone\0tsPlus\0tsCrosshair\0tsCircle\0"
6507 "tsSquare"
6508 };
6509 #undef QT_MOC_LITERAL
6510
6511 static const uint qt_meta_data_QCPItemTracer[] = {
6512
6513 // content:
6514 8, // revision
6515 0, // classname
6516 0, 0, // classinfo
6517 0, 0, // methods
6518 9, 14, // properties
6519 1, 41, // enums/sets
6520 0, 0, // constructors
6521 0, // flags
6522 0, // signalCount
6523
6524 // properties: name, type, flags
6525 1, QMetaType::QPen, 0x00095103,
6526 2, QMetaType::QPen, 0x00095103,
6527 3, QMetaType::QBrush, 0x00095103,
6528 4, QMetaType::QBrush, 0x00095103,
6529 5, QMetaType::Double, 0x00095103,
6530 6, 0x80000000 | 7, 0x0009510b,
6531 8, 0x80000000 | 9, 0x0009510b,
6532 10, QMetaType::Double, 0x00095103,
6533 11, QMetaType::Bool, 0x00095103,
6534
6535 // enums: name, alias, flags, count, data
6536 7, 7, 0x0, 5, 46,
6537
6538 // enum data: key, value
6539 12, uint(QCPItemTracer::tsNone),
6540 13, uint(QCPItemTracer::tsPlus),
6541 14, uint(QCPItemTracer::tsCrosshair),
6542 15, uint(QCPItemTracer::tsCircle),
6543 16, uint(QCPItemTracer::tsSquare),
6544
6545 0 // eod
6546 };
6547
6548 ✗ void QCPItemTracer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
6549 {
6550 ✗ if (_c == QMetaObject::RegisterPropertyMetaType) {
6551 ✗ switch (_id) {
6552 ✗ default: *reinterpret_cast<int*>(_a[0]) = -1; break;
6553 ✗ case 6:
6554 ✗ *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPGraph* >(); break;
6555 }
6556 }
6557
6558 #ifndef QT_NO_PROPERTIES
6559 ✗ else if (_c == QMetaObject::ReadProperty) {
6560 ✗ auto *_t = static_cast<QCPItemTracer *>(_o);
6561 (void)_t;
6562 ✗ void *_v = _a[0];
6563 ✗ switch (_id) {
6564 ✗ case 0: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
6565 ✗ case 1: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
6566 ✗ case 2: *reinterpret_cast< QBrush*>(_v) = _t->brush(); break;
6567 ✗ case 3: *reinterpret_cast< QBrush*>(_v) = _t->selectedBrush(); break;
6568 ✗ case 4: *reinterpret_cast< double*>(_v) = _t->size(); break;
6569 ✗ case 5: *reinterpret_cast< TracerStyle*>(_v) = _t->style(); break;
6570 ✗ case 6: *reinterpret_cast< QCPGraph**>(_v) = _t->graph(); break;
6571 ✗ case 7: *reinterpret_cast< double*>(_v) = _t->graphKey(); break;
6572 ✗ case 8: *reinterpret_cast< bool*>(_v) = _t->interpolating(); break;
6573 ✗ default: break;
6574 }
6575 ✗ } else if (_c == QMetaObject::WriteProperty) {
6576 ✗ auto *_t = static_cast<QCPItemTracer *>(_o);
6577 (void)_t;
6578 ✗ void *_v = _a[0];
6579 ✗ switch (_id) {
6580 ✗ case 0: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
6581 ✗ case 1: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
6582 ✗ case 2: _t->setBrush(*reinterpret_cast< QBrush*>(_v)); break;
6583 ✗ case 3: _t->setSelectedBrush(*reinterpret_cast< QBrush*>(_v)); break;
6584 ✗ case 4: _t->setSize(*reinterpret_cast< double*>(_v)); break;
6585 ✗ case 5: _t->setStyle(*reinterpret_cast< TracerStyle*>(_v)); break;
6586 ✗ case 6: _t->setGraph(*reinterpret_cast< QCPGraph**>(_v)); break;
6587 ✗ case 7: _t->setGraphKey(*reinterpret_cast< double*>(_v)); break;
6588 ✗ case 8: _t->setInterpolating(*reinterpret_cast< bool*>(_v)); break;
6589 ✗ default: break;
6590 }
6591 } else if (_c == QMetaObject::ResetProperty) {
6592 }
6593 #endif // QT_NO_PROPERTIES
6594 (void)_o;
6595 }
6596
6597 QT_INIT_METAOBJECT const QMetaObject QCPItemTracer::staticMetaObject = { {
6598 QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
6599 qt_meta_stringdata_QCPItemTracer.data,
6600 qt_meta_data_QCPItemTracer,
6601 qt_static_metacall,
6602 nullptr,
6603 nullptr
6604 } };
6605
6606
6607 ✗ const QMetaObject *QCPItemTracer::metaObject() const
6608 {
6609 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
6610 }
6611
6612 ✗ void *QCPItemTracer::qt_metacast(const char *_clname)
6613 {
6614 ✗ if (!_clname) return nullptr;
6615 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPItemTracer.stringdata0))
6616 ✗ return static_cast<void*>(this);
6617 ✗ return QCPAbstractItem::qt_metacast(_clname);
6618 }
6619
6620 ✗ int QCPItemTracer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
6621 {
6622 ✗ _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
6623 ✗ if (_id < 0)
6624 ✗ return _id;
6625
6626 #ifndef QT_NO_PROPERTIES
6627 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
6628 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
6629 ✗ qt_static_metacall(this, _c, _id, _a);
6630 ✗ _id -= 9;
6631 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
6632 ✗ _id -= 9;
6633 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
6634 ✗ _id -= 9;
6635 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
6636 ✗ _id -= 9;
6637 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
6638 ✗ _id -= 9;
6639 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
6640 ✗ _id -= 9;
6641 }
6642 #endif // QT_NO_PROPERTIES
6643 ✗ return _id;
6644 }
6645 struct qt_meta_stringdata_QCPItemBracket_t {
6646 QByteArrayData data[6];
6647 char stringdata0[57];
6648 };
6649 #define QT_MOC_LITERAL(idx, ofs, len) \
6650 Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
6651 qptrdiff(offsetof(qt_meta_stringdata_QCPItemBracket_t, stringdata0) + ofs \
6652 - idx * sizeof(QByteArrayData)) \
6653 )
6654 static const qt_meta_stringdata_QCPItemBracket_t qt_meta_stringdata_QCPItemBracket = {
6655 {
6656 QT_MOC_LITERAL(0, 0, 14), // "QCPItemBracket"
6657 QT_MOC_LITERAL(1, 15, 3), // "pen"
6658 QT_MOC_LITERAL(2, 19, 11), // "selectedPen"
6659 QT_MOC_LITERAL(3, 31, 6), // "length"
6660 QT_MOC_LITERAL(4, 38, 5), // "style"
6661 QT_MOC_LITERAL(5, 44, 12) // "BracketStyle"
6662
6663 },
6664 "QCPItemBracket\0pen\0selectedPen\0length\0"
6665 "style\0BracketStyle"
6666 };
6667 #undef QT_MOC_LITERAL
6668
6669 static const uint qt_meta_data_QCPItemBracket[] = {
6670
6671 // content:
6672 8, // revision
6673 0, // classname
6674 0, 0, // classinfo
6675 0, 0, // methods
6676 4, 14, // properties
6677 0, 0, // enums/sets
6678 0, 0, // constructors
6679 0, // flags
6680 0, // signalCount
6681
6682 // properties: name, type, flags
6683 1, QMetaType::QPen, 0x00095103,
6684 2, QMetaType::QPen, 0x00095103,
6685 3, QMetaType::Double, 0x00095103,
6686 4, 0x80000000 | 5, 0x0009510b,
6687
6688 0 // eod
6689 };
6690
6691 ✗ void QCPItemBracket::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
6692 {
6693
6694 #ifndef QT_NO_PROPERTIES
6695 ✗ if (_c == QMetaObject::ReadProperty) {
6696 ✗ auto *_t = static_cast<QCPItemBracket *>(_o);
6697 (void)_t;
6698 ✗ void *_v = _a[0];
6699 ✗ switch (_id) {
6700 ✗ case 0: *reinterpret_cast< QPen*>(_v) = _t->pen(); break;
6701 ✗ case 1: *reinterpret_cast< QPen*>(_v) = _t->selectedPen(); break;
6702 ✗ case 2: *reinterpret_cast< double*>(_v) = _t->length(); break;
6703 ✗ case 3: *reinterpret_cast< BracketStyle*>(_v) = _t->style(); break;
6704 ✗ default: break;
6705 }
6706 ✗ } else if (_c == QMetaObject::WriteProperty) {
6707 ✗ auto *_t = static_cast<QCPItemBracket *>(_o);
6708 (void)_t;
6709 ✗ void *_v = _a[0];
6710 ✗ switch (_id) {
6711 ✗ case 0: _t->setPen(*reinterpret_cast< QPen*>(_v)); break;
6712 ✗ case 1: _t->setSelectedPen(*reinterpret_cast< QPen*>(_v)); break;
6713 ✗ case 2: _t->setLength(*reinterpret_cast< double*>(_v)); break;
6714 ✗ case 3: _t->setStyle(*reinterpret_cast< BracketStyle*>(_v)); break;
6715 ✗ default: break;
6716 }
6717 } else if (_c == QMetaObject::ResetProperty) {
6718 }
6719 #endif // QT_NO_PROPERTIES
6720 (void)_o;
6721 (void)_id;
6722 (void)_c;
6723 (void)_a;
6724 }
6725
6726 QT_INIT_METAOBJECT const QMetaObject QCPItemBracket::staticMetaObject = { {
6727 QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
6728 qt_meta_stringdata_QCPItemBracket.data,
6729 qt_meta_data_QCPItemBracket,
6730 qt_static_metacall,
6731 nullptr,
6732 nullptr
6733 } };
6734
6735
6736 ✗ const QMetaObject *QCPItemBracket::metaObject() const
6737 {
6738 ✗ return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
6739 }
6740
6741 ✗ void *QCPItemBracket::qt_metacast(const char *_clname)
6742 {
6743 ✗ if (!_clname) return nullptr;
6744 ✗ if (!strcmp(_clname, qt_meta_stringdata_QCPItemBracket.stringdata0))
6745 ✗ return static_cast<void*>(this);
6746 ✗ return QCPAbstractItem::qt_metacast(_clname);
6747 }
6748
6749 ✗ int QCPItemBracket::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
6750 {
6751 ✗ _id = QCPAbstractItem::qt_metacall(_c, _id, _a);
6752 ✗ if (_id < 0)
6753 ✗ return _id;
6754
6755 #ifndef QT_NO_PROPERTIES
6756 ✗ if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
6757 ✗ || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
6758 ✗ qt_static_metacall(this, _c, _id, _a);
6759 ✗ _id -= 4;
6760 ✗ } else if (_c == QMetaObject::QueryPropertyDesignable) {
6761 ✗ _id -= 4;
6762 ✗ } else if (_c == QMetaObject::QueryPropertyScriptable) {
6763 ✗ _id -= 4;
6764 ✗ } else if (_c == QMetaObject::QueryPropertyStored) {
6765 ✗ _id -= 4;
6766 ✗ } else if (_c == QMetaObject::QueryPropertyEditable) {
6767 ✗ _id -= 4;
6768 ✗ } else if (_c == QMetaObject::QueryPropertyUser) {
6769 ✗ _id -= 4;
6770 }
6771 #endif // QT_NO_PROPERTIES
6772 ✗ return _id;
6773 }
6774 QT_WARNING_POP
6775 QT_END_MOC_NAMESPACE
6776