1 | /**************************************************************************** |
2 | ** |
3 | ** Copyright (C) 2016 The Qt Company Ltd. |
4 | ** Contact: https://www.qt.io/licensing/ |
5 | ** |
6 | ** This file is part of the QtQml module of the Qt Toolkit. |
7 | ** |
8 | ** $QT_BEGIN_LICENSE:LGPL$ |
9 | ** Commercial License Usage |
10 | ** Licensees holding valid commercial Qt licenses may use this file in |
11 | ** accordance with the commercial license agreement provided with the |
12 | ** Software or, alternatively, in accordance with the terms contained in |
13 | ** a written agreement between you and The Qt Company. For licensing terms |
14 | ** and conditions see https://www.qt.io/terms-conditions. For further |
15 | ** information use the contact form at https://www.qt.io/contact-us. |
16 | ** |
17 | ** GNU Lesser General Public License Usage |
18 | ** Alternatively, this file may be used under the terms of the GNU Lesser |
19 | ** General Public License version 3 as published by the Free Software |
20 | ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
21 | ** packaging of this file. Please review the following information to |
22 | ** ensure the GNU Lesser General Public License version 3 requirements |
23 | ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
24 | ** |
25 | ** GNU General Public License Usage |
26 | ** Alternatively, this file may be used under the terms of the GNU |
27 | ** General Public License version 2.0 or (at your option) the GNU General |
28 | ** Public license version 3 or any later version approved by the KDE Free |
29 | ** Qt Foundation. The licenses are as published by the Free Software |
30 | ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
31 | ** included in the packaging of this file. Please review the following |
32 | ** information to ensure the GNU General Public License requirements will |
33 | ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
34 | ** https://www.gnu.org/licenses/gpl-3.0.html. |
35 | ** |
36 | ** $QT_END_LICENSE$ |
37 | ** |
38 | ****************************************************************************/ |
39 | |
40 | #include "qqmlengine_p.h" |
41 | #include "qqmlengine.h" |
42 | #include "qqmlcomponentattached_p.h" |
43 | |
44 | #include "qqmlcontext_p.h" |
45 | #include "qqml.h" |
46 | #include "qqmlcontext.h" |
47 | #include "qqmlexpression.h" |
48 | #include "qqmlcomponent.h" |
49 | #include "qqmlvme_p.h" |
50 | #include "qqmlstringconverters_p.h" |
51 | #include "qqmlscriptstring.h" |
52 | #include "qqmlglobal_p.h" |
53 | #include "qqmlcomponent_p.h" |
54 | #include "qqmlextensioninterface.h" |
55 | #include "qqmllist_p.h" |
56 | #include "qqmltypenamecache_p.h" |
57 | #include "qqmlnotifier_p.h" |
58 | #include "qqmlincubator.h" |
59 | #include "qqmlabstracturlinterceptor.h" |
60 | #include "qqmlsourcecoordinate_p.h" |
61 | #include <private/qqmldirparser_p.h> |
62 | #include <private/qqmlboundsignal_p.h> |
63 | #include <private/qqmljsdiagnosticmessage_p.h> |
64 | #include <QtCore/qstandardpaths.h> |
65 | #include <QtCore/qsettings.h> |
66 | #include <QtCore/qmetaobject.h> |
67 | #include <QDebug> |
68 | #include <QtCore/qcoreapplication.h> |
69 | #include <QtCore/qcryptographichash.h> |
70 | #include <QtCore/qdir.h> |
71 | #include <QtCore/qmutex.h> |
72 | #include <QtCore/qthread.h> |
73 | #include <private/qthread_p.h> |
74 | |
75 | #if QT_CONFIG(qml_network) |
76 | #include "qqmlnetworkaccessmanagerfactory.h" |
77 | #include <QNetworkAccessManager> |
78 | #include <QtNetwork/qnetworkconfigmanager.h> |
79 | #endif |
80 | |
81 | #include <private/qobject_p.h> |
82 | #include <private/qmetaobject_p.h> |
83 | #if QT_CONFIG(qml_locale) |
84 | #include <private/qqmllocale_p.h> |
85 | #endif |
86 | #include <private/qqmlbind_p.h> |
87 | #include <private/qqmlconnections_p.h> |
88 | #if QT_CONFIG(qml_animation) |
89 | #include <private/qqmltimer_p.h> |
90 | #endif |
91 | #include <private/qqmlplatform_p.h> |
92 | #include <private/qqmlloggingcategory_p.h> |
93 | |
94 | #ifdef Q_OS_WIN // for %APPDATA% |
95 | # include <qt_windows.h> |
96 | # ifndef Q_OS_WINRT |
97 | # include <shlobj.h> |
98 | # endif |
99 | # include <qlibrary.h> |
100 | # ifndef CSIDL_APPDATA |
101 | # define CSIDL_APPDATA 0x001a // <username>\Application Data |
102 | # endif |
103 | #endif // Q_OS_WIN |
104 | |
105 | QT_BEGIN_NAMESPACE |
106 | |
107 | // Declared in qqml.h |
108 | int qmlRegisterUncreatableMetaObject(const QMetaObject &staticMetaObject, |
109 | const char *uri, int versionMajor, |
110 | int versionMinor, const char *qmlName, |
111 | const QString& reason) |
112 | { |
113 | QQmlPrivate::RegisterType type = { |
114 | .version: 0, |
115 | |
116 | .typeId: 0, |
117 | .listId: 0, |
118 | .objectSize: 0, |
119 | .create: nullptr, |
120 | .noCreationReason: reason, |
121 | |
122 | .uri: uri, .versionMajor: versionMajor, .versionMinor: versionMinor, .elementName: qmlName, .metaObject: &staticMetaObject, |
123 | |
124 | .attachedPropertiesFunction: QQmlAttachedPropertiesFunc(), |
125 | .attachedPropertiesMetaObject: nullptr, |
126 | |
127 | .parserStatusCast: 0, |
128 | .valueSourceCast: 0, |
129 | .valueInterceptorCast: 0, |
130 | |
131 | .extensionObjectCreate: nullptr, .extensionMetaObject: nullptr, |
132 | |
133 | .customParser: nullptr, |
134 | .revision: 0 |
135 | }; |
136 | |
137 | return QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type); |
138 | } |
139 | |
140 | /*! |
141 | \qmltype QtObject |
142 | \instantiates QObject |
143 | \inqmlmodule QtQml |
144 | \ingroup qml-utility-elements |
145 | \brief A basic QML type. |
146 | |
147 | The QtObject type is a non-visual element which contains only the |
148 | objectName property. |
149 | |
150 | It can be useful to create a QtObject if you need an extremely |
151 | lightweight type to enclose a set of custom properties: |
152 | |
153 | \snippet qml/qtobject.qml 0 |
154 | |
155 | It can also be useful for C++ integration, as it is just a plain |
156 | QObject. See the QObject documentation for further details. |
157 | */ |
158 | /*! |
159 | \qmlproperty string QtObject::objectName |
160 | This property holds the QObject::objectName for this specific object instance. |
161 | |
162 | This allows a C++ application to locate an item within a QML component |
163 | using the QObject::findChild() method. For example, the following C++ |
164 | application locates the child \l Rectangle item and dynamically changes its |
165 | \c color value: |
166 | |
167 | \qml |
168 | // MyRect.qml |
169 | |
170 | import QtQuick 2.0 |
171 | |
172 | Item { |
173 | width: 200; height: 200 |
174 | |
175 | Rectangle { |
176 | anchors.fill: parent |
177 | color: "red" |
178 | objectName: "myRect" |
179 | } |
180 | } |
181 | \endqml |
182 | |
183 | \code |
184 | // main.cpp |
185 | |
186 | QQuickView view; |
187 | view.setSource(QUrl::fromLocalFile("MyRect.qml")); |
188 | view.show(); |
189 | |
190 | QQuickItem *item = view.rootObject()->findChild<QQuickItem*>("myRect"); |
191 | if (item) |
192 | item->setProperty("color", QColor(Qt::yellow)); |
193 | \endcode |
194 | */ |
195 | |
196 | bool QQmlEnginePrivate::qml_debugging_enabled = false; |
197 | bool QQmlEnginePrivate::s_designerMode = false; |
198 | |
199 | #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) |
200 | void QQmlEnginePrivate::registerQuickTypes() |
201 | { |
202 | // Don't add anything here. These are only for backwards compatibility. |
203 | // Also, don't use qmlRegisterTypesAndRevisions as that will auto-add future revisions. |
204 | |
205 | const char uri[] = "QtQuick" ; |
206 | |
207 | qmlRegisterType<QQmlComponent>(uri, versionMajor: 2, versionMinor: 0, qmlName: "Component" ); |
208 | qmlRegisterType<QObject>(uri, versionMajor: 2, versionMinor: 0, qmlName: "QtObject" ); |
209 | qmlRegisterType<QQmlBind>(uri, versionMajor: 2, versionMinor: 0, qmlName: "Binding" ); |
210 | qmlRegisterType<QQmlBind, 8>(uri, versionMajor: 2, versionMinor: 8, qmlName: "Binding" ); |
211 | qmlRegisterCustomType<QQmlConnections>(uri, versionMajor: 2, versionMinor: 0, qmlName: "Connections" , parser: new QQmlConnectionsParser); |
212 | |
213 | // Connections revision 3 was added in QtQml 2.3, but only in QtQuick 2.7. |
214 | qmlRegisterCustomType<QQmlConnections, 3>(uri, versionMajor: 2, versionMinor: 7, qmlName: "Connections" , parser: new QQmlConnectionsParser); |
215 | |
216 | #if QT_CONFIG(qml_animation) |
217 | qmlRegisterType<QQmlTimer>(uri, versionMajor: 2, versionMinor: 0,qmlName: "Timer" ); |
218 | #endif |
219 | qmlRegisterType<QQmlLoggingCategory>(uri, versionMajor: 2, versionMinor: 8, qmlName: "LoggingCategory" ); |
220 | qmlRegisterType<QQmlLoggingCategory, 12>(uri, versionMajor: 2, versionMinor: 12, qmlName: "LoggingCategory" ); |
221 | #if QT_CONFIG(qml_locale) |
222 | // Locale was added in QtQuick 2.0 and in QtQml 2.2 |
223 | qmlRegisterUncreatableType<QQmlLocale>(uri, versionMajor: 2, versionMinor: 0, qmlName: "Locale" , reason: QQmlEngine::tr(s: "Locale cannot be instantiated. Use Qt.locale()" )); |
224 | #endif |
225 | } |
226 | #endif // QT_VERSION < QT_VERSION_CHECK(6, 0, 0) |
227 | |
228 | bool QQmlEnginePrivate::designerMode() |
229 | { |
230 | return s_designerMode; |
231 | } |
232 | |
233 | void QQmlEnginePrivate::activateDesignerMode() |
234 | { |
235 | s_designerMode = true; |
236 | } |
237 | |
238 | |
239 | /*! |
240 | \class QQmlImageProviderBase |
241 | \brief The QQmlImageProviderBase class is used to register image providers in the QML engine. |
242 | \inmodule QtQml |
243 | |
244 | Image providers must be registered with the QML engine. The only information the QML |
245 | engine knows about image providers is the type of image data they provide. To use an |
246 | image provider to acquire image data, you must cast the QQmlImageProviderBase pointer |
247 | to a QQuickImageProvider pointer. |
248 | |
249 | \sa QQuickImageProvider, QQuickTextureFactory |
250 | */ |
251 | |
252 | /*! |
253 | \enum QQmlImageProviderBase::ImageType |
254 | |
255 | Defines the type of image supported by this image provider. |
256 | |
257 | \value Image The Image Provider provides QImage images. |
258 | The QQuickImageProvider::requestImage() method will be called for all image requests. |
259 | \value Pixmap The Image Provider provides QPixmap images. |
260 | The QQuickImageProvider::requestPixmap() method will be called for all image requests. |
261 | \value Texture The Image Provider provides QSGTextureProvider based images. |
262 | The QQuickImageProvider::requestTexture() method will be called for all image requests. |
263 | \value ImageResponse The Image provider provides QQuickTextureFactory based images. |
264 | Should only be used in QQuickAsyncImageProvider or its subclasses. |
265 | The QQuickAsyncImageProvider::requestImageResponse() method will be called for all image requests. |
266 | Since Qt 5.6 |
267 | \omitvalue Invalid |
268 | */ |
269 | |
270 | /*! |
271 | \enum QQmlImageProviderBase::Flag |
272 | |
273 | Defines specific requirements or features of this image provider. |
274 | |
275 | \value ForceAsynchronousImageLoading Ensures that image requests to the provider are |
276 | run in a separate thread, which allows the provider to spend as much time as needed |
277 | on producing the image without blocking the main thread. |
278 | */ |
279 | |
280 | /*! |
281 | \fn QQmlImageProviderBase::imageType() const |
282 | |
283 | Implement this method to return the image type supported by this image provider. |
284 | */ |
285 | |
286 | /*! |
287 | \fn QQmlImageProviderBase::flags() const |
288 | |
289 | Implement this to return the properties of this image provider. |
290 | */ |
291 | |
292 | /*! \internal */ |
293 | QQmlImageProviderBase::QQmlImageProviderBase() |
294 | { |
295 | } |
296 | |
297 | /*! \internal */ |
298 | QQmlImageProviderBase::~QQmlImageProviderBase() |
299 | { |
300 | } |
301 | |
302 | |
303 | /*! |
304 | \qmltype Qt |
305 | \inqmlmodule QtQml |
306 | \instantiates QQmlEnginePrivate |
307 | \ingroup qml-utility-elements |
308 | \keyword QmlGlobalQtObject |
309 | \brief Provides a global object with useful enums and functions from Qt. |
310 | |
311 | The \c Qt object is a global object with utility functions, properties and enums. |
312 | |
313 | It is not instantiable; to use it, call the members of the global \c Qt object directly. |
314 | For example: |
315 | |
316 | \qml |
317 | import QtQuick 2.0 |
318 | |
319 | Text { |
320 | color: Qt.rgba(1, 0, 0, 1) |
321 | text: Qt.md5("hello, world") |
322 | } |
323 | \endqml |
324 | |
325 | |
326 | \section1 Enums |
327 | |
328 | The Qt object contains the enums available in the \l [QtCore]{Qt}{Qt Namespace}. For example, you can access |
329 | the \l Qt::LeftButton and \l Qt::RightButton enumeration values as \c Qt.LeftButton and \c Qt.RightButton. |
330 | |
331 | |
332 | \section1 Types |
333 | |
334 | The Qt object also contains helper functions for creating objects of specific |
335 | data types. This is primarily useful when setting the properties of an item |
336 | when the property has one of the following types: |
337 | \list |
338 | \li \c rect - use \l{Qt::rect()}{Qt.rect()} |
339 | \li \c point - use \l{Qt::point()}{Qt.point()} |
340 | \li \c size - use \l{Qt::size()}{Qt.size()} |
341 | \endlist |
342 | |
343 | If the \c QtQuick module has been imported, the following helper functions for |
344 | creating objects of specific data types are also available for clients to use: |
345 | \list |
346 | \li \c color - use \l{Qt::rgba()}{Qt.rgba()}, \l{Qt::hsla()}{Qt.hsla()}, \l{Qt::darker()}{Qt.darker()}, \l{Qt::lighter()}{Qt.lighter()} or \l{Qt::tint()}{Qt.tint()} |
347 | \li \c font - use \l{Qt::font()}{Qt.font()} |
348 | \li \c vector2d - use \l{Qt::vector2d()}{Qt.vector2d()} |
349 | \li \c vector3d - use \l{Qt::vector3d()}{Qt.vector3d()} |
350 | \li \c vector4d - use \l{Qt::vector4d()}{Qt.vector4d()} |
351 | \li \c quaternion - use \l{Qt::quaternion()}{Qt.quaternion()} |
352 | \li \c matrix4x4 - use \l{Qt::matrix4x4()}{Qt.matrix4x4()} |
353 | \endlist |
354 | |
355 | There are also string based constructors for these types. See \l{qtqml-typesystem-basictypes.html}{QML Basic Types} for more information. |
356 | |
357 | \section1 Date/Time Formatters |
358 | |
359 | The Qt object contains several functions for formatting QDateTime, QDate and QTime values. |
360 | |
361 | \list |
362 | \li \l{Qt::formatDateTime}{string Qt.formatDateTime(datetime date, variant format)} |
363 | \li \l{Qt::formatDate}{string Qt.formatDate(datetime date, variant format)} |
364 | \li \l{Qt::formatTime}{string Qt.formatTime(datetime date, variant format)} |
365 | \endlist |
366 | |
367 | The format specification is described at \l{Qt::formatDateTime}{Qt.formatDateTime}. |
368 | |
369 | |
370 | \section1 Dynamic Object Creation |
371 | The following functions on the global object allow you to dynamically create QML |
372 | items from files or strings. See \l{Dynamic QML Object Creation from JavaScript} for an overview |
373 | of their use. |
374 | |
375 | \list |
376 | \li \l{Qt::createComponent()}{object Qt.createComponent(url)} |
377 | \li \l{Qt::createQmlObject()}{object Qt.createQmlObject(string qml, object parent, string filepath)} |
378 | \endlist |
379 | |
380 | |
381 | \section1 Other Functions |
382 | |
383 | The following functions are also on the Qt object. |
384 | |
385 | \list |
386 | \li \l{Qt::quit()}{Qt.quit()} |
387 | \li \l{Qt::md5()}{Qt.md5(string)} |
388 | \li \l{Qt::btoa()}{string Qt.btoa(string)} |
389 | \li \l{Qt::atob()}{string Qt.atob(string)} |
390 | \li \l{Qt::binding()}{object Qt.binding(function)} |
391 | \li \l{Qt::locale()}{object Qt.locale()} |
392 | \li \l{Qt::resolvedUrl()}{string Qt.resolvedUrl(string)} |
393 | \li \l{Qt::openUrlExternally()}{Qt.openUrlExternally(string)} |
394 | \li \l{Qt::fontFamilies()}{list<string> Qt.fontFamilies()} |
395 | \endlist |
396 | */ |
397 | |
398 | /*! |
399 | \qmlproperty object Qt::platform |
400 | \since 5.1 |
401 | |
402 | The \c platform object provides info about the underlying platform. |
403 | |
404 | Its properties are: |
405 | |
406 | \table |
407 | \row |
408 | \li \c platform.os |
409 | \li |
410 | |
411 | This read-only property contains the name of the operating system. |
412 | |
413 | Possible values are: |
414 | |
415 | \list |
416 | \li \c "android" - Android |
417 | \li \c "ios" - iOS |
418 | \li \c "tvos" - tvOS |
419 | \li \c "linux" - Linux |
420 | \li \c "osx" - \macos |
421 | \li \c "qnx" - QNX (since Qt 5.9.3) |
422 | \li \c "unix" - Other Unix-based OS |
423 | \li \c "windows" - Windows |
424 | \li \c "winrt" - WinRT / UWP |
425 | \li \c "wasm" - WebAssembly |
426 | \endlist |
427 | |
428 | \row |
429 | \li \c platform.pluginName |
430 | \li This is the name of the platform set on the QGuiApplication instance |
431 | as returned by \l QGuiApplication::platformName() |
432 | |
433 | \endtable |
434 | */ |
435 | |
436 | /*! |
437 | \qmlproperty object Qt::application |
438 | \since 5.1 |
439 | |
440 | The \c application object provides access to global application state |
441 | properties shared by many QML components. |
442 | |
443 | Its properties are: |
444 | |
445 | \table |
446 | \row |
447 | \li \c application.active |
448 | \li |
449 | Deprecated, use Qt.application.state == Qt.ApplicationActive instead. |
450 | |
451 | \row |
452 | \li \c application.state |
453 | \li |
454 | This read-only property indicates the current state of the application. |
455 | |
456 | Possible values are: |
457 | |
458 | \list |
459 | \li Qt.ApplicationActive - The application is the top-most and focused application, and the |
460 | user is able to interact with the application. |
461 | \li Qt.ApplicationInactive - The application is visible or partially visible, but not selected |
462 | to be in front, the user cannot interact with the application. |
463 | On desktop platforms, this typically means that the user activated |
464 | another application. On mobile platforms, it is more common to |
465 | enter this state when the OS is interrupting the user with for |
466 | example incoming calls, SMS-messages or dialogs. This is usually a |
467 | transient state during which the application is paused. The user |
468 | may return focus to your application, but most of the time it will |
469 | be the first indication that the application is going to be suspended. |
470 | While in this state, consider pausing or stopping any activity that |
471 | should not continue when the user cannot interact with your |
472 | application, such as a video, a game, animations, or sensors. |
473 | You should also avoid performing CPU-intensive tasks which might |
474 | slow down the application in front. |
475 | \li Qt.ApplicationSuspended - The application is suspended and not visible to the user. On |
476 | mobile platforms, the application typically enters this state when |
477 | the user returns to the home screen or switches to another |
478 | application. While in this state, the application should ensure |
479 | that the user perceives it as always alive and does not lose his |
480 | progress, saving any persistent data. The application should cease |
481 | all activities and be prepared for code execution to stop. While |
482 | suspended, the application can be killed at any time without |
483 | further warnings (for example when low memory forces the OS to purge |
484 | suspended applications). |
485 | \li Qt.ApplicationHidden - The application is hidden and runs in the background. This is the |
486 | normal state for applications that need to do background processing, |
487 | like playing music, while the user interacts with other applications. |
488 | The application should free up all graphical resources when entering |
489 | this state. A Qt Quick application should not usually handle this state |
490 | at the QML level. Instead, you should unload the entire UI and reload |
491 | the QML files whenever the application becomes active again. |
492 | \endlist |
493 | |
494 | \row |
495 | \li \c application.layoutDirection |
496 | \li |
497 | This read-only property can be used to query the default layout direction of the |
498 | application. On system start-up, the default layout direction depends on the |
499 | application's language. The property has a value of \c Qt.RightToLeft in locales |
500 | where text and graphic elements are read from right to left, and \c Qt.LeftToRight |
501 | where the reading direction flows from left to right. You can bind to this |
502 | property to customize your application layouts to support both layout directions. |
503 | |
504 | Possible values are: |
505 | |
506 | \list |
507 | \li Qt.LeftToRight - Text and graphics elements should be positioned |
508 | from left to right. |
509 | \li Qt.RightToLeft - Text and graphics elements should be positioned |
510 | from right to left. |
511 | \endlist |
512 | \row |
513 | \li \c application.font |
514 | \li This read-only property holds the default application font as |
515 | returned by \l QGuiApplication::font(). |
516 | \row |
517 | \li \c application.arguments |
518 | \li This is a string list of the arguments the executable was invoked with. |
519 | \row |
520 | \li \c application.name |
521 | \li This is the application name set on the QCoreApplication instance. This property can be written |
522 | to in order to set the application name. |
523 | \row |
524 | \li \c application.displayName (since Qt 5.9) |
525 | \li This is the application display name set on the QGuiApplication instance. This property can be written |
526 | to in order to set the application display name. |
527 | \row |
528 | \li \c application.version |
529 | \li This is the application version set on the QCoreApplication instance. This property can be written |
530 | to in order to set the application version. |
531 | \row |
532 | \li \c application.organization |
533 | \li This is the organization name set on the QCoreApplication instance. This property can be written |
534 | to in order to set the organization name. |
535 | \row |
536 | \li \c application.domain |
537 | \li This is the organization domain set on the QCoreApplication instance. This property can be written |
538 | to in order to set the organization domain. |
539 | |
540 | \row |
541 | \li \c application.supportsMultipleWindows |
542 | \li This read-only property can be used to determine whether or not the |
543 | platform supports multiple windows. Some embedded platforms do not support |
544 | multiple windows, for example. |
545 | |
546 | \row |
547 | \li \c application.screens |
548 | \li An array containing the descriptions of all connected screens. The |
549 | elements of the array are objects with the same properties as the |
550 | \l{Screen} attached object. In practice the array corresponds to the screen |
551 | list returned by QGuiApplication::screens(). In addition to examining |
552 | properties like name, width, height, etc., the array elements can also be |
553 | assigned to the screen property of Window items, thus serving as an |
554 | alternative to the C++ side's QWindow::setScreen(). This property has been |
555 | added in Qt 5.9. |
556 | |
557 | \endtable |
558 | |
559 | The object also has one signal, aboutToQuit(), which is the same as \l QCoreApplication::aboutToQuit(). |
560 | |
561 | The following example uses the \c application object to indicate |
562 | whether the application is currently active: |
563 | |
564 | \snippet qml/application.qml document |
565 | |
566 | Note that when using QML without a QGuiApplication, the following properties will be undefined: |
567 | \list |
568 | \li application.active |
569 | \li application.state |
570 | \li application.layoutDirection |
571 | \li application.font |
572 | \endlist |
573 | |
574 | \sa Screen, Window, {QtQuick.Window::Window::screen}{Window.screen} |
575 | */ |
576 | |
577 | /*! |
578 | \qmlproperty object Qt::inputMethod |
579 | \since 5.0 |
580 | |
581 | The \c inputMethod object allows access to application's QInputMethod object |
582 | and all its properties and slots. See the QInputMethod documentation for |
583 | further details. |
584 | */ |
585 | |
586 | /*! |
587 | \qmlproperty object Qt::styleHints |
588 | \since 5.5 |
589 | |
590 | The \c styleHints object provides platform-specific style hints and settings. |
591 | See the QStyleHints documentation for further details. |
592 | |
593 | \note The \c styleHints object is only available when using the Qt Quick module. |
594 | |
595 | The following example uses the \c styleHints object to determine whether an |
596 | item should gain focus on mouse press or touch release: |
597 | \code |
598 | import QtQuick 2.4 |
599 | |
600 | MouseArea { |
601 | id: button |
602 | |
603 | onPressed: { |
604 | if (!Qt.styleHints.setFocusOnTouchRelease) |
605 | button.forceActiveFocus() |
606 | } |
607 | onReleased: { |
608 | if (Qt.styleHints.setFocusOnTouchRelease) |
609 | button.forceActiveFocus() |
610 | } |
611 | } |
612 | \endcode |
613 | */ |
614 | |
615 | /*! |
616 | \qmlmethod object Qt::include(string url, jsobject callback) |
617 | \deprecated |
618 | |
619 | This method should not be used. Use ECMAScript modules instead and the native |
620 | JavaScript \c import and \c export statements instead. |
621 | |
622 | Includes another JavaScript file. This method can only be used from within JavaScript files, |
623 | and not regular QML files. |
624 | |
625 | This imports all functions from \a url into the current script's namespace. |
626 | |
627 | Qt.include() returns an object that describes the status of the operation. The object has |
628 | a single property, \c {status}, that is set to one of the following values: |
629 | |
630 | \table |
631 | \header \li Symbol \li Value \li Description |
632 | \row \li result.OK \li 0 \li The include completed successfully. |
633 | \row \li result.LOADING \li 1 \li Data is being loaded from the network. |
634 | \row \li result.NETWORK_ERROR \li 2 \li A network error occurred while fetching the url. |
635 | \row \li result.EXCEPTION \li 3 \li A JavaScript exception occurred while executing the included code. |
636 | An additional \c exception property will be set in this case. |
637 | \endtable |
638 | |
639 | The \c status property will be updated as the operation progresses. |
640 | |
641 | If provided, \a callback is invoked when the operation completes. The callback is passed |
642 | the same object as is returned from the Qt.include() call. |
643 | */ |
644 | // Qt.include() is implemented in qv4include.cpp |
645 | |
646 | QQmlEnginePrivate::QQmlEnginePrivate(QQmlEngine *e) |
647 | : propertyCapture(nullptr), rootContext(nullptr), |
648 | #if QT_CONFIG(qml_debug) |
649 | profiler(nullptr), |
650 | #endif |
651 | outputWarningsToMsgLog(true), |
652 | cleanup(nullptr), erroredBindings(nullptr), inProgressCreations(0), |
653 | #if QT_CONFIG(qml_worker_script) |
654 | workerScriptEngine(nullptr), |
655 | #endif |
656 | activeObjectCreator(nullptr), |
657 | #if QT_CONFIG(qml_network) |
658 | networkAccessManager(nullptr), networkAccessManagerFactory(nullptr), |
659 | #endif |
660 | urlInterceptor(nullptr), scarceResourcesRefCount(0), importDatabase(e), typeLoader(e), |
661 | uniqueId(1), incubatorCount(0), incubationController(nullptr) |
662 | { |
663 | } |
664 | |
665 | QQmlEnginePrivate::~QQmlEnginePrivate() |
666 | { |
667 | if (inProgressCreations) |
668 | qWarning() << QQmlEngine::tr(s: "There are still \"%1\" items in the process of being created at engine destruction." ).arg(a: inProgressCreations); |
669 | |
670 | while (cleanup) { |
671 | QQmlCleanup *c = cleanup; |
672 | cleanup = c->next; |
673 | if (cleanup) cleanup->prev = &cleanup; |
674 | c->next = nullptr; |
675 | c->prev = nullptr; |
676 | c->clear(); |
677 | } |
678 | |
679 | doDeleteInEngineThread(); |
680 | |
681 | if (incubationController) incubationController->d = nullptr; |
682 | incubationController = nullptr; |
683 | |
684 | QQmlMetaType::freeUnusedTypesAndCaches(); |
685 | |
686 | for (auto iter = m_compositeTypes.cbegin(), end = m_compositeTypes.cend(); iter != end; ++iter) { |
687 | iter.value()->isRegisteredWithEngine = false; |
688 | QQmlMetaType::unregisterInternalCompositeType(typeIds: {iter.value()->metaTypeId, iter.value()->listMetaTypeId}); |
689 | } |
690 | #if QT_CONFIG(qml_debug) |
691 | delete profiler; |
692 | #endif |
693 | } |
694 | |
695 | void QQmlPrivate::qdeclarativeelement_destructor(QObject *o) |
696 | { |
697 | if (QQmlData *d = QQmlData::get(object: o)) { |
698 | if (d->ownContext) { |
699 | for (QQmlContextData *lc = d->ownContext->linkedContext; lc; lc = lc->linkedContext) { |
700 | lc->invalidate(); |
701 | if (lc->contextObject == o) |
702 | lc->contextObject = nullptr; |
703 | } |
704 | d->ownContext->invalidate(); |
705 | if (d->ownContext->contextObject == o) |
706 | d->ownContext->contextObject = nullptr; |
707 | d->ownContext = nullptr; |
708 | d->context = nullptr; |
709 | } |
710 | |
711 | if (d->outerContext && d->outerContext->contextObject == o) |
712 | d->outerContext->contextObject = nullptr; |
713 | |
714 | // Mark this object as in the process of deletion to |
715 | // prevent it resolving in bindings |
716 | QQmlData::markAsDeleted(o); |
717 | |
718 | // Disconnect the notifiers now - during object destruction this would be too late, since |
719 | // the disconnect call wouldn't be able to call disconnectNotify(), as it isn't possible to |
720 | // get the metaobject anymore. |
721 | d->disconnectNotifiers(); |
722 | } |
723 | } |
724 | |
725 | QQmlData::QQmlData() |
726 | : ownedByQml1(false), ownMemory(true), indestructible(true), explicitIndestructibleSet(false), |
727 | hasTaintedV4Object(false), isQueuedForDeletion(false), rootObjectInCreation(false), |
728 | hasInterceptorMetaObject(false), hasVMEMetaObject(false), parentFrozen(false), |
729 | bindingBitsArraySize(InlineBindingArraySize), notifyList(nullptr), |
730 | bindings(nullptr), signalHandlers(nullptr), nextContextObject(nullptr), prevContextObject(nullptr), |
731 | lineNumber(0), columnNumber(0), jsEngineId(0), |
732 | propertyCache(nullptr), guards(nullptr), extendedData(nullptr) |
733 | { |
734 | memset(s: bindingBitsValue, c: 0, n: sizeof(bindingBitsValue)); |
735 | init(); |
736 | } |
737 | |
738 | QQmlData::~QQmlData() |
739 | { |
740 | } |
741 | |
742 | void QQmlData::destroyed(QAbstractDeclarativeData *d, QObject *o) |
743 | { |
744 | QQmlData *ddata = static_cast<QQmlData *>(d); |
745 | if (ddata->ownedByQml1) |
746 | return; |
747 | ddata->destroyed(o); |
748 | } |
749 | |
750 | void QQmlData::parentChanged(QAbstractDeclarativeData *d, QObject *o, QObject *p) |
751 | { |
752 | QQmlData *ddata = static_cast<QQmlData *>(d); |
753 | if (ddata->ownedByQml1) |
754 | return; |
755 | ddata->parentChanged(o, p); |
756 | } |
757 | |
758 | class QQmlThreadNotifierProxyObject : public QObject |
759 | { |
760 | public: |
761 | QPointer<QObject> target; |
762 | |
763 | int qt_metacall(QMetaObject::Call, int methodIndex, void **a) override { |
764 | if (!target) |
765 | return -1; |
766 | |
767 | QMetaMethod method = target->metaObject()->method(index: methodIndex); |
768 | Q_ASSERT(method.methodType() == QMetaMethod::Signal); |
769 | int signalIndex = QMetaObjectPrivate::signalIndex(m: method); |
770 | QQmlData *ddata = QQmlData::get(object: target, create: false); |
771 | QQmlNotifierEndpoint *ep = ddata->notify(index: signalIndex); |
772 | if (ep) QQmlNotifier::emitNotify(ep, a); |
773 | |
774 | delete this; |
775 | |
776 | return -1; |
777 | } |
778 | }; |
779 | |
780 | void QQmlData::signalEmitted(QAbstractDeclarativeData *, QObject *object, int index, void **a) |
781 | { |
782 | QQmlData *ddata = QQmlData::get(object, create: false); |
783 | if (!ddata) return; // Probably being deleted |
784 | if (ddata->ownedByQml1) return; |
785 | |
786 | // In general, QML only supports QObject's that live on the same thread as the QQmlEngine |
787 | // that they're exposed to. However, to make writing "worker objects" that calculate data |
788 | // in a separate thread easier, QML allows a QObject that lives in the same thread as the |
789 | // QQmlEngine to emit signals from a different thread. These signals are then automatically |
790 | // marshalled back onto the QObject's thread and handled by QML from there. This is tested |
791 | // by the qqmlecmascript::threadSignal() autotest. |
792 | if (!ddata->notifyList) |
793 | return; |
794 | |
795 | auto objectThreadData = QObjectPrivate::get(o: object)->threadData.loadRelaxed(); |
796 | if (QThread::currentThreadId() != objectThreadData->threadId.loadRelaxed()) { |
797 | if (!objectThreadData->thread.loadAcquire()) |
798 | return; |
799 | |
800 | QMetaMethod m = QMetaObjectPrivate::signal(m: object->metaObject(), signal_index: index); |
801 | QList<QByteArray> parameterTypes = m.parameterTypes(); |
802 | |
803 | QScopedPointer<QMetaCallEvent> ev(new QMetaCallEvent(m.methodIndex(), 0, nullptr, |
804 | object, index, |
805 | parameterTypes.count() + 1)); |
806 | |
807 | void **args = ev->args(); |
808 | int *types = ev->types(); |
809 | |
810 | for (int ii = 0; ii < parameterTypes.count(); ++ii) { |
811 | const QByteArray &typeName = parameterTypes.at(i: ii); |
812 | if (typeName.endsWith(c: '*')) |
813 | types[ii + 1] = QMetaType::VoidStar; |
814 | else |
815 | types[ii + 1] = QMetaType::type(typeName); |
816 | |
817 | if (!types[ii + 1]) { |
818 | qWarning(msg: "QObject::connect: Cannot queue arguments of type '%s'\n" |
819 | "(Make sure '%s' is registered using qRegisterMetaType().)" , |
820 | typeName.constData(), typeName.constData()); |
821 | return; |
822 | } |
823 | |
824 | args[ii + 1] = QMetaType::create(type: types[ii + 1], copy: a[ii + 1]); |
825 | } |
826 | |
827 | QQmlThreadNotifierProxyObject *mpo = new QQmlThreadNotifierProxyObject; |
828 | mpo->target = object; |
829 | mpo->moveToThread(thread: objectThreadData->thread.loadAcquire()); |
830 | QCoreApplication::postEvent(receiver: mpo, event: ev.take()); |
831 | |
832 | } else { |
833 | QQmlNotifierEndpoint *ep = ddata->notify(index); |
834 | if (ep) QQmlNotifier::emitNotify(ep, a); |
835 | } |
836 | } |
837 | |
838 | int QQmlData::receivers(QAbstractDeclarativeData *d, const QObject *, int index) |
839 | { |
840 | QQmlData *ddata = static_cast<QQmlData *>(d); |
841 | if (ddata->ownedByQml1) |
842 | return 0; |
843 | return ddata->endpointCount(index); |
844 | } |
845 | |
846 | bool QQmlData::isSignalConnected(QAbstractDeclarativeData *d, const QObject *, int index) |
847 | { |
848 | QQmlData *ddata = static_cast<QQmlData *>(d); |
849 | if (ddata->ownedByQml1) |
850 | return false; |
851 | return ddata->signalHasEndpoint(index); |
852 | } |
853 | |
854 | int QQmlData::endpointCount(int index) |
855 | { |
856 | int count = 0; |
857 | QQmlNotifierEndpoint *ep = notify(index); |
858 | if (!ep) |
859 | return count; |
860 | ++count; |
861 | while (ep->next) { |
862 | ++count; |
863 | ep = ep->next; |
864 | } |
865 | return count; |
866 | } |
867 | |
868 | void QQmlData::markAsDeleted(QObject *o) |
869 | { |
870 | QQmlData::setQueuedForDeletion(o); |
871 | |
872 | QObjectPrivate *p = QObjectPrivate::get(o); |
873 | for (QList<QObject *>::const_iterator it = p->children.constBegin(), end = p->children.constEnd(); it != end; ++it) { |
874 | QQmlData::markAsDeleted(o: *it); |
875 | } |
876 | } |
877 | |
878 | void QQmlData::setQueuedForDeletion(QObject *object) |
879 | { |
880 | if (object) { |
881 | if (QQmlData *ddata = QQmlData::get(object)) { |
882 | if (ddata->ownContext) { |
883 | Q_ASSERT(ddata->ownContext == ddata->context); |
884 | ddata->context->emitDestruction(); |
885 | if (ddata->ownContext->contextObject == object) |
886 | ddata->ownContext->contextObject = nullptr; |
887 | ddata->ownContext = nullptr; |
888 | ddata->context = nullptr; |
889 | } |
890 | ddata->isQueuedForDeletion = true; |
891 | } |
892 | } |
893 | } |
894 | |
895 | void QQmlData::flushPendingBindingImpl(QQmlPropertyIndex index) |
896 | { |
897 | clearPendingBindingBit(coreIndex: index.coreIndex()); |
898 | |
899 | // Find the binding |
900 | QQmlAbstractBinding *b = bindings; |
901 | while (b && (b->targetPropertyIndex().coreIndex() != index.coreIndex() || |
902 | b->targetPropertyIndex().hasValueTypeIndex())) |
903 | b = b->nextBinding(); |
904 | |
905 | if (b && b->targetPropertyIndex().coreIndex() == index.coreIndex() && |
906 | !b->targetPropertyIndex().hasValueTypeIndex()) |
907 | b->setEnabled(e: true, f: QQmlPropertyData::BypassInterceptor | |
908 | QQmlPropertyData::DontRemoveBinding); |
909 | } |
910 | |
911 | QQmlData::DeferredData::DeferredData() |
912 | { |
913 | } |
914 | |
915 | QQmlData::DeferredData::~DeferredData() |
916 | { |
917 | } |
918 | |
919 | bool QQmlEnginePrivate::baseModulesUninitialized = true; |
920 | void QQmlEnginePrivate::init() |
921 | { |
922 | Q_Q(QQmlEngine); |
923 | |
924 | if (baseModulesUninitialized) { |
925 | |
926 | // required for the Compiler. |
927 | qmlRegisterType<QObject>(uri: "QML" , versionMajor: 1, versionMinor: 0, qmlName: "QtObject" ); |
928 | qmlRegisterType<QQmlComponent>(uri: "QML" , versionMajor: 1, versionMinor: 0, qmlName: "Component" ); |
929 | |
930 | QQmlData::init(); |
931 | baseModulesUninitialized = false; |
932 | } |
933 | |
934 | qRegisterMetaType<QVariant>(); |
935 | qRegisterMetaType<QQmlScriptString>(); |
936 | qRegisterMetaType<QJSValue>(); |
937 | qRegisterMetaType<QQmlComponent::Status>(); |
938 | qRegisterMetaType<QList<QObject*> >(); |
939 | qRegisterMetaType<QList<int> >(); |
940 | qRegisterMetaType<QQmlBinding*>(); |
941 | |
942 | q->handle()->setQmlEngine(q); |
943 | |
944 | rootContext = new QQmlContext(q,true); |
945 | } |
946 | |
947 | /*! |
948 | \class QQmlEngine |
949 | \since 5.0 |
950 | \inmodule QtQml |
951 | \brief The QQmlEngine class provides an environment for instantiating QML components. |
952 | |
953 | Each QML component is instantiated in a QQmlContext. |
954 | QQmlContext's are essential for passing data to QML |
955 | components. In QML, contexts are arranged hierarchically and this |
956 | hierarchy is managed by the QQmlEngine. |
957 | |
958 | Prior to creating any QML components, an application must have |
959 | created a QQmlEngine to gain access to a QML context. The |
960 | following example shows how to create a simple Text item. |
961 | |
962 | \code |
963 | QQmlEngine engine; |
964 | QQmlComponent component(&engine); |
965 | component.setData("import QtQuick 2.0\nText { text: \"Hello world!\" }", QUrl()); |
966 | QQuickItem *item = qobject_cast<QQuickItem *>(component.create()); |
967 | |
968 | //add item to view, etc |
969 | ... |
970 | \endcode |
971 | |
972 | In this case, the Text item will be created in the engine's |
973 | \l {QQmlEngine::rootContext()}{root context}. |
974 | |
975 | \sa QQmlComponent, QQmlContext, {QML Global Object} |
976 | */ |
977 | |
978 | /*! |
979 | Create a new QQmlEngine with the given \a parent. |
980 | */ |
981 | QQmlEngine::QQmlEngine(QObject *parent) |
982 | : QJSEngine(*new QQmlEnginePrivate(this), parent) |
983 | { |
984 | Q_D(QQmlEngine); |
985 | d->init(); |
986 | QJSEnginePrivate::addToDebugServer(q: this); |
987 | } |
988 | |
989 | /*! |
990 | * \internal |
991 | */ |
992 | QQmlEngine::QQmlEngine(QQmlEnginePrivate &dd, QObject *parent) |
993 | : QJSEngine(dd, parent) |
994 | { |
995 | Q_D(QQmlEngine); |
996 | d->init(); |
997 | } |
998 | |
999 | /*! |
1000 | Destroys the QQmlEngine. |
1001 | |
1002 | Any QQmlContext's created on this engine will be |
1003 | invalidated, but not destroyed (unless they are parented to the |
1004 | QQmlEngine object). |
1005 | |
1006 | See QJSEngine docs for details on cleaning up the JS engine. |
1007 | */ |
1008 | QQmlEngine::~QQmlEngine() |
1009 | { |
1010 | Q_D(QQmlEngine); |
1011 | QJSEnginePrivate::removeFromDebugServer(q: this); |
1012 | |
1013 | // Emit onDestruction signals for the root context before |
1014 | // we destroy the contexts, engine, Singleton Types etc. that |
1015 | // may be required to handle the destruction signal. |
1016 | QQmlContextData::get(context: rootContext())->emitDestruction(); |
1017 | |
1018 | // clean up all singleton type instances which we own. |
1019 | // we do this here and not in the private dtor since otherwise a crash can |
1020 | // occur (if we are the QObject parent of the QObject singleton instance) |
1021 | // XXX TODO: performance -- store list of singleton types separately? |
1022 | const QList<QQmlType> singletonTypes = QQmlMetaType::qmlSingletonTypes(); |
1023 | for (const QQmlType &currType : singletonTypes) |
1024 | d->destroySingletonInstance(type: currType); |
1025 | |
1026 | delete d->rootContext; |
1027 | d->rootContext = nullptr; |
1028 | |
1029 | d->typeLoader.invalidate(); |
1030 | } |
1031 | |
1032 | /*! \fn void QQmlEngine::quit() |
1033 | This signal is emitted when the QML loaded by the engine would like to quit. |
1034 | |
1035 | \sa exit() |
1036 | */ |
1037 | |
1038 | /*! \fn void QQmlEngine::exit(int retCode) |
1039 | This signal is emitted when the QML loaded by the engine would like to exit |
1040 | from the event loop with the specified return code \a retCode. |
1041 | |
1042 | \since 5.8 |
1043 | \sa quit() |
1044 | */ |
1045 | |
1046 | |
1047 | /*! \fn void QQmlEngine::warnings(const QList<QQmlError> &warnings) |
1048 | This signal is emitted when \a warnings messages are generated by QML. |
1049 | */ |
1050 | |
1051 | /*! |
1052 | Clears the engine's internal component cache. |
1053 | |
1054 | This function causes the property metadata of all components previously |
1055 | loaded by the engine to be destroyed. All previously loaded components and |
1056 | the property bindings for all extant objects created from those components will |
1057 | cease to function. |
1058 | |
1059 | This function returns the engine to a state where it does not contain any loaded |
1060 | component data. This may be useful in order to reload a smaller subset of the |
1061 | previous component set, or to load a new version of a previously loaded component. |
1062 | |
1063 | Once the component cache has been cleared, components must be loaded before |
1064 | any new objects can be created. |
1065 | |
1066 | \sa trimComponentCache() |
1067 | */ |
1068 | void QQmlEngine::clearComponentCache() |
1069 | { |
1070 | Q_D(QQmlEngine); |
1071 | d->typeLoader.lock(); |
1072 | d->typeLoader.clearCache(); |
1073 | d->typeLoader.unlock(); |
1074 | } |
1075 | |
1076 | /*! |
1077 | Trims the engine's internal component cache. |
1078 | |
1079 | This function causes the property metadata of any loaded components which are |
1080 | not currently in use to be destroyed. |
1081 | |
1082 | A component is considered to be in use if there are any extant instances of |
1083 | the component itself, any instances of other components that use the component, |
1084 | or any objects instantiated by any of those components. |
1085 | |
1086 | \sa clearComponentCache() |
1087 | */ |
1088 | void QQmlEngine::trimComponentCache() |
1089 | { |
1090 | Q_D(QQmlEngine); |
1091 | d->typeLoader.trimCache(); |
1092 | } |
1093 | |
1094 | /*! |
1095 | Returns the engine's root context. |
1096 | |
1097 | The root context is automatically created by the QQmlEngine. |
1098 | Data that should be available to all QML component instances |
1099 | instantiated by the engine should be put in the root context. |
1100 | |
1101 | Additional data that should only be available to a subset of |
1102 | component instances should be added to sub-contexts parented to the |
1103 | root context. |
1104 | */ |
1105 | QQmlContext *QQmlEngine::rootContext() const |
1106 | { |
1107 | Q_D(const QQmlEngine); |
1108 | return d->rootContext; |
1109 | } |
1110 | |
1111 | /*! |
1112 | \internal |
1113 | This API is private for 5.1 |
1114 | |
1115 | Sets the \a urlInterceptor to be used when resolving URLs in QML. |
1116 | This also applies to URLs used for loading script files and QML types. |
1117 | This should not be modifed while the engine is loading files, or URL |
1118 | selection may be inconsistent. |
1119 | */ |
1120 | void QQmlEngine::setUrlInterceptor(QQmlAbstractUrlInterceptor *urlInterceptor) |
1121 | { |
1122 | Q_D(QQmlEngine); |
1123 | d->urlInterceptor = urlInterceptor; |
1124 | } |
1125 | |
1126 | /*! |
1127 | \internal |
1128 | This API is private for 5.1 |
1129 | |
1130 | Returns the current QQmlAbstractUrlInterceptor. It must not be modified outside |
1131 | the GUI thread. |
1132 | */ |
1133 | QQmlAbstractUrlInterceptor *QQmlEngine::urlInterceptor() const |
1134 | { |
1135 | Q_D(const QQmlEngine); |
1136 | return d->urlInterceptor; |
1137 | } |
1138 | |
1139 | void QQmlEnginePrivate::registerFinalizeCallback(QObject *obj, int index) |
1140 | { |
1141 | if (activeObjectCreator) { |
1142 | activeObjectCreator->finalizeCallbacks()->append(t: qMakePair(x: QPointer<QObject>(obj), y: index)); |
1143 | } else { |
1144 | void *args[] = { nullptr }; |
1145 | QMetaObject::metacall(obj, QMetaObject::InvokeMetaMethod, index, args); |
1146 | } |
1147 | } |
1148 | |
1149 | QSharedPointer<QQmlImageProviderBase> QQmlEnginePrivate::imageProvider(const QString &providerId) const |
1150 | { |
1151 | const QString providerIdLower = providerId.toLower(); |
1152 | QMutexLocker locker(&mutex); |
1153 | return imageProviders.value(key: providerIdLower); |
1154 | } |
1155 | |
1156 | #if QT_CONFIG(qml_network) |
1157 | /*! |
1158 | Sets the \a factory to use for creating QNetworkAccessManager(s). |
1159 | |
1160 | QNetworkAccessManager is used for all network access by QML. By |
1161 | implementing a factory it is possible to create custom |
1162 | QNetworkAccessManager with specialized caching, proxy and cookie |
1163 | support. |
1164 | |
1165 | The factory must be set before executing the engine. |
1166 | |
1167 | \note QQmlEngine does not take ownership of the factory. |
1168 | */ |
1169 | void QQmlEngine::setNetworkAccessManagerFactory(QQmlNetworkAccessManagerFactory *factory) |
1170 | { |
1171 | Q_D(QQmlEngine); |
1172 | QMutexLocker locker(&d->networkAccessManagerMutex); |
1173 | d->networkAccessManagerFactory = factory; |
1174 | } |
1175 | |
1176 | /*! |
1177 | Returns the current QQmlNetworkAccessManagerFactory. |
1178 | |
1179 | \sa setNetworkAccessManagerFactory() |
1180 | */ |
1181 | QQmlNetworkAccessManagerFactory *QQmlEngine::networkAccessManagerFactory() const |
1182 | { |
1183 | Q_D(const QQmlEngine); |
1184 | return d->networkAccessManagerFactory; |
1185 | } |
1186 | |
1187 | QNetworkAccessManager *QQmlEnginePrivate::createNetworkAccessManager(QObject *parent) const |
1188 | { |
1189 | QMutexLocker locker(&networkAccessManagerMutex); |
1190 | QNetworkAccessManager *nam; |
1191 | if (networkAccessManagerFactory) { |
1192 | nam = networkAccessManagerFactory->create(parent); |
1193 | } else { |
1194 | nam = new QNetworkAccessManager(parent); |
1195 | } |
1196 | |
1197 | return nam; |
1198 | } |
1199 | |
1200 | QNetworkAccessManager *QQmlEnginePrivate::getNetworkAccessManager() const |
1201 | { |
1202 | Q_Q(const QQmlEngine); |
1203 | if (!networkAccessManager) |
1204 | networkAccessManager = createNetworkAccessManager(parent: const_cast<QQmlEngine*>(q)); |
1205 | return networkAccessManager; |
1206 | } |
1207 | |
1208 | /*! |
1209 | Returns a common QNetworkAccessManager which can be used by any QML |
1210 | type instantiated by this engine. |
1211 | |
1212 | If a QQmlNetworkAccessManagerFactory has been set and a |
1213 | QNetworkAccessManager has not yet been created, the |
1214 | QQmlNetworkAccessManagerFactory will be used to create the |
1215 | QNetworkAccessManager; otherwise the returned QNetworkAccessManager |
1216 | will have no proxy or cache set. |
1217 | |
1218 | \sa setNetworkAccessManagerFactory() |
1219 | */ |
1220 | QNetworkAccessManager *QQmlEngine::networkAccessManager() const |
1221 | { |
1222 | Q_D(const QQmlEngine); |
1223 | return d->getNetworkAccessManager(); |
1224 | } |
1225 | #endif // qml_network |
1226 | |
1227 | /*! |
1228 | |
1229 | Sets the \a provider to use for images requested via the \e |
1230 | image: url scheme, with host \a providerId. The QQmlEngine |
1231 | takes ownership of \a provider. |
1232 | |
1233 | Image providers enable support for pixmap and threaded image |
1234 | requests. See the QQuickImageProvider documentation for details on |
1235 | implementing and using image providers. |
1236 | |
1237 | All required image providers should be added to the engine before any |
1238 | QML sources files are loaded. |
1239 | |
1240 | \sa removeImageProvider(), QQuickImageProvider, QQmlImageProviderBase |
1241 | */ |
1242 | void QQmlEngine::addImageProvider(const QString &providerId, QQmlImageProviderBase *provider) |
1243 | { |
1244 | Q_D(QQmlEngine); |
1245 | QString providerIdLower = providerId.toLower(); |
1246 | QSharedPointer<QQmlImageProviderBase> sp(provider); |
1247 | QMutexLocker locker(&d->mutex); |
1248 | d->imageProviders.insert(key: std::move(providerIdLower), value: std::move(sp)); |
1249 | } |
1250 | |
1251 | /*! |
1252 | Returns the image provider set for \a providerId if found; otherwise returns \nullptr. |
1253 | |
1254 | \sa QQuickImageProvider |
1255 | */ |
1256 | QQmlImageProviderBase *QQmlEngine::imageProvider(const QString &providerId) const |
1257 | { |
1258 | Q_D(const QQmlEngine); |
1259 | const QString providerIdLower = providerId.toLower(); |
1260 | QMutexLocker locker(&d->mutex); |
1261 | return d->imageProviders.value(key: providerIdLower).data(); |
1262 | } |
1263 | |
1264 | /*! |
1265 | Removes the image provider for \a providerId. |
1266 | |
1267 | \sa addImageProvider(), QQuickImageProvider |
1268 | */ |
1269 | void QQmlEngine::removeImageProvider(const QString &providerId) |
1270 | { |
1271 | Q_D(QQmlEngine); |
1272 | const QString providerIdLower = providerId.toLower(); |
1273 | QMutexLocker locker(&d->mutex); |
1274 | d->imageProviders.take(key: providerIdLower); |
1275 | } |
1276 | |
1277 | /*! |
1278 | Return the base URL for this engine. The base URL is only used to |
1279 | resolve components when a relative URL is passed to the |
1280 | QQmlComponent constructor. |
1281 | |
1282 | If a base URL has not been explicitly set, this method returns the |
1283 | application's current working directory. |
1284 | |
1285 | \sa setBaseUrl() |
1286 | */ |
1287 | QUrl QQmlEngine::baseUrl() const |
1288 | { |
1289 | Q_D(const QQmlEngine); |
1290 | if (d->baseUrl.isEmpty()) { |
1291 | const QString currentPath = QDir::currentPath(); |
1292 | const QString rootPath = QDir::rootPath(); |
1293 | return QUrl::fromLocalFile(localfile: (currentPath == rootPath) ? rootPath : (currentPath + QDir::separator())); |
1294 | } else { |
1295 | return d->baseUrl; |
1296 | } |
1297 | } |
1298 | |
1299 | /*! |
1300 | Set the base URL for this engine to \a url. |
1301 | |
1302 | \sa baseUrl() |
1303 | */ |
1304 | void QQmlEngine::setBaseUrl(const QUrl &url) |
1305 | { |
1306 | Q_D(QQmlEngine); |
1307 | d->baseUrl = url; |
1308 | } |
1309 | |
1310 | /*! |
1311 | Returns true if warning messages will be output to stderr in addition |
1312 | to being emitted by the warnings() signal, otherwise false. |
1313 | |
1314 | The default value is true. |
1315 | */ |
1316 | bool QQmlEngine::outputWarningsToStandardError() const |
1317 | { |
1318 | Q_D(const QQmlEngine); |
1319 | return d->outputWarningsToMsgLog; |
1320 | } |
1321 | |
1322 | /*! |
1323 | Set whether warning messages will be output to stderr to \a enabled. |
1324 | |
1325 | If \a enabled is true, any warning messages generated by QML will be |
1326 | output to stderr and emitted by the warnings() signal. If \a enabled |
1327 | is false, only the warnings() signal will be emitted. This allows |
1328 | applications to handle warning output themselves. |
1329 | |
1330 | The default value is true. |
1331 | */ |
1332 | void QQmlEngine::setOutputWarningsToStandardError(bool enabled) |
1333 | { |
1334 | Q_D(QQmlEngine); |
1335 | d->outputWarningsToMsgLog = enabled; |
1336 | } |
1337 | |
1338 | /*! |
1339 | \qmlproperty string Qt::uiLanguage |
1340 | \since 5.15 |
1341 | |
1342 | The uiLanguage holds the name of the language to be used for user interface |
1343 | string translations. It is exposed in C++ as QQmlEngine::uiLanguage property. |
1344 | |
1345 | You can set the value freely and use it in bindings. It is recommended to set it |
1346 | after installing translators in your application. By convention, an empty string |
1347 | means no translation from the language used in the source code is intended to occur. |
1348 | |
1349 | If you're using QQmlApplicationEngine and the value changes, QQmlEngine::retranslate() |
1350 | will be called. |
1351 | */ |
1352 | |
1353 | /*! |
1354 | \fn template<typename T> T QQmlEngine::singletonInstance(int qmlTypeId) |
1355 | |
1356 | Returns the instance of a singleton type that was registered under \a qmlTypeId. |
1357 | |
1358 | The template argument \e T may be either QJSValue or a pointer to a QObject-derived |
1359 | type and depends on how the singleton was registered. If no instance of \e T has been |
1360 | created yet, it is created now. If \a qmlTypeId does not represent a valid singleton |
1361 | type, either a default constructed QJSValue or a \c nullptr is returned. |
1362 | |
1363 | QObject* example: |
1364 | \code |
1365 | class MySingleton : public QObject { |
1366 | Q_OBJECT |
1367 | |
1368 | // Register as default constructed singleton. |
1369 | QML_ELEMENT |
1370 | QML_SINGLETON |
1371 | |
1372 | static int typeId; |
1373 | // ... |
1374 | }; |
1375 | |
1376 | MySingleton::typeId = qmlTypeId(...); |
1377 | |
1378 | // Retrieve as QObject* |
1379 | QQmlEngine engine; |
1380 | MySingleton* instance = engine.singletonInstance<MySingleton*>(MySingleton::typeId); |
1381 | \endcode |
1382 | |
1383 | QJSValue example: |
1384 | \code |
1385 | // Register with QJSValue callback |
1386 | int typeId = qmlRegisterSingletonType(...); |
1387 | |
1388 | // Retrieve as QJSValue |
1389 | QQmlEngine engine; |
1390 | QJSValue instance = engine.singletonInstance<QJSValue>(typeId); |
1391 | \endcode |
1392 | |
1393 | It is recommended to store the QML type id, e.g. as a static member in the |
1394 | singleton class. The lookup via qmlTypeId() is costly. |
1395 | |
1396 | \sa QML_SINGLETON, qmlRegisterSingletonType(), qmlTypeId() |
1397 | \since 5.12 |
1398 | */ |
1399 | template<> |
1400 | QJSValue QQmlEngine::singletonInstance<QJSValue>(int qmlTypeId) |
1401 | { |
1402 | Q_D(QQmlEngine); |
1403 | QQmlType type = QQmlMetaType::qmlType(typeId: qmlTypeId, category: QQmlMetaType::TypeIdCategory::QmlType); |
1404 | |
1405 | if (!type.isValid() || !type.isSingleton()) |
1406 | return QJSValue(); |
1407 | |
1408 | return d->singletonInstance<QJSValue>(type); |
1409 | } |
1410 | |
1411 | /*! |
1412 | Refreshes all binding expressions that use strings marked for translation. |
1413 | |
1414 | Call this function after you have installed a new translator with |
1415 | QCoreApplication::installTranslator, to ensure that your user-interface |
1416 | shows up-to-date translations. |
1417 | |
1418 | \note Due to a limitation in the implementation, this function |
1419 | refreshes all the engine's bindings, not only those that use strings |
1420 | marked for translation. |
1421 | This may be optimized in a future release. |
1422 | |
1423 | \since 5.10 |
1424 | */ |
1425 | void QQmlEngine::retranslate() |
1426 | { |
1427 | Q_D(QQmlEngine); |
1428 | QQmlContextData *context = QQmlContextData::get(context: d->rootContext)->childContexts; |
1429 | while (context) { |
1430 | context->refreshExpressions(); |
1431 | context = context->nextChild; |
1432 | } |
1433 | } |
1434 | |
1435 | /*! |
1436 | Returns the QQmlContext for the \a object, or 0 if no |
1437 | context has been set. |
1438 | |
1439 | When the QQmlEngine instantiates a QObject, the context is |
1440 | set automatically. |
1441 | |
1442 | \sa qmlContext(), qmlEngine() |
1443 | */ |
1444 | QQmlContext *QQmlEngine::contextForObject(const QObject *object) |
1445 | { |
1446 | if(!object) |
1447 | return nullptr; |
1448 | |
1449 | QQmlData *data = QQmlData::get(object); |
1450 | if (data && data->outerContext) |
1451 | return data->outerContext->asQQmlContext(); |
1452 | |
1453 | return nullptr; |
1454 | } |
1455 | |
1456 | /*! |
1457 | Sets the QQmlContext for the \a object to \a context. |
1458 | If the \a object already has a context, a warning is |
1459 | output, but the context is not changed. |
1460 | |
1461 | When the QQmlEngine instantiates a QObject, the context is |
1462 | set automatically. |
1463 | */ |
1464 | void QQmlEngine::setContextForObject(QObject *object, QQmlContext *context) |
1465 | { |
1466 | if (!object || !context) |
1467 | return; |
1468 | |
1469 | QQmlData *data = QQmlData::get(object, create: true); |
1470 | if (data->context) { |
1471 | qWarning(msg: "QQmlEngine::setContextForObject(): Object already has a QQmlContext" ); |
1472 | return; |
1473 | } |
1474 | |
1475 | QQmlContextData *contextData = QQmlContextData::get(context); |
1476 | Q_ASSERT(data->context == nullptr); |
1477 | data->context = contextData; |
1478 | contextData->addObject(data); |
1479 | } |
1480 | |
1481 | /*! |
1482 | \enum QQmlEngine::ObjectOwnership |
1483 | |
1484 | ObjectOwnership controls whether or not QML automatically destroys the |
1485 | QObject when the corresponding JavaScript object is garbage collected by the |
1486 | engine. The two ownership options are: |
1487 | |
1488 | \value CppOwnership The object is owned by C++ code and QML will never delete |
1489 | it. The JavaScript destroy() method cannot be used on these objects. This |
1490 | option is similar to QScriptEngine::QtOwnership. |
1491 | |
1492 | \value JavaScriptOwnership The object is owned by JavaScript. When the object |
1493 | is returned to QML as the return value of a method call, QML will track it |
1494 | and delete it if there are no remaining JavaScript references to it and |
1495 | it has no QObject::parent(). An object tracked by one QQmlEngine will be |
1496 | deleted during that QQmlEngine's destructor. Thus, JavaScript references |
1497 | between objects with JavaScriptOwnership from two different engines will |
1498 | not be valid if one of these engines is deleted. This option is similar to |
1499 | QScriptEngine::ScriptOwnership. |
1500 | |
1501 | Generally an application doesn't need to set an object's ownership |
1502 | explicitly. QML uses a heuristic to set the default ownership. By default, an |
1503 | object that is created by QML has JavaScriptOwnership. The exception to this |
1504 | are the root objects created by calling QQmlComponent::create() or |
1505 | QQmlComponent::beginCreate(), which have CppOwnership by default. The |
1506 | ownership of these root-level objects is considered to have been transferred |
1507 | to the C++ caller. |
1508 | |
1509 | Objects not-created by QML have CppOwnership by default. The exception to this |
1510 | are objects returned from C++ method calls; their ownership will be set to |
1511 | JavaScriptOwnership. This applies only to explicit invocations of Q_INVOKABLE |
1512 | methods or slots, but not to property getter invocations. |
1513 | |
1514 | Calling setObjectOwnership() overrides the default ownership heuristic used by |
1515 | QML. |
1516 | */ |
1517 | |
1518 | /*! |
1519 | Sets the \a ownership of \a object. |
1520 | */ |
1521 | void QQmlEngine::setObjectOwnership(QObject *object, ObjectOwnership ownership) |
1522 | { |
1523 | if (!object) |
1524 | return; |
1525 | |
1526 | QQmlData *ddata = QQmlData::get(object, create: true); |
1527 | if (!ddata) |
1528 | return; |
1529 | |
1530 | ddata->indestructible = (ownership == CppOwnership)?true:false; |
1531 | ddata->explicitIndestructibleSet = true; |
1532 | } |
1533 | |
1534 | /*! |
1535 | Returns the ownership of \a object. |
1536 | */ |
1537 | QQmlEngine::ObjectOwnership QQmlEngine::objectOwnership(QObject *object) |
1538 | { |
1539 | if (!object) |
1540 | return CppOwnership; |
1541 | |
1542 | QQmlData *ddata = QQmlData::get(object, create: false); |
1543 | if (!ddata) |
1544 | return CppOwnership; |
1545 | else |
1546 | return ddata->indestructible?CppOwnership:JavaScriptOwnership; |
1547 | } |
1548 | |
1549 | /*! |
1550 | \reimp |
1551 | */ |
1552 | bool QQmlEngine::event(QEvent *e) |
1553 | { |
1554 | Q_D(QQmlEngine); |
1555 | if (e->type() == QEvent::User) |
1556 | d->doDeleteInEngineThread(); |
1557 | else if (e->type() == QEvent::LanguageChange) { |
1558 | retranslate(); |
1559 | } |
1560 | |
1561 | return QJSEngine::event(event: e); |
1562 | } |
1563 | |
1564 | void QQmlEnginePrivate::doDeleteInEngineThread() |
1565 | { |
1566 | QFieldList<Deletable, &Deletable::next> list; |
1567 | mutex.lock(); |
1568 | list.copyAndClear(toDeleteInEngineThread); |
1569 | mutex.unlock(); |
1570 | |
1571 | while (Deletable *d = list.takeFirst()) |
1572 | delete d; |
1573 | } |
1574 | |
1575 | namespace QtQml { |
1576 | |
1577 | void qmlExecuteDeferred(QObject *object) |
1578 | { |
1579 | QQmlData *data = QQmlData::get(object); |
1580 | |
1581 | if (data && !data->deferredData.isEmpty() && !data->wasDeleted(object)) { |
1582 | QQmlEnginePrivate *ep = QQmlEnginePrivate::get(e: data->context->engine); |
1583 | |
1584 | QQmlComponentPrivate::DeferredState state; |
1585 | QQmlComponentPrivate::beginDeferred(enginePriv: ep, object, deferredState: &state); |
1586 | |
1587 | // Release the reference for the deferral action (we still have one from construction) |
1588 | data->releaseDeferredData(); |
1589 | |
1590 | QQmlComponentPrivate::completeDeferred(enginePriv: ep, deferredState: &state); |
1591 | } |
1592 | } |
1593 | |
1594 | QQmlContext *qmlContext(const QObject *obj) |
1595 | { |
1596 | return QQmlEngine::contextForObject(object: obj); |
1597 | } |
1598 | |
1599 | QQmlEngine *qmlEngine(const QObject *obj) |
1600 | { |
1601 | QQmlData *data = QQmlData::get(object: obj, create: false); |
1602 | if (!data || !data->context) |
1603 | return nullptr; |
1604 | return data->context->engine; |
1605 | } |
1606 | |
1607 | static QObject *resolveAttachedProperties(QQmlAttachedPropertiesFunc pf, QQmlData *data, |
1608 | QObject *object, bool create) |
1609 | { |
1610 | if (!pf) |
1611 | return nullptr; |
1612 | |
1613 | QObject *rv = data->hasExtendedData() ? data->attachedProperties()->value(key: pf) : 0; |
1614 | if (rv || !create) |
1615 | return rv; |
1616 | |
1617 | rv = pf(object); |
1618 | |
1619 | if (rv) |
1620 | data->attachedProperties()->insert(key: pf, value: rv); |
1621 | |
1622 | return rv; |
1623 | } |
1624 | |
1625 | #if QT_DEPRECATED_SINCE(5, 14) |
1626 | QT_WARNING_PUSH |
1627 | QT_WARNING_DISABLE_DEPRECATED |
1628 | |
1629 | QObject *qmlAttachedPropertiesObjectById(int id, const QObject *object, bool create) |
1630 | { |
1631 | QQmlData *data = QQmlData::get(object, create); |
1632 | |
1633 | // Attached properties are only on objects created by QML, |
1634 | // unless explicitly requested (create==true) |
1635 | if (!data) |
1636 | return nullptr; |
1637 | |
1638 | QQmlEnginePrivate *engine = QQmlEnginePrivate::get(c: data->context); |
1639 | |
1640 | const QQmlType type = QQmlMetaType::qmlType(typeId: id, category: QQmlMetaType::TypeIdCategory::QmlType); |
1641 | return resolveAttachedProperties(pf: type.attachedPropertiesFunction(engine), data, |
1642 | object: const_cast<QObject *>(object), create); |
1643 | } |
1644 | |
1645 | QObject *qmlAttachedPropertiesObject(int *idCache, const QObject *object, |
1646 | const QMetaObject *attachedMetaObject, bool create) |
1647 | { |
1648 | if (*idCache == -1) { |
1649 | QQmlEngine *engine = object ? qmlEngine(obj: object) : nullptr; |
1650 | *idCache = QQmlMetaType::attachedPropertiesFuncId(engine: engine ? QQmlEnginePrivate::get(e: engine) : nullptr, attachedMetaObject); |
1651 | } |
1652 | |
1653 | if (*idCache == -1 || !object) |
1654 | return nullptr; |
1655 | |
1656 | return qmlAttachedPropertiesObjectById(id: *idCache, object, create); |
1657 | } |
1658 | |
1659 | QT_WARNING_POP |
1660 | #endif |
1661 | |
1662 | QQmlAttachedPropertiesFunc qmlAttachedPropertiesFunction(QObject *object, |
1663 | const QMetaObject *attachedMetaObject) |
1664 | { |
1665 | QQmlEngine *engine = object ? qmlEngine(obj: object) : nullptr; |
1666 | return QQmlMetaType::attachedPropertiesFunc(engine ? QQmlEnginePrivate::get(e: engine) : nullptr, |
1667 | attachedMetaObject); |
1668 | } |
1669 | |
1670 | QObject *qmlAttachedPropertiesObject(QObject *object, QQmlAttachedPropertiesFunc func, bool create) |
1671 | { |
1672 | if (!object) |
1673 | return nullptr; |
1674 | |
1675 | QQmlData *data = QQmlData::get(object, create); |
1676 | |
1677 | // Attached properties are only on objects created by QML, |
1678 | // unless explicitly requested (create==true) |
1679 | if (!data) |
1680 | return nullptr; |
1681 | |
1682 | return resolveAttachedProperties(pf: func, data, object, create); |
1683 | } |
1684 | |
1685 | } // namespace QtQml |
1686 | |
1687 | #if QT_DEPRECATED_SINCE(5, 1) |
1688 | QT_WARNING_PUSH |
1689 | QT_WARNING_DISABLE_DEPRECATED |
1690 | |
1691 | // Also define symbols outside namespace to keep binary compatibility with Qt 5.0 |
1692 | |
1693 | Q_QML_EXPORT void qmlExecuteDeferred(QObject *obj) |
1694 | { |
1695 | QtQml::qmlExecuteDeferred(object: obj); |
1696 | } |
1697 | |
1698 | Q_QML_EXPORT QQmlContext *qmlContext(const QObject *obj) |
1699 | { |
1700 | return QtQml::qmlContext(obj); |
1701 | } |
1702 | |
1703 | Q_QML_EXPORT QQmlEngine *qmlEngine(const QObject *obj) |
1704 | { |
1705 | return QtQml::qmlEngine(obj); |
1706 | } |
1707 | |
1708 | Q_QML_EXPORT QObject *qmlAttachedPropertiesObjectById(int id, const QObject *obj, bool create) |
1709 | { |
1710 | return QtQml::qmlAttachedPropertiesObjectById(id, object: obj, create); |
1711 | } |
1712 | |
1713 | Q_QML_EXPORT QObject *qmlAttachedPropertiesObject(int *idCache, const QObject *object, |
1714 | const QMetaObject *attachedMetaObject, |
1715 | bool create) |
1716 | { |
1717 | return QtQml::qmlAttachedPropertiesObject(idCache, object, attachedMetaObject, create); |
1718 | } |
1719 | |
1720 | QT_WARNING_POP |
1721 | #endif // QT_DEPRECATED_SINCE(5, 1) |
1722 | |
1723 | class QQmlDataExtended { |
1724 | public: |
1725 | QQmlDataExtended(); |
1726 | ~QQmlDataExtended(); |
1727 | |
1728 | QHash<QQmlAttachedPropertiesFunc, QObject *> attachedProperties; |
1729 | }; |
1730 | |
1731 | QQmlDataExtended::QQmlDataExtended() |
1732 | { |
1733 | } |
1734 | |
1735 | QQmlDataExtended::~QQmlDataExtended() |
1736 | { |
1737 | } |
1738 | |
1739 | void QQmlData::NotifyList::layout(QQmlNotifierEndpoint *endpoint) |
1740 | { |
1741 | // Add a temporary sentinel at beginning of list. This will be overwritten |
1742 | // when the end point is inserted into the notifies further down. |
1743 | endpoint->prev = nullptr; |
1744 | |
1745 | while (endpoint->next) { |
1746 | Q_ASSERT(reinterpret_cast<QQmlNotifierEndpoint *>(endpoint->next->prev) == endpoint); |
1747 | endpoint = endpoint->next; |
1748 | } |
1749 | |
1750 | while (endpoint) { |
1751 | QQmlNotifierEndpoint *ep = (QQmlNotifierEndpoint *) endpoint->prev; |
1752 | |
1753 | int index = endpoint->sourceSignal; |
1754 | index = qMin(a: index, b: 0xFFFF - 1); |
1755 | |
1756 | endpoint->next = notifies[index]; |
1757 | if (endpoint->next) endpoint->next->prev = &endpoint->next; |
1758 | endpoint->prev = ¬ifies[index]; |
1759 | notifies[index] = endpoint; |
1760 | |
1761 | endpoint = ep; |
1762 | } |
1763 | } |
1764 | |
1765 | void QQmlData::NotifyList::layout() |
1766 | { |
1767 | Q_ASSERT(maximumTodoIndex >= notifiesSize); |
1768 | |
1769 | if (todo) { |
1770 | QQmlNotifierEndpoint **old = notifies; |
1771 | const int reallocSize = (maximumTodoIndex + 1) * sizeof(QQmlNotifierEndpoint*); |
1772 | notifies = (QQmlNotifierEndpoint**)realloc(ptr: notifies, size: reallocSize); |
1773 | const int memsetSize = (maximumTodoIndex - notifiesSize + 1) * |
1774 | sizeof(QQmlNotifierEndpoint*); |
1775 | memset(s: notifies + notifiesSize, c: 0, n: memsetSize); |
1776 | |
1777 | if (notifies != old) { |
1778 | for (int ii = 0; ii < notifiesSize; ++ii) |
1779 | if (notifies[ii]) |
1780 | notifies[ii]->prev = ¬ifies[ii]; |
1781 | } |
1782 | |
1783 | notifiesSize = maximumTodoIndex + 1; |
1784 | |
1785 | layout(endpoint: todo); |
1786 | } |
1787 | |
1788 | maximumTodoIndex = 0; |
1789 | todo = nullptr; |
1790 | } |
1791 | |
1792 | void QQmlData::deferData(int objectIndex, const QQmlRefPointer<QV4::ExecutableCompilationUnit> &compilationUnit, QQmlContextData *context) |
1793 | { |
1794 | QQmlData::DeferredData *deferData = new QQmlData::DeferredData; |
1795 | deferData->deferredIdx = objectIndex; |
1796 | deferData->compilationUnit = compilationUnit; |
1797 | deferData->context = context; |
1798 | |
1799 | const QV4::CompiledData::Object *compiledObject = compilationUnit->objectAt(index: objectIndex); |
1800 | const QV4::BindingPropertyData &propertyData = compilationUnit->bindingPropertyDataPerObject.at(i: objectIndex); |
1801 | |
1802 | const QV4::CompiledData::Binding *binding = compiledObject->bindingTable(); |
1803 | for (quint32 i = 0; i < compiledObject->nBindings; ++i, ++binding) { |
1804 | const QQmlPropertyData *property = propertyData.at(i); |
1805 | if (property && binding->flags & QV4::CompiledData::Binding::IsDeferredBinding) |
1806 | deferData->bindings.insert(key: property->coreIndex(), value: binding); |
1807 | } |
1808 | |
1809 | deferredData.append(t: deferData); |
1810 | } |
1811 | |
1812 | void QQmlData::releaseDeferredData() |
1813 | { |
1814 | auto it = deferredData.begin(); |
1815 | while (it != deferredData.end()) { |
1816 | DeferredData *deferData = *it; |
1817 | if (deferData->bindings.isEmpty()) { |
1818 | delete deferData; |
1819 | it = deferredData.erase(pos: it); |
1820 | } else { |
1821 | ++it; |
1822 | } |
1823 | } |
1824 | } |
1825 | |
1826 | void QQmlData::addNotify(int index, QQmlNotifierEndpoint *endpoint) |
1827 | { |
1828 | if (!notifyList) { |
1829 | notifyList = (NotifyList *)malloc(size: sizeof(NotifyList)); |
1830 | notifyList->connectionMask = 0; |
1831 | notifyList->maximumTodoIndex = 0; |
1832 | notifyList->notifiesSize = 0; |
1833 | notifyList->todo = nullptr; |
1834 | notifyList->notifies = nullptr; |
1835 | } |
1836 | |
1837 | Q_ASSERT(!endpoint->isConnected()); |
1838 | |
1839 | index = qMin(a: index, b: 0xFFFF - 1); |
1840 | notifyList->connectionMask |= (1ULL << quint64(index % 64)); |
1841 | |
1842 | if (index < notifyList->notifiesSize) { |
1843 | |
1844 | endpoint->next = notifyList->notifies[index]; |
1845 | if (endpoint->next) endpoint->next->prev = &endpoint->next; |
1846 | endpoint->prev = ¬ifyList->notifies[index]; |
1847 | notifyList->notifies[index] = endpoint; |
1848 | |
1849 | } else { |
1850 | notifyList->maximumTodoIndex = qMax(a: int(notifyList->maximumTodoIndex), b: index); |
1851 | |
1852 | endpoint->next = notifyList->todo; |
1853 | if (endpoint->next) endpoint->next->prev = &endpoint->next; |
1854 | endpoint->prev = ¬ifyList->todo; |
1855 | notifyList->todo = endpoint; |
1856 | } |
1857 | } |
1858 | |
1859 | void QQmlData::disconnectNotifiers() |
1860 | { |
1861 | if (notifyList) { |
1862 | while (notifyList->todo) |
1863 | notifyList->todo->disconnect(); |
1864 | for (int ii = 0; ii < notifyList->notifiesSize; ++ii) { |
1865 | while (QQmlNotifierEndpoint *ep = notifyList->notifies[ii]) |
1866 | ep->disconnect(); |
1867 | } |
1868 | free(ptr: notifyList->notifies); |
1869 | free(ptr: notifyList); |
1870 | notifyList = nullptr; |
1871 | } |
1872 | } |
1873 | |
1874 | QHash<QQmlAttachedPropertiesFunc, QObject *> *QQmlData::attachedProperties() const |
1875 | { |
1876 | if (!extendedData) extendedData = new QQmlDataExtended; |
1877 | return &extendedData->attachedProperties; |
1878 | } |
1879 | |
1880 | void QQmlData::destroyed(QObject *object) |
1881 | { |
1882 | if (nextContextObject) |
1883 | nextContextObject->prevContextObject = prevContextObject; |
1884 | if (prevContextObject) |
1885 | *prevContextObject = nextContextObject; |
1886 | else if (outerContext && outerContext->contextObjects == this) |
1887 | outerContext->contextObjects = nextContextObject; |
1888 | |
1889 | QQmlAbstractBinding *binding = bindings; |
1890 | while (binding) { |
1891 | binding->setAddedToObject(false); |
1892 | binding = binding->nextBinding(); |
1893 | } |
1894 | if (bindings && !bindings->ref.deref()) |
1895 | delete bindings; |
1896 | |
1897 | compilationUnit = nullptr; |
1898 | |
1899 | qDeleteAll(c: deferredData); |
1900 | deferredData.clear(); |
1901 | |
1902 | QQmlBoundSignal *signalHandler = signalHandlers; |
1903 | while (signalHandler) { |
1904 | if (signalHandler->isNotifying()) { |
1905 | // The object is being deleted during signal handler evaluation. |
1906 | // This will cause a crash due to invalid memory access when the |
1907 | // evaluation has completed. |
1908 | // Abort with a friendly message instead. |
1909 | QString locationString; |
1910 | QQmlBoundSignalExpression *expr = signalHandler->expression(); |
1911 | if (expr) { |
1912 | QQmlSourceLocation location = expr->sourceLocation(); |
1913 | if (location.sourceFile.isEmpty()) |
1914 | location.sourceFile = QStringLiteral("<Unknown File>" ); |
1915 | locationString.append(s: location.sourceFile); |
1916 | locationString.append(QStringLiteral(":%0: " ).arg(a: location.line)); |
1917 | QString source = expr->expression(); |
1918 | if (source.size() > 100) { |
1919 | source.truncate(pos: 96); |
1920 | source.append(s: QLatin1String(" ..." )); |
1921 | } |
1922 | locationString.append(s: source); |
1923 | } else { |
1924 | locationString = QStringLiteral("<Unknown Location>" ); |
1925 | } |
1926 | qFatal(msg: "Object %p destroyed while one of its QML signal handlers is in progress.\n" |
1927 | "Most likely the object was deleted synchronously (use QObject::deleteLater() " |
1928 | "instead), or the application is running a nested event loop.\n" |
1929 | "This behavior is NOT supported!\n" |
1930 | "%s" , object, qPrintable(locationString)); |
1931 | } |
1932 | |
1933 | QQmlBoundSignal *next = signalHandler->m_nextSignal; |
1934 | signalHandler->m_prevSignal = nullptr; |
1935 | signalHandler->m_nextSignal = nullptr; |
1936 | delete signalHandler; |
1937 | signalHandler = next; |
1938 | } |
1939 | |
1940 | if (bindingBitsArraySize > InlineBindingArraySize) |
1941 | free(ptr: bindingBits); |
1942 | |
1943 | if (propertyCache) |
1944 | propertyCache->release(); |
1945 | |
1946 | ownContext = nullptr; |
1947 | |
1948 | while (guards) { |
1949 | QQmlGuard<QObject> *guard = static_cast<QQmlGuard<QObject> *>(guards); |
1950 | *guard = (QObject *)nullptr; |
1951 | guard->objectDestroyed(object); |
1952 | } |
1953 | |
1954 | disconnectNotifiers(); |
1955 | |
1956 | if (extendedData) |
1957 | delete extendedData; |
1958 | |
1959 | // Dispose the handle. |
1960 | jsWrapper.clear(); |
1961 | |
1962 | if (ownMemory) |
1963 | delete this; |
1964 | else |
1965 | this->~QQmlData(); |
1966 | } |
1967 | |
1968 | DEFINE_BOOL_CONFIG_OPTION(parentTest, QML_PARENT_TEST); |
1969 | |
1970 | void QQmlData::parentChanged(QObject *object, QObject *parent) |
1971 | { |
1972 | if (parentTest()) { |
1973 | if (parentFrozen && !QObjectPrivate::get(o: object)->wasDeleted) { |
1974 | QString on; |
1975 | QString pn; |
1976 | |
1977 | { QDebug dbg(&on); dbg << object; on = on.left(n: on.length() - 1); } |
1978 | { QDebug dbg(&pn); dbg << parent; pn = pn.left(n: pn.length() - 1); } |
1979 | |
1980 | qFatal(msg: "Object %s has had its parent frozen by QML and cannot be changed.\n" |
1981 | "User code is attempting to change it to %s.\n" |
1982 | "This behavior is NOT supported!" , qPrintable(on), qPrintable(pn)); |
1983 | } |
1984 | } |
1985 | } |
1986 | |
1987 | QQmlData::BindingBitsType *QQmlData::growBits(QObject *obj, int bit) |
1988 | { |
1989 | BindingBitsType *bits = (bindingBitsArraySize == InlineBindingArraySize) ? bindingBitsValue : bindingBits; |
1990 | int props = QQmlMetaObject(obj).propertyCount(); |
1991 | Q_ASSERT(bit < 2 * props); |
1992 | Q_UNUSED(bit); // .. for Q_NO_DEBUG mode when the assert above expands to empty |
1993 | |
1994 | uint arraySize = (2 * static_cast<uint>(props) + BitsPerType - 1) / BitsPerType; |
1995 | Q_ASSERT(arraySize > 1); |
1996 | Q_ASSERT(arraySize <= 0xffff); // max for bindingBitsArraySize |
1997 | |
1998 | BindingBitsType *newBits = static_cast<BindingBitsType *>(malloc(size: arraySize*sizeof(BindingBitsType))); |
1999 | memcpy(dest: newBits, src: bits, n: bindingBitsArraySize * sizeof(BindingBitsType)); |
2000 | memset(s: newBits + bindingBitsArraySize, c: 0, n: sizeof(BindingBitsType) * (arraySize - bindingBitsArraySize)); |
2001 | |
2002 | if (bindingBitsArraySize > InlineBindingArraySize) |
2003 | free(ptr: bits); |
2004 | bindingBits = newBits; |
2005 | bits = newBits; |
2006 | bindingBitsArraySize = arraySize; |
2007 | return bits; |
2008 | } |
2009 | |
2010 | QQmlData *QQmlData::createQQmlData(QObjectPrivate *priv) |
2011 | { |
2012 | Q_ASSERT(priv); |
2013 | Q_ASSERT(!priv->isDeletingChildren); |
2014 | priv->declarativeData = new QQmlData; |
2015 | return static_cast<QQmlData *>(priv->declarativeData); |
2016 | } |
2017 | |
2018 | QQmlPropertyCache *QQmlData::createPropertyCache(QJSEngine *engine, QObject *object) |
2019 | { |
2020 | QQmlData *ddata = QQmlData::get(object, /*create*/true); |
2021 | ddata->propertyCache = QJSEnginePrivate::get(e: engine)->cache(obj: object, minorVersion: -1, doRef: true); |
2022 | return ddata->propertyCache; |
2023 | } |
2024 | |
2025 | void QQmlEnginePrivate::sendQuit() |
2026 | { |
2027 | Q_Q(QQmlEngine); |
2028 | emit q->quit(); |
2029 | if (q->receivers(SIGNAL(quit())) == 0) { |
2030 | qWarning(msg: "Signal QQmlEngine::quit() emitted, but no receivers connected to handle it." ); |
2031 | } |
2032 | } |
2033 | |
2034 | void QQmlEnginePrivate::sendExit(int retCode) |
2035 | { |
2036 | Q_Q(QQmlEngine); |
2037 | if (q->receivers(SIGNAL(exit(int))) == 0) |
2038 | qWarning(msg: "Signal QQmlEngine::exit() emitted, but no receivers connected to handle it." ); |
2039 | emit q->exit(retCode); |
2040 | } |
2041 | |
2042 | static void dumpwarning(const QQmlError &error) |
2043 | { |
2044 | switch (error.messageType()) { |
2045 | case QtDebugMsg: |
2046 | QMessageLogger(error.url().toString().toLatin1().constData(), |
2047 | error.line(), nullptr).debug().nospace() |
2048 | << qPrintable(error.toString()); |
2049 | break; |
2050 | case QtInfoMsg: |
2051 | QMessageLogger(error.url().toString().toLatin1().constData(), |
2052 | error.line(), nullptr).info().nospace() |
2053 | << qPrintable(error.toString()); |
2054 | break; |
2055 | case QtWarningMsg: |
2056 | case QtFatalMsg: // fatal does not support streaming, and furthermore, is actually fatal. Probably not desirable for QML. |
2057 | QMessageLogger(error.url().toString().toLatin1().constData(), |
2058 | error.line(), nullptr).warning().nospace() |
2059 | << qPrintable(error.toString()); |
2060 | break; |
2061 | case QtCriticalMsg: |
2062 | QMessageLogger(error.url().toString().toLatin1().constData(), |
2063 | error.line(), nullptr).critical().nospace() |
2064 | << qPrintable(error.toString()); |
2065 | break; |
2066 | } |
2067 | } |
2068 | |
2069 | static void dumpwarning(const QList<QQmlError> &errors) |
2070 | { |
2071 | for (int ii = 0; ii < errors.count(); ++ii) |
2072 | dumpwarning(error: errors.at(i: ii)); |
2073 | } |
2074 | |
2075 | void QQmlEnginePrivate::warning(const QQmlError &error) |
2076 | { |
2077 | Q_Q(QQmlEngine); |
2078 | q->warnings(warnings: QList<QQmlError>() << error); |
2079 | if (outputWarningsToMsgLog) |
2080 | dumpwarning(error); |
2081 | } |
2082 | |
2083 | void QQmlEnginePrivate::warning(const QList<QQmlError> &errors) |
2084 | { |
2085 | Q_Q(QQmlEngine); |
2086 | q->warnings(warnings: errors); |
2087 | if (outputWarningsToMsgLog) |
2088 | dumpwarning(errors); |
2089 | } |
2090 | |
2091 | void QQmlEnginePrivate::warning(QQmlEngine *engine, const QQmlError &error) |
2092 | { |
2093 | if (engine) |
2094 | QQmlEnginePrivate::get(e: engine)->warning(error); |
2095 | else |
2096 | dumpwarning(error); |
2097 | } |
2098 | |
2099 | void QQmlEnginePrivate::warning(QQmlEngine *engine, const QList<QQmlError> &error) |
2100 | { |
2101 | if (engine) |
2102 | QQmlEnginePrivate::get(e: engine)->warning(errors: error); |
2103 | else |
2104 | dumpwarning(errors: error); |
2105 | } |
2106 | |
2107 | void QQmlEnginePrivate::warning(QQmlEnginePrivate *engine, const QQmlError &error) |
2108 | { |
2109 | if (engine) |
2110 | engine->warning(error); |
2111 | else |
2112 | dumpwarning(error); |
2113 | } |
2114 | |
2115 | void QQmlEnginePrivate::warning(QQmlEnginePrivate *engine, const QList<QQmlError> &error) |
2116 | { |
2117 | if (engine) |
2118 | engine->warning(errors: error); |
2119 | else |
2120 | dumpwarning(errors: error); |
2121 | } |
2122 | |
2123 | QList<QQmlError> QQmlEnginePrivate::qmlErrorFromDiagnostics( |
2124 | const QString &fileName, const QList<QQmlJS::DiagnosticMessage> &diagnosticMessages) |
2125 | { |
2126 | QList<QQmlError> errors; |
2127 | for (const QQmlJS::DiagnosticMessage &m : diagnosticMessages) { |
2128 | if (m.isWarning()) { |
2129 | qWarning(msg: "%s:%d : %s" , qPrintable(fileName), m.loc.startLine, qPrintable(m.message)); |
2130 | continue; |
2131 | } |
2132 | |
2133 | QQmlError error; |
2134 | error.setUrl(QUrl(fileName)); |
2135 | error.setDescription(m.message); |
2136 | error.setLine(qmlConvertSourceCoordinate<quint32, int>(n: m.loc.startLine)); |
2137 | error.setColumn(qmlConvertSourceCoordinate<quint32, int>(n: m.loc.startColumn)); |
2138 | errors << error; |
2139 | } |
2140 | return errors; |
2141 | } |
2142 | |
2143 | void QQmlEnginePrivate::cleanupScarceResources() |
2144 | { |
2145 | // iterate through the list and release them all. |
2146 | // note that the actual SRD is owned by the JS engine, |
2147 | // so we cannot delete the SRD; but we can free the |
2148 | // memory used by the variant in the SRD. |
2149 | QV4::ExecutionEngine *engine = v4engine(); |
2150 | while (QV4::ExecutionEngine::ScarceResourceData *sr = engine->scarceResources.first()) { |
2151 | sr->data = QVariant(); |
2152 | engine->scarceResources.remove(n: sr); |
2153 | } |
2154 | } |
2155 | |
2156 | /*! |
2157 | Adds \a path as a directory where the engine searches for |
2158 | installed modules in a URL-based directory structure. |
2159 | |
2160 | The \a path may be a local filesystem directory, a |
2161 | \l {The Qt Resource System}{Qt Resource} path (\c {:/imports}), a |
2162 | \l {The Qt Resource System}{Qt Resource} url (\c {qrc:/imports}) or a URL. |
2163 | |
2164 | The \a path will be converted into canonical form before it |
2165 | is added to the import path list. |
2166 | |
2167 | The newly added \a path will be first in the importPathList(). |
2168 | |
2169 | \sa setImportPathList(), {QML Modules} |
2170 | */ |
2171 | void QQmlEngine::addImportPath(const QString& path) |
2172 | { |
2173 | Q_D(QQmlEngine); |
2174 | d->importDatabase.addImportPath(dir: path); |
2175 | } |
2176 | |
2177 | /*! |
2178 | Returns the list of directories where the engine searches for |
2179 | installed modules in a URL-based directory structure. |
2180 | |
2181 | For example, if \c /opt/MyApp/lib/imports is in the path, then QML that |
2182 | imports \c com.mycompany.Feature will cause the QQmlEngine to look |
2183 | in \c /opt/MyApp/lib/imports/com/mycompany/Feature/ for the components |
2184 | provided by that module. A \c qmldir file is required for defining the |
2185 | type version mapping and possibly QML extensions plugins. |
2186 | |
2187 | By default, the list contains the directory of the application executable, |
2188 | paths specified in the \c QML2_IMPORT_PATH environment variable, |
2189 | and the builtin \c Qml2ImportsPath from QLibraryInfo. |
2190 | |
2191 | \sa addImportPath(), setImportPathList() |
2192 | */ |
2193 | QStringList QQmlEngine::importPathList() const |
2194 | { |
2195 | Q_D(const QQmlEngine); |
2196 | return d->importDatabase.importPathList(); |
2197 | } |
2198 | |
2199 | /*! |
2200 | Sets \a paths as the list of directories where the engine searches for |
2201 | installed modules in a URL-based directory structure. |
2202 | |
2203 | By default, the list contains the directory of the application executable, |
2204 | paths specified in the \c QML2_IMPORT_PATH environment variable, |
2205 | and the builtin \c Qml2ImportsPath from QLibraryInfo. |
2206 | |
2207 | \sa importPathList(), addImportPath() |
2208 | */ |
2209 | void QQmlEngine::setImportPathList(const QStringList &paths) |
2210 | { |
2211 | Q_D(QQmlEngine); |
2212 | d->importDatabase.setImportPathList(paths); |
2213 | } |
2214 | |
2215 | |
2216 | /*! |
2217 | Adds \a path as a directory where the engine searches for |
2218 | native plugins for imported modules (referenced in the \c qmldir file). |
2219 | |
2220 | By default, the list contains only \c ., i.e. the engine searches |
2221 | in the directory of the \c qmldir file itself. |
2222 | |
2223 | The newly added \a path will be first in the pluginPathList(). |
2224 | |
2225 | \sa setPluginPathList() |
2226 | */ |
2227 | void QQmlEngine::addPluginPath(const QString& path) |
2228 | { |
2229 | Q_D(QQmlEngine); |
2230 | d->importDatabase.addPluginPath(path); |
2231 | } |
2232 | |
2233 | |
2234 | /*! |
2235 | Returns the list of directories where the engine searches for |
2236 | native plugins for imported modules (referenced in the \c qmldir file). |
2237 | |
2238 | By default, the list contains only \c ., i.e. the engine searches |
2239 | in the directory of the \c qmldir file itself. |
2240 | |
2241 | \sa addPluginPath(), setPluginPathList() |
2242 | */ |
2243 | QStringList QQmlEngine::pluginPathList() const |
2244 | { |
2245 | Q_D(const QQmlEngine); |
2246 | return d->importDatabase.pluginPathList(); |
2247 | } |
2248 | |
2249 | /*! |
2250 | Sets the list of directories where the engine searches for |
2251 | native plugins for imported modules (referenced in the \c qmldir file) |
2252 | to \a paths. |
2253 | |
2254 | By default, the list contains only \c ., i.e. the engine searches |
2255 | in the directory of the \c qmldir file itself. |
2256 | |
2257 | \sa pluginPathList(), addPluginPath() |
2258 | */ |
2259 | void QQmlEngine::setPluginPathList(const QStringList &paths) |
2260 | { |
2261 | Q_D(QQmlEngine); |
2262 | d->importDatabase.setPluginPathList(paths); |
2263 | } |
2264 | |
2265 | #if QT_CONFIG(library) |
2266 | /*! |
2267 | Imports the plugin named \a filePath with the \a uri provided. |
2268 | Returns true if the plugin was successfully imported; otherwise returns false. |
2269 | |
2270 | On failure and if non-null, the \a errors list will have any errors which occurred prepended to it. |
2271 | |
2272 | The plugin has to be a Qt plugin which implements the QQmlEngineExtensionPlugin interface. |
2273 | */ |
2274 | bool QQmlEngine::importPlugin(const QString &filePath, const QString &uri, QList<QQmlError> *errors) |
2275 | { |
2276 | Q_D(QQmlEngine); |
2277 | return d->importDatabase.importDynamicPlugin(filePath, uri, importNamespace: QString(), vmaj: -1, errors); |
2278 | } |
2279 | #endif |
2280 | |
2281 | /*! |
2282 | \property QQmlEngine::offlineStoragePath |
2283 | \brief the directory for storing offline user data |
2284 | |
2285 | Returns the directory where SQL and other offline |
2286 | storage is placed. |
2287 | |
2288 | The SQL databases created with openDatabase() are stored here. |
2289 | |
2290 | The default is QML/OfflineStorage in the platform-standard |
2291 | user application data directory. |
2292 | |
2293 | Note that the path may not currently exist on the filesystem, so |
2294 | callers wanting to \e create new files at this location should create |
2295 | it first - see QDir::mkpath(). |
2296 | */ |
2297 | void QQmlEngine::setOfflineStoragePath(const QString& dir) |
2298 | { |
2299 | Q_D(QQmlEngine); |
2300 | d->offlineStoragePath = dir; |
2301 | } |
2302 | |
2303 | QString QQmlEngine::offlineStoragePath() const |
2304 | { |
2305 | Q_D(const QQmlEngine); |
2306 | |
2307 | if (d->offlineStoragePath.isEmpty()) { |
2308 | QString dataLocation = QStandardPaths::writableLocation(type: QStandardPaths::DataLocation); |
2309 | QQmlEnginePrivate *e = const_cast<QQmlEnginePrivate *>(d); |
2310 | if (!dataLocation.isEmpty()) |
2311 | e->offlineStoragePath = dataLocation.replace(before: QLatin1Char('/'), after: QDir::separator()) |
2312 | + QDir::separator() + QLatin1String("QML" ) |
2313 | + QDir::separator() + QLatin1String("OfflineStorage" ); |
2314 | } |
2315 | |
2316 | return d->offlineStoragePath; |
2317 | } |
2318 | |
2319 | /*! |
2320 | Returns the file path where a \l{QtQuick.LocalStorage}{Local Storage} |
2321 | database with the identifier \a databaseName is (or would be) located. |
2322 | |
2323 | \sa {openDatabaseSync}{LocalStorage.openDatabaseSync()} |
2324 | \since 5.9 |
2325 | */ |
2326 | QString QQmlEngine::offlineStorageDatabaseFilePath(const QString &databaseName) const |
2327 | { |
2328 | Q_D(const QQmlEngine); |
2329 | QCryptographicHash md5(QCryptographicHash::Md5); |
2330 | md5.addData(data: databaseName.toUtf8()); |
2331 | return d->offlineStorageDatabaseDirectory() + QLatin1String(md5.result().toHex()); |
2332 | } |
2333 | |
2334 | // #### Qt 6: Remove this function, it exists only for binary compatibility. |
2335 | /*! |
2336 | * \internal |
2337 | */ |
2338 | bool QQmlEngine::addNamedBundle(const QString &name, const QString &fileName) |
2339 | { |
2340 | Q_UNUSED(name) |
2341 | Q_UNUSED(fileName) |
2342 | return false; |
2343 | } |
2344 | |
2345 | QString QQmlEnginePrivate::offlineStorageDatabaseDirectory() const |
2346 | { |
2347 | Q_Q(const QQmlEngine); |
2348 | return q->offlineStoragePath() + QDir::separator() + QLatin1String("Databases" ) + QDir::separator(); |
2349 | } |
2350 | |
2351 | bool QQmlEnginePrivate::isQObject(int t) |
2352 | { |
2353 | Locker locker(this); |
2354 | return m_compositeTypes.contains(key: t) || QQmlMetaType::isQObject(t); |
2355 | } |
2356 | |
2357 | QObject *QQmlEnginePrivate::toQObject(const QVariant &v, bool *ok) const |
2358 | { |
2359 | Locker locker(this); |
2360 | int t = v.userType(); |
2361 | if (t == QMetaType::QObjectStar || m_compositeTypes.contains(key: t)) { |
2362 | if (ok) *ok = true; |
2363 | return *(QObject *const *)(v.constData()); |
2364 | } else { |
2365 | return QQmlMetaType::toQObject(v, ok); |
2366 | } |
2367 | } |
2368 | |
2369 | QQmlMetaType::TypeCategory QQmlEnginePrivate::typeCategory(int t) const |
2370 | { |
2371 | Locker locker(this); |
2372 | if (m_compositeTypes.contains(key: t)) |
2373 | return QQmlMetaType::Object; |
2374 | return QQmlMetaType::typeCategory(t); |
2375 | } |
2376 | |
2377 | bool QQmlEnginePrivate::isList(int t) const |
2378 | { |
2379 | return QQmlMetaType::isList(t); |
2380 | } |
2381 | |
2382 | int QQmlEnginePrivate::listType(int t) const |
2383 | { |
2384 | return QQmlMetaType::listType(t); |
2385 | } |
2386 | |
2387 | |
2388 | static QQmlPropertyCache *propertyCacheForPotentialInlineComponentType(int t, const QHash<int, QV4::ExecutableCompilationUnit *>::const_iterator &iter) { |
2389 | if (t != (*iter)->metaTypeId) { |
2390 | // this is an inline component, and what we have in the iterator is currently the parent compilation unit |
2391 | for (auto &&icDatum: (*iter)->inlineComponentData) |
2392 | if (icDatum.typeIds.id == t) |
2393 | return (*iter)->propertyCaches.at(index: icDatum.objectIndex); |
2394 | } |
2395 | return (*iter)->rootPropertyCache().data(); |
2396 | } |
2397 | |
2398 | QQmlMetaObject QQmlEnginePrivate::rawMetaObjectForType(int t) const |
2399 | { |
2400 | Locker locker(this); |
2401 | auto iter = m_compositeTypes.constFind(key: t); |
2402 | if (iter != m_compositeTypes.cend()) { |
2403 | return propertyCacheForPotentialInlineComponentType(t, iter); |
2404 | } else { |
2405 | QQmlType type = QQmlMetaType::qmlType(typeId: t); |
2406 | return QQmlMetaObject(type.baseMetaObject()); |
2407 | } |
2408 | } |
2409 | |
2410 | QQmlMetaObject QQmlEnginePrivate::metaObjectForType(int t) const |
2411 | { |
2412 | Locker locker(this); |
2413 | auto iter = m_compositeTypes.constFind(key: t); |
2414 | if (iter != m_compositeTypes.cend()) { |
2415 | return propertyCacheForPotentialInlineComponentType(t, iter); |
2416 | } else { |
2417 | QQmlType type = QQmlMetaType::qmlType(typeId: t); |
2418 | return QQmlMetaObject(type.metaObject()); |
2419 | } |
2420 | } |
2421 | |
2422 | QQmlPropertyCache *QQmlEnginePrivate::propertyCacheForType(int t) |
2423 | { |
2424 | Locker locker(this); |
2425 | auto iter = m_compositeTypes.constFind(key: t); |
2426 | if (iter != m_compositeTypes.cend()) { |
2427 | return propertyCacheForPotentialInlineComponentType(t, iter); |
2428 | } else { |
2429 | QQmlType type = QQmlMetaType::qmlType(typeId: t); |
2430 | locker.unlock(); |
2431 | return type.isValid() ? cache(metaObject: type.metaObject()) : nullptr; |
2432 | } |
2433 | } |
2434 | |
2435 | QQmlPropertyCache *QQmlEnginePrivate::rawPropertyCacheForType(int t, int minorVersion) |
2436 | { |
2437 | Locker locker(this); |
2438 | auto iter = m_compositeTypes.constFind(key: t); |
2439 | if (iter != m_compositeTypes.cend()) { |
2440 | return propertyCacheForPotentialInlineComponentType(t, iter); |
2441 | } else { |
2442 | QQmlType type = QQmlMetaType::qmlType(typeId: t); |
2443 | locker.unlock(); |
2444 | |
2445 | if (minorVersion >= 0) |
2446 | return type.isValid() ? cache(type, minorVersion) : nullptr; |
2447 | else |
2448 | return type.isValid() ? cache(metaObject: type.baseMetaObject()) : nullptr; |
2449 | } |
2450 | } |
2451 | |
2452 | void QQmlEnginePrivate::registerInternalCompositeType(QV4::ExecutableCompilationUnit *compilationUnit) |
2453 | { |
2454 | compilationUnit->isRegisteredWithEngine = true; |
2455 | |
2456 | Locker locker(this); |
2457 | // The QQmlCompiledData is not referenced here, but it is removed from this |
2458 | // hash in the QQmlCompiledData destructor |
2459 | m_compositeTypes.insert(key: compilationUnit->metaTypeId, value: compilationUnit); |
2460 | for (auto &&data: compilationUnit->inlineComponentData) { |
2461 | m_compositeTypes.insert(key: data.typeIds.id, value: compilationUnit); |
2462 | } |
2463 | } |
2464 | |
2465 | void QQmlEnginePrivate::unregisterInternalCompositeType(QV4::ExecutableCompilationUnit *compilationUnit) |
2466 | { |
2467 | compilationUnit->isRegisteredWithEngine = false; |
2468 | |
2469 | Locker locker(this); |
2470 | m_compositeTypes.remove(key: compilationUnit->metaTypeId); |
2471 | for (auto&& icDatum: compilationUnit->inlineComponentData) |
2472 | m_compositeTypes.remove(key: icDatum.typeIds.id); |
2473 | } |
2474 | |
2475 | QV4::ExecutableCompilationUnit *QQmlEnginePrivate::obtainExecutableCompilationUnit(int typeId) |
2476 | { |
2477 | Locker locker(this); |
2478 | return m_compositeTypes.value(key: typeId, defaultValue: nullptr); |
2479 | } |
2480 | |
2481 | template<> |
2482 | QJSValue QQmlEnginePrivate::singletonInstance<QJSValue>(const QQmlType &type) |
2483 | { |
2484 | Q_Q(QQmlEngine); |
2485 | |
2486 | QJSValue value = singletonInstances.value(key: type); |
2487 | if (!value.isUndefined()) { |
2488 | return value; |
2489 | } |
2490 | |
2491 | QQmlType::SingletonInstanceInfo *siinfo = type.singletonInstanceInfo(); |
2492 | Q_ASSERT(siinfo != nullptr); |
2493 | |
2494 | if (siinfo->scriptCallback) { |
2495 | value = siinfo->scriptCallback(q, q); |
2496 | if (value.isQObject()) { |
2497 | QObject *o = value.toQObject(); |
2498 | // even though the object is defined in C++, qmlContext(obj) and qmlEngine(obj) |
2499 | // should behave identically to QML singleton types. |
2500 | q->setContextForObject(object: o, context: new QQmlContext(q->rootContext(), q)); |
2501 | } |
2502 | singletonInstances.insert(key: type, value); |
2503 | |
2504 | } else if (siinfo->qobjectCallback) { |
2505 | QObject *o = siinfo->qobjectCallback(q, q); |
2506 | if (!o) { |
2507 | QQmlError error; |
2508 | error.setMessageType(QtMsgType::QtCriticalMsg); |
2509 | error.setDescription(QString::asprintf(format: "qmlRegisterSingletonType(): \"%s\" is not available because the callback function returns a null pointer." , |
2510 | qPrintable(QString::fromUtf8(type.typeName())))); |
2511 | warning(error); |
2512 | } else { |
2513 | // if this object can use a property cache, create it now |
2514 | QQmlData::ensurePropertyCache(engine: q, object: o); |
2515 | } |
2516 | // even though the object is defined in C++, qmlContext(obj) and qmlEngine(obj) |
2517 | // should behave identically to QML singleton types. |
2518 | q->setContextForObject(object: o, context: new QQmlContext(q->rootContext(), q)); |
2519 | value = q->newQObject(object: o); |
2520 | singletonInstances.insert(key: type, value); |
2521 | } else if (!siinfo->url.isEmpty()) { |
2522 | QQmlComponent component(q, siinfo->url, QQmlComponent::PreferSynchronous); |
2523 | QObject *o = component.beginCreate(q->rootContext()); |
2524 | value = q->newQObject(object: o); |
2525 | singletonInstances.insert(key: type, value); |
2526 | component.completeCreate(); |
2527 | } |
2528 | |
2529 | return value; |
2530 | } |
2531 | |
2532 | void QQmlEnginePrivate::destroySingletonInstance(const QQmlType &type) |
2533 | { |
2534 | Q_ASSERT(type.isSingleton() || type.isCompositeSingleton()); |
2535 | |
2536 | QObject* o = singletonInstances.take(key: type).toQObject(); |
2537 | if (o) { |
2538 | QQmlData *ddata = QQmlData::get(object: o, create: false); |
2539 | if (type.singletonInstanceInfo()->url.isEmpty() && ddata && ddata->indestructible && ddata->explicitIndestructibleSet) |
2540 | return; |
2541 | delete o; |
2542 | } |
2543 | } |
2544 | |
2545 | bool QQmlEnginePrivate::isTypeLoaded(const QUrl &url) const |
2546 | { |
2547 | return typeLoader.isTypeLoaded(url); |
2548 | } |
2549 | |
2550 | bool QQmlEnginePrivate::isScriptLoaded(const QUrl &url) const |
2551 | { |
2552 | return typeLoader.isScriptLoaded(url); |
2553 | } |
2554 | |
2555 | #if defined(Q_OS_WIN) && !defined(Q_OS_WINRT) |
2556 | // Normalize a file name using Shell API. As opposed to converting it |
2557 | // to a short 8.3 name and back, this also works for drives where 8.3 notation |
2558 | // is disabled (see 8dot3name options of fsutil.exe). |
2559 | static inline QString shellNormalizeFileName(const QString &name) |
2560 | { |
2561 | const QString nativeSeparatorName(QDir::toNativeSeparators(name)); |
2562 | const LPCTSTR nameC = reinterpret_cast<LPCTSTR>(nativeSeparatorName.utf16()); |
2563 | // The correct declaration of the SHGetPathFromIDList symbol is |
2564 | // being used in mingw-w64 as of r6215, which is a v3 snapshot. |
2565 | #if defined(Q_CC_MINGW) && (!defined(__MINGW64_VERSION_MAJOR) || __MINGW64_VERSION_MAJOR < 3) |
2566 | ITEMIDLIST *file; |
2567 | if (FAILED(SHParseDisplayName(nameC, NULL, reinterpret_cast<LPITEMIDLIST>(&file), 0, NULL))) |
2568 | return name; |
2569 | #else |
2570 | PIDLIST_ABSOLUTE file; |
2571 | if (FAILED(SHParseDisplayName(nameC, NULL, &file, 0, NULL))) |
2572 | return name; |
2573 | #endif |
2574 | TCHAR buffer[MAX_PATH]; |
2575 | bool gotPath = SHGetPathFromIDList(file, buffer); |
2576 | ILFree(file); |
2577 | |
2578 | if (!gotPath) |
2579 | return name; |
2580 | |
2581 | QString canonicalName = QString::fromWCharArray(buffer); |
2582 | // Upper case drive letter |
2583 | if (canonicalName.size() > 2 && canonicalName.at(1) == QLatin1Char(':')) |
2584 | canonicalName[0] = canonicalName.at(0).toUpper(); |
2585 | return QDir::cleanPath(canonicalName); |
2586 | } |
2587 | #endif // Q_OS_WIN && !Q_OS_WINRT |
2588 | |
2589 | bool QQml_isFileCaseCorrect(const QString &fileName, int lengthIn /* = -1 */) |
2590 | { |
2591 | #if defined(Q_OS_MAC) || defined(Q_OS_WIN) |
2592 | QFileInfo info(fileName); |
2593 | const QString absolute = info.absoluteFilePath(); |
2594 | |
2595 | #if defined(Q_OS_DARWIN) || defined(Q_OS_WINRT) |
2596 | const QString canonical = info.canonicalFilePath(); |
2597 | #elif defined(Q_OS_WIN) |
2598 | // No difference if the path is qrc based |
2599 | if (absolute[0] == QLatin1Char(':')) |
2600 | return true; |
2601 | const QString canonical = shellNormalizeFileName(absolute); |
2602 | #endif |
2603 | |
2604 | const int absoluteLength = absolute.length(); |
2605 | const int canonicalLength = canonical.length(); |
2606 | |
2607 | int length = qMin(absoluteLength, canonicalLength); |
2608 | if (lengthIn >= 0) { |
2609 | length = qMin(lengthIn, length); |
2610 | } else { |
2611 | // No length given: Limit to file name. Do not trigger |
2612 | // on drive letters or folder names. |
2613 | int lastSlash = absolute.lastIndexOf(QLatin1Char('/')); |
2614 | if (lastSlash < 0) |
2615 | lastSlash = absolute.lastIndexOf(QLatin1Char('\\')); |
2616 | if (lastSlash >= 0) { |
2617 | const int fileNameLength = absoluteLength - 1 - lastSlash; |
2618 | length = qMin(length, fileNameLength); |
2619 | } |
2620 | } |
2621 | |
2622 | for (int ii = 0; ii < length; ++ii) { |
2623 | const QChar &a = absolute.at(absoluteLength - 1 - ii); |
2624 | const QChar &c = canonical.at(canonicalLength - 1 - ii); |
2625 | |
2626 | if (a.toLower() != c.toLower()) |
2627 | return true; |
2628 | if (a != c) |
2629 | return false; |
2630 | } |
2631 | #else |
2632 | Q_UNUSED(lengthIn) |
2633 | Q_UNUSED(fileName) |
2634 | #endif |
2635 | return true; |
2636 | } |
2637 | |
2638 | /*! |
2639 | \fn QQmlEngine *qmlEngine(const QObject *object) |
2640 | \relates QQmlEngine |
2641 | |
2642 | Returns the QQmlEngine associated with \a object, if any. This is equivalent to |
2643 | QQmlEngine::contextForObject(object)->engine(), but more efficient. |
2644 | |
2645 | \note Add \c{#include <QtQml>} to use this function. |
2646 | |
2647 | \sa {QQmlEngine::contextForObject()}{contextForObject()}, qmlContext() |
2648 | */ |
2649 | |
2650 | /*! |
2651 | \fn QQmlContext *qmlContext(const QObject *object) |
2652 | \relates QQmlEngine |
2653 | |
2654 | Returns the QQmlContext associated with \a object, if any. This is equivalent to |
2655 | QQmlEngine::contextForObject(object). |
2656 | |
2657 | \note Add \c{#include <QtQml>} to use this function. |
2658 | |
2659 | \sa {QQmlEngine::contextForObject()}{contextForObject()}, qmlEngine() |
2660 | */ |
2661 | |
2662 | QT_END_NAMESPACE |
2663 | |
2664 | #include "moc_qqmlengine.cpp" |
2665 | |