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