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