Qt
Internal/Contributor docs for the Qt SDK. Note: These are NOT official API docs; those are found at https://doc.qt.io/
Loading...
Searching...
No Matches
qqml.h
Go to the documentation of this file.
1// Copyright (C) 2021 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3// Qt-Security score:significant
4
5#ifndef QQML_H
6#define QQML_H
7
8#include <QtQml/qqmlprivate.h>
9#include <QtQml/qjsvalue.h>
10#include <QtQml/qqmlregistration.h>
11
12#include <QtCore/qbytearray.h>
13#include <QtCore/qmetaobject.h>
14#include <QtCore/qmetasequence.h>
15#include <QtCore/qtyperevision.h>
16#if !defined(QT_LEAN_HEADERS) || QT_LEAN_HEADERS < 3
17#include <QtCore/qversionnumber.h>
18#endif
19
20#define QML_VERSION 0x020000
21#define QML_VERSION_STR "2.0"
22
23#define QML_DECLARE_TYPE(TYPE)
24 Q_DECLARE_METATYPE(TYPE*)
25 Q_DECLARE_METATYPE(QQmlListProperty<TYPE>)
26
27#define QML_DECLARE_TYPE_HASMETATYPE(TYPE)
28 Q_DECLARE_METATYPE(QQmlListProperty<TYPE>)
29
30#define QML_DECLARE_INTERFACE(INTERFACE)
31 QML_DECLARE_TYPE(INTERFACE)
32
33#define QML_DECLARE_INTERFACE_HASMETATYPE(INTERFACE)
34 QML_DECLARE_TYPE_HASMETATYPE(INTERFACE)
35
36enum { /* TYPEINFO flags */
37 QML_HAS_ATTACHED_PROPERTIES = 0x01
38};
39
40#define QML_DECLARE_TYPEINFO(TYPE, FLAGS) QT_BEGIN_NAMESPACE
41 template
42 <> class
43 QQmlTypeInfo<TYPE > \
44{public
45 :
46 enum {
47 hasAttachedProperties = (((FLAGS) & QML_HAS_ATTACHED_PROPERTIES) == QML_HAS_ATTACHED_PROPERTIES)
48 }; \
49};QT_END_NAMESPACE
50
51
52QT_BEGIN_NAMESPACE
53
54void Q_QML_EXPORT qmlClearTypeRegistrations();
55
56template<class T>
57QQmlCustomParser *qmlCreateCustomParser();
58
59template<typename T>
60int qmlRegisterAnonymousType(const char *uri, int versionMajor)
61{
62 QQmlPrivate::RegisterType type = {
63 QQmlPrivate::RegisterType::CurrentVersion,
64 QQmlPrivate::QmlMetaType<T>::self(),
65 QQmlPrivate::QmlMetaType<T>::list(),
66 0,
67 nullptr, nullptr,
68 QString(),
69 QQmlPrivate::ValueType<T, void>::create,
70
71 uri, QTypeRevision::fromVersion(versionMajor, 0), nullptr,
72 QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
73
74 QQmlPrivate::attachedPropertiesFunc<T>(),
75 QQmlPrivate::attachedPropertiesMetaObject<T>(),
76
77 QQmlPrivate::StaticCastSelector<T,QQmlParserStatus>::cast(),
78 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueSource>::cast(),
79 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueInterceptor>::cast(),
80
81 nullptr, nullptr,
82
83 nullptr,
84 QTypeRevision::zero(),
85 QQmlPrivate::StaticCastSelector<T,QQmlFinalizerHook>::cast(),
86 QQmlPrivate::ValueTypeCreationMethod::None,
87 };
88
89 return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
90}
91
92//! \internal
93template<typename T, int metaObjectRevisionMinor>
94int qmlRegisterAnonymousType(const char *uri, int versionMajor)
95{
96 QQmlPrivate::RegisterType type = {
97 QQmlPrivate::RegisterType::CurrentVersion,
98 QQmlPrivate::QmlMetaType<T>::self(),
99 QQmlPrivate::QmlMetaType<T>::list(),
100 0,
101 nullptr,
102 nullptr,
103 QString(),
104 QQmlPrivate::ValueType<T, void>::create,
105
106 uri,
107 QTypeRevision::fromVersion(versionMajor, 0),
108 nullptr,
109 QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
110
111 QQmlPrivate::attachedPropertiesFunc<T>(),
112 QQmlPrivate::attachedPropertiesMetaObject<T>(),
113
114 QQmlPrivate::StaticCastSelector<T, QQmlParserStatus>::cast(),
115 QQmlPrivate::StaticCastSelector<T, QQmlPropertyValueSource>::cast(),
116 QQmlPrivate::StaticCastSelector<T, QQmlPropertyValueInterceptor>::cast(),
117
118 nullptr,
119 nullptr,
120
121 nullptr,
122 QTypeRevision::fromMinorVersion(metaObjectRevisionMinor),
123 QQmlPrivate::StaticCastSelector<T, QQmlFinalizerHook>::cast(),
124 QQmlPrivate::ValueTypeCreationMethod::None,
125 };
126
127 return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
128}
129
130//! \internal
131template<typename T>
132void qmlRegisterAnonymousTypesAndRevisions(const char *uri, int versionMajor)
133{
134 // Anonymous types are not creatable, no need to warn about missing acceptable constructors.
135 QQmlPrivate::qmlRegisterTypeAndRevisions<T, void>(
136 uri, versionMajor, QQmlPrivate::StaticMetaObject<T>::staticMetaObject(), nullptr,
137 nullptr, true);
138}
139
140class QQmlTypeNotAvailable : public QObject
141{
142 Q_OBJECT
143 QML_NAMED_ELEMENT(TypeNotAvailable)
144 QML_ADDED_IN_VERSION(2, 15)
145 QML_UNCREATABLE("Type not available.")
146};
147
148int Q_QML_EXPORT qmlRegisterTypeNotAvailable(const char *uri, int versionMajor, int versionMinor,
149 const char *qmlName, const QString &message);
150
151template<typename T>
152int qmlRegisterUncreatableType(const char *uri, int versionMajor, int versionMinor, const char *qmlName, const QString& reason)
153{
154 QQmlPrivate::RegisterType type = {
155 QQmlPrivate::RegisterType::CurrentVersion,
156 QQmlPrivate::QmlMetaType<T>::self(),
157 QQmlPrivate::QmlMetaType<T>::list(),
158 0,
159 nullptr,
160 nullptr,
161 reason,
162 QQmlPrivate::ValueType<T, void>::create,
163
164 uri, QTypeRevision::fromVersion(versionMajor, versionMinor), qmlName,
165 QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
166
167 QQmlPrivate::attachedPropertiesFunc<T>(),
168 QQmlPrivate::attachedPropertiesMetaObject<T>(),
169
170 QQmlPrivate::StaticCastSelector<T,QQmlParserStatus>::cast(),
171 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueSource>::cast(),
172 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueInterceptor>::cast(),
173
174 nullptr, nullptr,
175
176 nullptr,
177 QTypeRevision::zero(),
178 QQmlPrivate::StaticCastSelector<T,QQmlFinalizerHook>::cast(),
179 QQmlPrivate::ValueTypeCreationMethod::None,
180 };
181
182 return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
183}
184
185template<typename T, int metaObjectRevision>
186int qmlRegisterUncreatableType(const char *uri, int versionMajor, int versionMinor, const char *qmlName, const QString& reason)
187{
188 QQmlPrivate::RegisterType type = {
189 QQmlPrivate::RegisterType::CurrentVersion,
190 QQmlPrivate::QmlMetaType<T>::self(),
191 QQmlPrivate::QmlMetaType<T>::list(),
192 0,
193 nullptr,
194 nullptr,
195 reason,
196 QQmlPrivate::ValueType<T, void>::create,
197
198 uri, QTypeRevision::fromVersion(versionMajor, versionMinor), qmlName,
199 QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
200
201 QQmlPrivate::attachedPropertiesFunc<T>(),
202 QQmlPrivate::attachedPropertiesMetaObject<T>(),
203
204 QQmlPrivate::StaticCastSelector<T,QQmlParserStatus>::cast(),
205 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueSource>::cast(),
206 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueInterceptor>::cast(),
207
208 nullptr, nullptr,
209
210 nullptr,
211 QTypeRevision::fromMinorVersion(metaObjectRevision),
212 QQmlPrivate::StaticCastSelector<T,QQmlFinalizerHook>::cast(),
213 QQmlPrivate::ValueTypeCreationMethod::None,
214 };
215
216 return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
217}
218
219template<typename T, typename E>
220int qmlRegisterExtendedUncreatableType(const char *uri, int versionMajor, int versionMinor, const char *qmlName, const QString& reason)
221{
222 QQmlAttachedPropertiesFunc attached = QQmlPrivate::attachedPropertiesFunc<E>();
223 const QMetaObject * attachedMetaObject = QQmlPrivate::attachedPropertiesMetaObject<E>();
224 if (!attached) {
225 attached = QQmlPrivate::attachedPropertiesFunc<T>();
226 attachedMetaObject = QQmlPrivate::attachedPropertiesMetaObject<T>();
227 }
228
229 QQmlPrivate::RegisterType type = {
230 QQmlPrivate::RegisterType::CurrentVersion,
231 QQmlPrivate::QmlMetaType<T>::self(),
232 QQmlPrivate::QmlMetaType<T>::list(),
233 0,
234 nullptr,
235 nullptr,
236 reason,
237 QQmlPrivate::ValueType<T, E>::create,
238
239 uri, QTypeRevision::fromVersion(versionMajor, versionMinor), qmlName,
240 QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
241
242 attached,
243 attachedMetaObject,
244
245 QQmlPrivate::StaticCastSelector<T,QQmlParserStatus>::cast(),
246 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueSource>::cast(),
247 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueInterceptor>::cast(),
248
249 QQmlPrivate::ExtendedType<E>::createParent, QQmlPrivate::ExtendedType<E>::staticMetaObject(),
250
251 nullptr,
252 QTypeRevision::zero(),
253 QQmlPrivate::StaticCastSelector<T,QQmlFinalizerHook>::cast(),
254 QQmlPrivate::ValueTypeCreationMethod::None,
255 };
256
257 return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
258}
259
260template<typename T, typename E, int metaObjectRevision>
261int qmlRegisterExtendedUncreatableType(const char *uri, int versionMajor, int versionMinor, const char *qmlName, const QString& reason)
262{
263 QQmlAttachedPropertiesFunc attached = QQmlPrivate::attachedPropertiesFunc<E>();
264 const QMetaObject * attachedMetaObject = QQmlPrivate::attachedPropertiesMetaObject<E>();
265 if (!attached) {
266 attached = QQmlPrivate::attachedPropertiesFunc<T>();
267 attachedMetaObject = QQmlPrivate::attachedPropertiesMetaObject<T>();
268 }
269
270 QQmlPrivate::RegisterType type = {
271 QQmlPrivate::RegisterType::CurrentVersion,
272 QQmlPrivate::QmlMetaType<T>::self(),
273 QQmlPrivate::QmlMetaType<T>::list(),
274 0,
275 nullptr,
276 nullptr,
277 reason,
278 QQmlPrivate::ValueType<T, E>::create,
279
280 uri, QTypeRevision::fromVersion(versionMajor, versionMinor), qmlName,
281 QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
282
283 attached,
284 attachedMetaObject,
285
286 QQmlPrivate::StaticCastSelector<T,QQmlParserStatus>::cast(),
287 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueSource>::cast(),
288 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueInterceptor>::cast(),
289
290 QQmlPrivate::ExtendedType<E>::createParent, QQmlPrivate::ExtendedType<E>::staticMetaObject(),
291
292 nullptr,
293 QTypeRevision::fromMinorVersion(metaObjectRevision),
294 QQmlPrivate::StaticCastSelector<T,QQmlFinalizerHook>::cast(),
295 QQmlPrivate::ValueTypeCreationMethod::None,
296 };
297
298 return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
299}
300
301Q_QML_EXPORT int qmlRegisterUncreatableMetaObject(const QMetaObject &staticMetaObject, const char *uri, int versionMajor, int versionMinor, const char *qmlName, const QString& reason);
302
303template<typename T>
304int qmlRegisterType(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
305{
306 static_assert(!std::is_abstract_v<T>,
307 "It is not possible to register an abstract type with qmlRegisterType. "
308 "Maybe you wanted qmlRegisterUncreatableType or qmlRegisterInterface?");
309
310 QQmlPrivate::RegisterType type = {
311 QQmlPrivate::RegisterType::CurrentVersion,
312 QQmlPrivate::QmlMetaType<T>::self(),
313 QQmlPrivate::QmlMetaType<T>::list(),
314 sizeof(T), QQmlPrivate::Constructors<T>::createInto, nullptr,
315 QString(),
316 QQmlPrivate::ValueType<T, void>::create,
317
318 uri, QTypeRevision::fromVersion(versionMajor, versionMinor), qmlName,
319 QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
320
321 QQmlPrivate::attachedPropertiesFunc<T>(),
322 QQmlPrivate::attachedPropertiesMetaObject<T>(),
323
324 QQmlPrivate::StaticCastSelector<T,QQmlParserStatus>::cast(),
325 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueSource>::cast(),
326 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueInterceptor>::cast(),
327
328 nullptr, nullptr,
329
330 nullptr,
331 QTypeRevision::zero(),
332 QQmlPrivate::StaticCastSelector<T,QQmlFinalizerHook>::cast(),
333 QQmlPrivate::ValueTypeCreationMethod::None,
334 };
335
336 return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
337}
338
339template<typename T, int metaObjectRevision>
340int qmlRegisterType(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
341{
342 static_assert(!std::is_abstract_v<T>,
343 "It is not possible to register an abstract type with qmlRegisterType. "
344 "Maybe you wanted qmlRegisterUncreatableType or qmlRegisterInterface?");
345
346 QQmlPrivate::RegisterType type = {
347 QQmlPrivate::RegisterType::CurrentVersion,
348 QQmlPrivate::QmlMetaType<T>::self(),
349 QQmlPrivate::QmlMetaType<T>::list(),
350 sizeof(T), QQmlPrivate::Constructors<T>::createInto, nullptr,
351 QString(),
352 QQmlPrivate::ValueType<T, void>::create,
353
354 uri, QTypeRevision::fromVersion(versionMajor, versionMinor), qmlName,
355 QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
356
357 QQmlPrivate::attachedPropertiesFunc<T>(),
358 QQmlPrivate::attachedPropertiesMetaObject<T>(),
359
360 QQmlPrivate::StaticCastSelector<T,QQmlParserStatus>::cast(),
361 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueSource>::cast(),
362 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueInterceptor>::cast(),
363
364 nullptr, nullptr,
365
366 nullptr,
367 QTypeRevision::fromMinorVersion(metaObjectRevision),
368 QQmlPrivate::StaticCastSelector<T,QQmlFinalizerHook>::cast(),
369 QQmlPrivate::ValueTypeCreationMethod::None,
370 };
371
372 return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
373}
374
375template<typename T, int metaObjectRevision>
376int qmlRegisterRevision(const char *uri, int versionMajor, int versionMinor)
377{
378 QQmlPrivate::RegisterType type = {
379 QQmlPrivate::RegisterType::CurrentVersion,
380 QQmlPrivate::QmlMetaType<T>::self(),
381 QQmlPrivate::QmlMetaType<T>::list(),
382 sizeof(T), QQmlPrivate::Constructors<T>::createInto, nullptr,
383 QString(),
384 QQmlPrivate::ValueType<T, void>::create,
385
386 uri, QTypeRevision::fromVersion(versionMajor, versionMinor), nullptr,
387 QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
388
389 QQmlPrivate::attachedPropertiesFunc<T>(),
390 QQmlPrivate::attachedPropertiesMetaObject<T>(),
391
392 QQmlPrivate::StaticCastSelector<T,QQmlParserStatus>::cast(),
393 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueSource>::cast(),
394 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueInterceptor>::cast(),
395
396 nullptr, nullptr,
397
398 nullptr,
399 QTypeRevision::fromMinorVersion(metaObjectRevision),
400 QQmlPrivate::StaticCastSelector<T,QQmlFinalizerHook>::cast(),
401 QQmlPrivate::ValueTypeCreationMethod::None,
402 };
403
404 return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
405}
406
407template<typename T, typename E>
408int qmlRegisterExtendedType(const char *uri, int versionMajor)
409{
410 static_assert(!std::is_abstract_v<T>,
411 "It is not possible to register an extension to an abstract type with qmlRegisterExtendedType.");
412
413 static_assert(!std::is_abstract_v<E>,
414 "It is not possible to register an abstract type with qmlRegisterExtendedType. "
415 "Maybe you wanted qmlRegisterExtendedUncreatableType?");
416
417 QQmlPrivate::RegisterType type = {
418 QQmlPrivate::RegisterType::CurrentVersion,
419 QQmlPrivate::QmlMetaType<T>::self(),
420 QQmlPrivate::QmlMetaType<T>::list(),
421 0,
422 nullptr,
423 nullptr,
424 QString(),
425 QQmlPrivate::ValueType<T, E>::create,
426
427 uri, QTypeRevision::fromVersion(versionMajor, 0), nullptr,
428 QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
429
430 QQmlPrivate::attachedPropertiesFunc<T>(),
431 QQmlPrivate::attachedPropertiesMetaObject<T>(),
432
433 QQmlPrivate::StaticCastSelector<T,QQmlParserStatus>::cast(),
434 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueSource>::cast(),
435 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueInterceptor>::cast(),
436
437 QQmlPrivate::ExtendedType<E>::createParent, QQmlPrivate::ExtendedType<E>::staticMetaObject(),
438
439 nullptr,
440 QTypeRevision::zero(),
441 QQmlPrivate::StaticCastSelector<T,QQmlFinalizerHook>::cast(),
442 QQmlPrivate::ValueTypeCreationMethod::None,
443 };
444
445 return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
446}
447
448template<typename T, typename E>
449int qmlRegisterExtendedType(const char *uri, int versionMajor, int versionMinor,
450 const char *qmlName)
451{
452 static_assert(!std::is_abstract_v<T>,
453 "It is not possible to register an extension to an abstract type with qmlRegisterExtendedType.");
454
455 static_assert(!std::is_abstract_v<E>,
456 "It is not possible to register an abstract type with qmlRegisterExtendedType. "
457 "Maybe you wanted qmlRegisterExtendedUncreatableType?");
458
459 QQmlAttachedPropertiesFunc attached = QQmlPrivate::attachedPropertiesFunc<E>();
460 const QMetaObject * attachedMetaObject = QQmlPrivate::attachedPropertiesMetaObject<E>();
461 if (!attached) {
462 attached = QQmlPrivate::attachedPropertiesFunc<T>();
463 attachedMetaObject = QQmlPrivate::attachedPropertiesMetaObject<T>();
464 }
465
466 QQmlPrivate::RegisterType type = {
467 QQmlPrivate::RegisterType::CurrentVersion,
468 QQmlPrivate::QmlMetaType<T>::self(),
469 QQmlPrivate::QmlMetaType<T>::list(),
470 sizeof(T), QQmlPrivate::Constructors<T>::createInto, nullptr,
471 QString(),
472 QQmlPrivate::ValueType<T, E>::create,
473
474 uri, QTypeRevision::fromVersion(versionMajor, versionMinor), qmlName,
475 QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
476
477 attached,
478 attachedMetaObject,
479
480 QQmlPrivate::StaticCastSelector<T,QQmlParserStatus>::cast(),
481 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueSource>::cast(),
482 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueInterceptor>::cast(),
483
484 QQmlPrivate::ExtendedType<E>::createParent, QQmlPrivate::ExtendedType<E>::staticMetaObject(),
485
486 nullptr,
487 QTypeRevision::zero(),
488 QQmlPrivate::StaticCastSelector<T,QQmlFinalizerHook>::cast(),
489 QQmlPrivate::ValueTypeCreationMethod::None,
490 };
491
492 return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
493}
494
495template<typename T>
496int qmlRegisterInterface(const char *uri, int versionMajor)
497{
498 QQmlPrivate::RegisterInterface qmlInterface = {
499 0,
500 // An interface is not a QObject itself but is typically casted to one.
501 // Therefore, we still want the pointer.
502 QMetaType::fromType<T *>(),
503 QMetaType::fromType<QQmlListProperty<T> >(),
504 qobject_interface_iid<T *>(),
505
506 uri,
507 QTypeRevision::fromVersion(versionMajor, 0)
508 };
509
510 return QQmlPrivate::qmlregister(QQmlPrivate::InterfaceRegistration, &qmlInterface);
511}
512
513template<typename T>
514int qmlRegisterCustomType(const char *uri, int versionMajor, int versionMinor,
515 const char *qmlName, QQmlCustomParser *parser)
516{
517 static_assert(!std::is_abstract_v<T>,
518 "It is not possible to register an abstract type with qmlRegisterCustomType. "
519 "Maybe you wanted qmlRegisterUncreatableType or qmlRegisterInterface?");
520
521 QQmlPrivate::RegisterType type = {
522 QQmlPrivate::RegisterType::CurrentVersion,
523 QQmlPrivate::QmlMetaType<T>::self(),
524 QQmlPrivate::QmlMetaType<T>::list(),
525 sizeof(T), QQmlPrivate::Constructors<T>::createInto, nullptr,
526 QString(),
527 QQmlPrivate::ValueType<T, void>::create,
528
529 uri, QTypeRevision::fromVersion(versionMajor, versionMinor), qmlName,
530 QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
531
532 QQmlPrivate::attachedPropertiesFunc<T>(),
533 QQmlPrivate::attachedPropertiesMetaObject<T>(),
534
535 QQmlPrivate::StaticCastSelector<T,QQmlParserStatus>::cast(),
536 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueSource>::cast(),
537 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueInterceptor>::cast(),
538
539 nullptr, nullptr,
540
541 parser,
542 QTypeRevision::zero(),
543 QQmlPrivate::StaticCastSelector<T,QQmlFinalizerHook>::cast(),
544 QQmlPrivate::ValueTypeCreationMethod::None,
545 };
546
547 return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
548}
549
550template<typename T, int metaObjectRevision>
551int qmlRegisterCustomType(const char *uri, int versionMajor, int versionMinor,
552 const char *qmlName, QQmlCustomParser *parser)
553{
554 static_assert(!std::is_abstract_v<T>,
555 "It is not possible to register an abstract type with qmlRegisterCustomType. "
556 "Maybe you wanted qmlRegisterUncreatableType or qmlRegisterInterface?");
557
558 QQmlPrivate::RegisterType type = {
559 QQmlPrivate::RegisterType::CurrentVersion,
560 QQmlPrivate::QmlMetaType<T>::self(),
561 QQmlPrivate::QmlMetaType<T>::list(),
562 sizeof(T), QQmlPrivate::Constructors<T>::createInto, nullptr,
563 QString(),
564 QQmlPrivate::ValueType<T, void>::create,
565
566 uri, QTypeRevision::fromVersion(versionMajor, versionMinor), qmlName,
567 QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
568
569 QQmlPrivate::attachedPropertiesFunc<T>(),
570 QQmlPrivate::attachedPropertiesMetaObject<T>(),
571
572 QQmlPrivate::StaticCastSelector<T,QQmlParserStatus>::cast(),
573 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueSource>::cast(),
574 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueInterceptor>::cast(),
575
576 nullptr, nullptr,
577
578 parser,
579 QTypeRevision::fromMinorVersion(metaObjectRevision),
580 QQmlPrivate::StaticCastSelector<T,QQmlFinalizerHook>::cast(),
581 QQmlPrivate::ValueTypeCreationMethod::None,
582 };
583
584 return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
585}
586
587template<typename T, typename E>
588int qmlRegisterCustomExtendedType(const char *uri, int versionMajor, int versionMinor,
589 const char *qmlName, QQmlCustomParser *parser)
590{
591 static_assert(!std::is_abstract_v<T>,
592 "It is not possible to register an extension to an abstract type with qmlRegisterCustomExtendedType.");
593
594 static_assert(!std::is_abstract_v<E>,
595 "It is not possible to register an abstract type with qmlRegisterCustomExtendedType.");
596
597 QQmlAttachedPropertiesFunc attached = QQmlPrivate::attachedPropertiesFunc<E>();
598 const QMetaObject * attachedMetaObject = QQmlPrivate::attachedPropertiesMetaObject<E>();
599 if (!attached) {
600 attached = QQmlPrivate::attachedPropertiesFunc<T>();
601 attachedMetaObject = QQmlPrivate::attachedPropertiesMetaObject<T>();
602 }
603
604 QQmlPrivate::RegisterType type = {
605 QQmlPrivate::RegisterType::CurrentVersion,
606 QQmlPrivate::QmlMetaType<T>::self(),
607 QQmlPrivate::QmlMetaType<T>::list(),
608 sizeof(T), QQmlPrivate::Constructors<T>::createInto, nullptr,
609 QString(),
610 QQmlPrivate::ValueType<T, E>::create,
611
612 uri, QTypeRevision::fromVersion(versionMajor, versionMinor), qmlName,
613 QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
614
615 attached,
616 attachedMetaObject,
617
618 QQmlPrivate::StaticCastSelector<T,QQmlParserStatus>::cast(),
619 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueSource>::cast(),
620 QQmlPrivate::StaticCastSelector<T,QQmlPropertyValueInterceptor>::cast(),
621
622 QQmlPrivate::ExtendedType<E>::createParent, QQmlPrivate::ExtendedType<E>::staticMetaObject(),
623
624 parser,
625 QTypeRevision::zero(),
626 QQmlPrivate::StaticCastSelector<T,QQmlFinalizerHook>::cast(),
627 QQmlPrivate::ValueTypeCreationMethod::None,
628 };
629
630 return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
631}
632
633class QQmlContext;
634class QQmlEngine;
635class QJSValue;
636class QJSEngine;
637
638Q_QML_EXPORT void qmlExecuteDeferred(QObject *);
639Q_QML_EXPORT QQmlContext *qmlContext(const QObject *);
640Q_QML_EXPORT QQmlEngine *qmlEngine(const QObject *);
641Q_QML_EXPORT QQmlAttachedPropertiesFunc qmlAttachedPropertiesFunction(QObject *,
642 const QMetaObject *);
643Q_QML_EXPORT QObject *qmlAttachedPropertiesObject(QObject *, QQmlAttachedPropertiesFunc func,
644 bool createIfMissing = true);
645Q_QML_EXPORT QObject *qmlExtendedObject(QObject *);
646
647//The C++ version of protected namespaces in qmldir
648Q_QML_EXPORT bool qmlProtectModule(const char* uri, int majVersion);
649Q_QML_EXPORT void qmlRegisterModule(const char *uri, int versionMajor, int versionMinor);
650
656
657Q_QML_EXPORT void qmlRegisterModuleImport(const char *uri, int moduleMajor,
658 const char *import,
659 int importMajor = QQmlModuleImportLatest,
660 int importMinor = QQmlModuleImportLatest);
661Q_QML_EXPORT void qmlUnregisterModuleImport(const char *uri, int moduleMajor,
662 const char *import,
663 int importMajor = QQmlModuleImportLatest,
664 int importMinor = QQmlModuleImportLatest);
665
666template<typename T>
667QObject *qmlAttachedPropertiesObject(const QObject *obj, bool create = true)
668{
669 // We don't need a concrete object to resolve the function. As T is a C++ type, it and all its
670 // super types should be registered as CppType (or not at all). We only need the object and its
671 // QML engine to resolve composite types. Therefore, the function is actually a static property
672 // of the C++ type system and we can cache it here for improved performance on further lookups.
673 if (const auto func = QQmlPrivate::attachedPropertiesFunc<T>())
674 return qmlAttachedPropertiesObject(const_cast<QObject *>(obj), func, create);
675
676 // Usually the above func should not be nullptr. However, to be safe, keep this fallback
677 // via the metaobject.
678 static const auto func = qmlAttachedPropertiesFunction(nullptr, &T::staticMetaObject);
679 return qmlAttachedPropertiesObject(const_cast<QObject *>(obj), func, create);
680}
681
682#ifdef Q_QDOC
683int qmlRegisterSingletonType(
684 const char *uri, int versionMajor, int versionMinor, const char *typeName,
685 std::function<QJSValue(QQmlEngine *, QJSEngine *)> callback)
686#else
687template<typename F, typename std::enable_if<std::is_convertible<F, std::function<QJSValue(QQmlEngine *, QJSEngine *)>>::value, void>::type* = nullptr>
688int qmlRegisterSingletonType(
689 const char *uri, int versionMajor, int versionMinor, const char *typeName, F &&callback)
690#endif
691{
692 QQmlPrivate::RegisterSingletonType api = {
693 0,
694 uri,
695 QTypeRevision::fromVersion(versionMajor, versionMinor),
696 typeName,
697 std::forward<F>(callback),
698 nullptr,
699 nullptr,
700 QMetaType(),
701 nullptr, nullptr,
702 QTypeRevision::zero()
703 };
704
705 return QQmlPrivate::qmlregister(QQmlPrivate::SingletonRegistration, &api);
706}
707
708#ifdef Q_QDOC
709template <typename T>
710int qmlRegisterSingletonType(
711 const char *uri, int versionMajor, int versionMinor, const char *typeName,
712 std::function<QObject *(QQmlEngine *, QJSEngine *)> callback)
713#else
714template<typename T, typename F, typename std::enable_if<std::is_convertible<F, std::function<QObject *(QQmlEngine *, QJSEngine *)>>::value, void>::type* = nullptr>
715int qmlRegisterSingletonType(
716 const char *uri, int versionMajor, int versionMinor, const char *typeName, F &&callback)
717#endif
718{
719 QQmlPrivate::RegisterSingletonType api = {
720 0,
721 uri,
722 QTypeRevision::fromVersion(versionMajor, versionMinor),
723 typeName,
724 nullptr,
725 std::forward<F>(callback),
726 QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
727 QQmlPrivate::QmlMetaType<T>::self(),
728 nullptr, nullptr,
729 QTypeRevision::zero()
730 };
731
732 return QQmlPrivate::qmlregister(QQmlPrivate::SingletonRegistration, &api);
733}
734
735#ifdef Q_QDOC
736int qmlRegisterSingletonInstance(const char *uri, int versionMajor, int versionMinor, const char *typeName, QObject *cppObject)
737#else
738template<typename T>
739inline auto qmlRegisterSingletonInstance(const char *uri, int versionMajor, int versionMinor,
740 const char *typeName, T *cppObject) -> typename std::enable_if<std::is_base_of<QObject, T>::value, int>::type
741#endif
742{
743 QQmlPrivate::SingletonInstanceFunctor registrationFunctor;
744 registrationFunctor.m_object = cppObject;
745 return qmlRegisterSingletonType<T>(uri, versionMajor, versionMinor, typeName, registrationFunctor);
746}
747
748inline int qmlRegisterSingletonType(const QUrl &url, const char *uri, int versionMajor, int versionMinor, const char *qmlName)
749{
750 if (url.isRelative()) {
751 // User input check must go here, because QQmlPrivate::qmlregister is also used internally for composite types
752 qWarning("qmlRegisterSingletonType requires absolute URLs.");
753 return 0;
754 }
755
756 QQmlPrivate::RegisterCompositeSingletonType type = {
757 0,
758 url,
759 uri,
760 QTypeRevision::fromVersion(versionMajor, versionMinor),
761 qmlName
762 };
763
764 return QQmlPrivate::qmlregister(QQmlPrivate::CompositeSingletonRegistration, &type);
765}
766
767inline int qmlRegisterType(const QUrl &url, const char *uri, int versionMajor, int versionMinor, const char *qmlName)
768{
769 if (url.isRelative()) {
770 // User input check must go here, because QQmlPrivate::qmlregister is also used internally for composite types
771 qWarning("qmlRegisterType requires absolute URLs.");
772 return 0;
773 }
774
775 QQmlPrivate::RegisterCompositeType type = {
776 0,
777 url,
778 uri,
779 QTypeRevision::fromVersion(versionMajor, versionMinor),
780 qmlName
781 };
782
783 return QQmlPrivate::qmlregister(QQmlPrivate::CompositeRegistration, &type);
784}
785
786template<typename Container>
787inline int qmlRegisterAnonymousSequentialContainer(const char *uri, int versionMajor)
788{
789 static_assert(!std::is_abstract_v<Container>,
790 "It is not possible to register an abstract container with qmlRegisterAnonymousSequentialContainer.");
791
792 QQmlPrivate::RegisterSequentialContainer type = {
793 0,
794 uri,
795 QTypeRevision::fromMajorVersion(versionMajor),
796 nullptr,
797 QMetaType::fromType<Container>(),
798 QMetaSequence::fromContainer<Container>(),
799 QTypeRevision::zero()
800 };
801
802 return QQmlPrivate::qmlregister(QQmlPrivate::SequentialContainerRegistration, &type);
803}
804
805template<class T, class Resolved, class Extended, bool Singleton, bool Interface, bool Sequence, bool Uncreatable>
806struct QmlTypeAndRevisionsRegistration;
807
808template<class T, class Resolved, class Extended>
809struct QmlTypeAndRevisionsRegistration<T, Resolved, Extended, false, false, false, false> {
810 static void registerTypeAndRevisions(const char *uri, int versionMajor, QList<int> *qmlTypeIds,
811 const QMetaObject *extension)
812 {
813#if QT_DEPRECATED_SINCE(6, 4)
814 // ### Qt7: Remove the warnings, and leave only the static asserts below.
815 if constexpr (!QQmlPrivate::QmlMetaType<Resolved>::hasAcceptableCtors()) {
816 QQmlPrivate::qmlRegistrationWarning(QQmlPrivate::UnconstructibleType,
817 QMetaType::fromType<Resolved>());
818 }
819
820 if constexpr (!std::is_base_of_v<QObject, Resolved>
821 && QQmlTypeInfo<T>::hasAttachedProperties) {
822 QQmlPrivate::qmlRegistrationWarning(QQmlPrivate::NonQObjectWithAtached,
823 QMetaType::fromType<Resolved>());
824 }
825#else
826 static_assert(QQmlPrivate::QmlMetaType<Resolved>::hasAcceptableCtors(),
827 "This type is neither a default constructible QObject, nor a default- "
828 "and copy-constructible Q_GADGET, nor marked as uncreatable.\n"
829 "You should not use it as a QML type.");
830 static_assert(std::is_base_of_v<QObject, Resolved>
831 || !QQmlTypeInfo<Resolved>::hasAttachedProperties);
832#endif
833 QQmlPrivate::qmlRegisterTypeAndRevisions<Resolved, Extended>(
834 uri, versionMajor, QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
835 qmlTypeIds, extension);
836 }
837};
838
839template<class T, class Resolved, class Extended>
840struct QmlTypeAndRevisionsRegistration<T, Resolved, Extended, false, false, false, true> {
841 static void registerTypeAndRevisions(const char *uri, int versionMajor, QList<int> *qmlTypeIds,
842 const QMetaObject *extension)
843 {
844#if QT_DEPRECATED_SINCE(6, 4)
845 // ### Qt7: Remove the warning, and leave only the static assert below.
846 if constexpr (!std::is_base_of_v<QObject, Resolved>) {
847 if constexpr (!QQmlPrivate::QmlMetaType<Resolved>::hasAcceptableCtors()) {
848 QQmlPrivate::qmlRegistrationWarning(
849 QQmlPrivate::UnconstructibleType, QMetaType::fromType<Resolved>());
850 }
851 if constexpr (QQmlTypeInfo<Resolved>::hasAttachedProperties) {
852 QQmlPrivate::qmlRegistrationWarning(
853 QQmlPrivate::NonQObjectWithAtached, QMetaType::fromType<Resolved>());
854 }
855 }
856#elif QT_DEPRECATED_SINCE(6, 10)
857 static_assert(std::is_base_of_v<QObject, Resolved>
858 || !QQmlTypeInfo<Resolved>::hasAttachedProperties);
859
860 // ### Qt7: Remove the warning, and leave only the static assert below.
861 if constexpr (!std::is_base_of_v<QObject, Resolved>
862 && !QQmlPrivate::QmlMetaType<Resolved>::hasAcceptableCtors()) {
863 QQmlPrivate::qmlRegistrationWarning(
864 QQmlPrivate::UnconstructibleType, QMetaType::fromType<Resolved>());
865 }
866#else
867 static_assert(std::is_base_of_v<QObject, Resolved>
868 || (QQmlPrivate::QmlMetaType<Resolved>::hasAcceptableCtors()
869 && !QQmlTypeInfo<Resolved>::hasAttachedProperties));
870#endif
871 QQmlPrivate::qmlRegisterTypeAndRevisions<Resolved, Extended>(
872 uri, versionMajor, QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
873 qmlTypeIds, extension);
874 }
875};
876
877template<class T, class Resolved>
878struct QmlTypeAndRevisionsRegistration<T, Resolved, void, false, false, true, true> {
879 static void registerTypeAndRevisions(const char *uri, int versionMajor, QList<int> *qmlTypeIds,
880 const QMetaObject *)
881 {
882 // Sequences have to be anonymous for now, which implies uncreatable.
883 QQmlPrivate::qmlRegisterSequenceAndRevisions<Resolved>(
884 uri, versionMajor, QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
885 qmlTypeIds);
886 }
887};
888
889template<class T, class Resolved, class Extended>
890struct QmlTypeAndRevisionsRegistration<T, Resolved, Extended, true, false, false, false> {
891 static void registerTypeAndRevisions(const char *uri, int versionMajor, QList<int> *qmlTypeIds,
892 const QMetaObject *extension)
893 {
894#if QT_DEPRECATED_SINCE(6, 4)
895 // ### Qt7: Remove the warning, and leave only the static assert below.
896 if constexpr (QQmlPrivate::singletonConstructionMode<Resolved, T>()
897 == QQmlPrivate::SingletonConstructionMode::None) {
898 QQmlPrivate::qmlRegistrationWarning(QQmlPrivate::UnconstructibleSingleton,
899 QMetaType::fromType<Resolved>());
900 }
901#else
902 static_assert(QQmlPrivate::singletonConstructionMode<Resolved, T>()
903 != QQmlPrivate::SingletonConstructionMode::None,
904 "A singleton needs either a default constructor or, when adding a default "
905 "constructor is infeasible, a public static "
906 "create(QQmlEngine *, QJSEngine *) method");
907#endif
908
909 QQmlPrivate::qmlRegisterSingletonAndRevisions<Resolved, Extended, T>(
910 uri, versionMajor, QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
911 qmlTypeIds, extension);
912 }
913};
914
915template<class T, class Resolved, class Extended>
916struct QmlTypeAndRevisionsRegistration<T, Resolved, Extended, true, false, false, true> {
917 static void registerTypeAndRevisions(const char *uri, int versionMajor, QList<int> *qmlTypeIds,
918 const QMetaObject *extension)
919 {
920 // An uncreatable singleton makes little sense? OK, you can still use the enums.
921 QQmlPrivate::qmlRegisterSingletonAndRevisions<Resolved, Extended, T>(
922 uri, versionMajor, QQmlPrivate::StaticMetaObject<T>::staticMetaObject(),
923 qmlTypeIds, extension);
924 }
925};
926
927template<class T, class Resolved>
928struct QmlTypeAndRevisionsRegistration<T, Resolved, void, false, true, false, false> {
929 static void registerTypeAndRevisions(const char *uri, int versionMajor, QList<int> *qmlTypeIds,
930 const QMetaObject *)
931 {
932 const int id = qmlRegisterInterface<Resolved>(uri, versionMajor);
933 if (qmlTypeIds)
934 qmlTypeIds->append(id);
935 }
936};
937
938template<typename... T>
939void qmlRegisterTypesAndRevisions(const char *uri, int versionMajor, QList<int> *qmlTypeIds)
940{
941 (QmlTypeAndRevisionsRegistration<
942 T, typename QQmlPrivate::QmlResolved<T>::Type,
943 typename QQmlPrivate::QmlExtended<T>::Type,
944 QQmlPrivate::QmlSingleton<T>::Value,
945 QQmlPrivate::QmlInterface<T>::Value,
946 QQmlPrivate::QmlSequence<T>::Value,
947 QQmlPrivate::QmlUncreatable<T>::Value || QQmlPrivate::QmlAnonymous<T>::Value>
948 ::registerTypeAndRevisions(uri, versionMajor, qmlTypeIds,
949 QQmlPrivate::QmlExtendedNamespace<T>::metaObject()), ...);
950}
951
952inline void qmlRegisterNamespaceAndRevisions(const QMetaObject *metaObject,
953 const char *uri, int versionMajor,
954 QList<int> *qmlTypeIds,
955 const QMetaObject *classInfoMetaObject,
956 const QMetaObject *extensionMetaObject)
957{
958 QQmlPrivate::RegisterTypeAndRevisions type = {
959 3,
960 QMetaType(),
961 QMetaType(),
962 0,
963 nullptr,
964 nullptr,
965 nullptr,
966
967 uri,
968 QTypeRevision::fromMajorVersion(versionMajor),
969
970 metaObject,
971 (classInfoMetaObject ? classInfoMetaObject : metaObject),
972
973 nullptr,
974 nullptr,
975
976 -1,
977 -1,
978 -1,
979
980 nullptr,
981 extensionMetaObject,
982
983 &qmlCreateCustomParser<void>,
984 qmlTypeIds,
985 -1,
986 false,
987 QMetaSequence()
988 };
989
990 qmlregister(QQmlPrivate::TypeAndRevisionsRegistration, &type);
991}
992
993inline void qmlRegisterNamespaceAndRevisions(const QMetaObject *metaObject,
994 const char *uri, int versionMajor,
995 QList<int> *qmlTypeIds = nullptr,
996 const QMetaObject *classInfoMetaObject = nullptr)
997{
998 qmlRegisterNamespaceAndRevisions(metaObject, uri, versionMajor, qmlTypeIds,
999 classInfoMetaObject, nullptr);
1000}
1001
1002template<typename Enum>
1003void qmlRegisterEnum(const char *name)
1004{
1005 const QMetaType metaType = QMetaType::fromType<Enum>();
1006
1007 // Calling id() generally makes the metatype usable with fromName().
1008 metaType.id();
1009
1010 // If the enum was registered with the old Q_ENUMS or Q_FLAGS,
1011 // we need to manually set up the typedef.
1012 if constexpr (QtPrivate::IsQEnumHelper<Enum>::Value)
1013 Q_UNUSED(name)
1014 else
1015 QMetaType::registerNormalizedTypedef(name, metaType);
1016}
1017
1018int Q_QML_EXPORT qmlTypeId(const char *uri, int versionMajor, int versionMinor, const char *qmlName);
1019
1020QT_END_NAMESPACE
1021
1022#endif // QQML_H
QJSManagedValue::QJSEngine
friend class QJSEngine
Definition qjsmanagedvalue.h:123
QObject
\inmodule QtCore
Definition qobject.h:106
QQmlContext
The QQmlContext class defines a context within a QML engine.
Definition qqmlcontext.h:25
QQmlEngine
The QQmlEngine class provides an environment for instantiating QML components.
Definition qqmlengine.h:58
QQuickBoundaryReturnJob::updateCurrentTime
void updateCurrentTime(int) override
Definition qquickboundaryrule.cpp:70
QQuickBoundaryReturnJob::duration
int duration() const override
Definition qquickboundaryrule.cpp:58
QQuickBoundaryReturnJob::QQuickBoundaryReturnJob
QQuickBoundaryReturnJob(QQuickBoundaryRulePrivate *br, qreal to)
Definition qquickboundaryrule.cpp:52
QQuickBoundaryReturnJob::updateState
void updateState(QAbstractAnimationJob::State newState, QAbstractAnimationJob::State oldState) override
Definition qquickboundaryrule.cpp:84
QQuickBoundaryReturnJob::boundaryRule
QQuickBoundaryRulePrivate * boundaryRule
Definition qquickboundaryrule.cpp:65
QQuickBoundaryRulePrivate::easedOvershoot
qreal easedOvershoot(qreal overshootingValue)
Definition qquickboundaryrule.cpp:495
QQuickBoundaryRulePrivate::returnAnimationJob
QQuickBoundaryReturnJob * returnAnimationJob
Definition qquickboundaryrule.cpp:28
QT_BEGIN_NAMESPACE
Combined button and popup list for selecting options.
Definition qrandomaccessasyncfile_darwin.mm:17
qmlRegisterCustomType
int qmlRegisterCustomType(const char *uri, int versionMajor, int versionMinor, const char *qmlName, QQmlCustomParser *parser)
Definition qqml.h:551
QML_DECLARE_TYPE_HASMETATYPE
#define QML_DECLARE_TYPE_HASMETATYPE(TYPE)
Definition qqml.h:27
qmlRegisterModuleImport
Q_QML_EXPORT void qmlRegisterModuleImport(const char *uri, int moduleMajor, const char *import, int importMajor=QQmlModuleImportLatest, int importMinor=QQmlModuleImportLatest)
qmlCreateCustomParser
QQmlCustomParser * qmlCreateCustomParser()
Definition qqmlprivate.h:95
qmlRegisterEnum
void qmlRegisterEnum(const char *name)
Definition qqml.h:1003
qmlProtectModule
Q_QML_EXPORT bool qmlProtectModule(const char *uri, int majVersion)
qmlRegisterType
int qmlRegisterType(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
Definition qqml.h:304
qmlRegisterAnonymousTypesAndRevisions
void qmlRegisterAnonymousTypesAndRevisions(const char *uri, int versionMajor)
Definition qqml.h:132
qmlRegisterNamespaceAndRevisions
void qmlRegisterNamespaceAndRevisions(const QMetaObject *metaObject, const char *uri, int versionMajor, QList< int > *qmlTypeIds=nullptr, const QMetaObject *classInfoMetaObject=nullptr)
Definition qqml.h:993
qmlRegisterCustomExtendedType
int qmlRegisterCustomExtendedType(const char *uri, int versionMajor, int versionMinor, const char *qmlName, QQmlCustomParser *parser)
Definition qqml.h:588
QML_DECLARE_TYPE
#define QML_DECLARE_TYPE(TYPE)
Definition qqml.h:23
qmlExecuteDeferred
Q_QML_EXPORT void qmlExecuteDeferred(QObject *)
\inmodule QtQml \title Functions to register C++ types to QML
Definition qqml.cpp:60
qmlRegisterType
int qmlRegisterType(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
Definition qqml.h:340
qmlRegisterNamespaceAndRevisions
void qmlRegisterNamespaceAndRevisions(const QMetaObject *metaObject, const char *uri, int versionMajor, QList< int > *qmlTypeIds, const QMetaObject *classInfoMetaObject, const QMetaObject *extensionMetaObject)
Definition qqml.h:952
qmlRegisterTypesAndRevisions
void qmlRegisterTypesAndRevisions(const char *uri, int versionMajor, QList< int > *qmlTypeIds)
Definition qqml.h:939
qmlRegisterCustomType
int qmlRegisterCustomType(const char *uri, int versionMajor, int versionMinor, const char *qmlName, QQmlCustomParser *parser)
Definition qqml.h:514
qmlRegisterExtendedType
int qmlRegisterExtendedType(const char *uri, int versionMajor)
Definition qqml.h:408
QQmlModuleImportSpecialVersions
QQmlModuleImportSpecialVersions
Definition qqml.h:651
QQmlModuleImportLatest
@ QQmlModuleImportLatest
Definition qqml.h:653
QQmlModuleImportModuleAny
@ QQmlModuleImportModuleAny
Definition qqml.h:652
QQmlModuleImportAuto
@ QQmlModuleImportAuto
Definition qqml.h:654
qmlRegisterExtendedType
int qmlRegisterExtendedType(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
Definition qqml.h:449
qmlRegisterRevision
int qmlRegisterRevision(const char *uri, int versionMajor, int versionMinor)
Definition qqml.h:376
qmlRegisterAnonymousType
int qmlRegisterAnonymousType(const char *uri, int versionMajor)
Definition qqml.h:94
qmlUnregisterModuleImport
Q_QML_EXPORT void qmlUnregisterModuleImport(const char *uri, int moduleMajor, const char *import, int importMajor=QQmlModuleImportLatest, int importMinor=QQmlModuleImportLatest)
qmlAttachedPropertiesObject
QObject * qmlAttachedPropertiesObject(const QObject *obj, bool create=true)
Definition qqml.h:667
qmlRegisterAnonymousType
int qmlRegisterAnonymousType(const char *uri, int versionMajor)
Definition qqml.h:60
qmlRegisterModule
Q_QML_EXPORT void qmlRegisterModule(const char *uri, int versionMajor, int versionMinor)
qmlRegisterInterface
int qmlRegisterInterface(const char *uri, int versionMajor)
Definition qqml.h:496
operator<<
QDebug Q_QML_EXPORT operator<<(QDebug debug, const QQmlError &error)
Definition qqmlerror.cpp:283
QmlTypeAndRevisionsRegistration< T, Resolved, Extended, false, false, false, false >::registerTypeAndRevisions
static void registerTypeAndRevisions(const char *uri, int versionMajor, QList< int > *qmlTypeIds, const QMetaObject *extension)
Definition qqml.h:810