qiurui
/
qtdeclarative
mirror of https://github.com/qt/qtdeclarative.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
qtdeclarative/tools/qml/main.cpp

654 lines
25 KiB
C++
Raw Normal View History

Use SPDX license identifiers Replace the current license disclaimer in files by a SPDX-License-Identifier. Files that have to be modified by hand are modified. License files are organized under LICENSES directory. Pick-to: 6.4 Task-number: QTBUG-67283 Change-Id: I63563bbeb6f60f89d2c99660400dca7fab78a294 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2022-05-13 13:12:05 +00:00
// Copyright (C) 2016 Research In Motion.
// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
#include "conf.h"
#include <QCoreApplication>
Make qtdeclarative compile with -no-gui Change-Id: I079f5e09a0099550348388379c496fc8f8cfa27c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-10-12 02:59:09 +00:00
#ifdef QT_GUI_LIB
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
#include <QGuiApplication>
Make qtdeclarative compile with -no-gui Change-Id: I079f5e09a0099550348388379c496fc8f8cfa27c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-10-12 02:59:09 +00:00
#include <QWindow>
#include <QFileOpenEvent>
Add QML_CORE_PROFILE support to QML tool If QML_CORE_PROFILE is defined we use the CoreProfile surface format. This is required for QtQuick3D. For consistency we also introduce QSG_CORE_PROFILE. Adding QSG_CORE_PROFILE also to qmlscene. Change-Id: I4feee91740162cf36fa2668695b74f5a1279bb89 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-01-30 14:54:09 +00:00
#include <QSurfaceFormat>
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
#ifdef QT_WIDGETS_LIB
#include <QApplication>
Make qtdeclarative compile with -no-gui Change-Id: I079f5e09a0099550348388379c496fc8f8cfa27c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-10-12 02:59:09 +00:00
#endif // QT_WIDGETS_LIB
#endif // QT_GUI_LIB
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
#include <QQmlApplicationEngine>
Remove several uses of module includes Module includes are discouraged because they may increase compilation time. While debugging a broken core module include header, a number of module include infractions were discovered in qtdeclarative. Replace them with their more specific counterparts. Change-Id: I614e9a6aa2177f396e5289f3cdb3c35faa0202c9 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-03-09 21:27:34 +00:00
#include <QQmlComponent>
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
#include <QCommandLineOption>
#include <QCommandLineParser>
Remove several uses of module includes Module includes are discouraged because they may increase compilation time. While debugging a broken core module include header, a number of module include infractions were discovered in qtdeclarative. Replace them with their more specific counterparts. Change-Id: I614e9a6aa2177f396e5289f3cdb3c35faa0202c9 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-03-09 21:27:34 +00:00
#include <QDir>
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
#include <QFile>
#include <QFileInfo>
qml runtime tool: --quiet disables categorized logging too [ChangeLog][QtQml][qml] The QML Runtime tool --quiet option now disables categorized logging in addition to qDebug, qInfo, qWarning and qFatal, except for some early QPA-level categorized logging that occurs during application construction. You can still override specific categories by setting QT_LOGGING_CONF or QT_LOGGING_RULES. Change-Id: Icf986a7fa9980d07beed308df8f69fcc4da9d771 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-23 13:20:15 +00:00
#include <QLoggingCategory>
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
#include <QStringList>
qml tool should exit on Qt.quit() In a QML/C++ application there may be additional code after app.exec(). In a pure QML application this is not the case, and you may wish to call Qt.quit() during scene creation (before app.exec()). [ChangeLog][QtQml][qml] qml tool now quits immediately if Qt.quit() is called before all scenes complete creation. Change-Id: I5c6fb64769724350ef3d74c34e2ede2d06562e4b Reviewed-by: Kevin Krammer <kevin.krammer@kdab.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2015-03-11 05:25:14 +00:00
#include <QScopedPointer>
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
#include <QDebug>
#include <QStandardPaths>
Remove several uses of module includes Module includes are discouraged because they may increase compilation time. While debugging a broken core module include header, a number of module include infractions were discovered in qtdeclarative. Replace them with their more specific counterparts. Change-Id: I614e9a6aa2177f396e5289f3cdb3c35faa0202c9 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-03-09 21:27:34 +00:00
#include <QTranslator>
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
#include <QtGlobal>
qml: Output information about build and GL renderer in verbose mode. Make static contain() a member of LoadWatcher() and connect to QQuickWindow::onOpenGlContextCreated(). Print information similar to qtdiag. Change-Id: I0bc6bc43418e4392c6b5e2643d4f7899ff4f4f8b Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2015-06-03 09:05:12 +00:00
#include <QLibraryInfo>
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
#include <qqml.h>
#include <qqmldebug.h>
Add support for file selectors to qml tool This allows defining file selectors using a command-line option. [ChangeLog][QtQml][qml] The QML Runtime tool --selector option now allows defining a custom QQmlFileSelector. Change-Id: I1be5efd273b2f387df72b1d5057f7281e5c0c156 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2020-01-30 14:43:57 +00:00
#include <qqmlfileselector.h>
Add a feature for qml-animation It should be possible to switch it off without globally switching animations off in Qt. Change-Id: I3cae6b72b2c6b5c420f21625208de5e273839438 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@qt.io> Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-12-19 15:37:24 +00:00
#include <private/qtqmlglobal_p.h>
qml: Don't mangle the settings URL If you do QUrl::fromLocalFile() on a file name starting with ":" you get a rather curious URL. Change-Id: I07d35e792b87a66fffc9c992462d92a4c0c8040d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-25 14:49:34 +00:00
#include <private/qqmlimport_p.h>
Add a feature for qml-animation It should be possible to switch it off without globally switching animations off in Qt. Change-Id: I3cae6b72b2c6b5c420f21625208de5e273839438 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@qt.io> Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-12-19 15:37:24 +00:00
#if QT_CONFIG(qml_animation)
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
#include <private/qabstractanimation_p.h>
Fix build without features.animation Change-Id: Ie45a2f01def64941a323973ea27446e3fc85a72b Reviewed-by: Robin Burchell <robin.burchell@crimson.no> Reviewed-by: Paul Olav Tvete <paul.tvete@qt.io>
2017-03-30 08:41:52 +00:00
#endif
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
#include <cstdio>
#include <cstring>
#include <cstdlib>
qml: Make sure the qml tool deletes its application Otherwise the shutdown mechanism for debug services doesn't work. Fixes: QTBUG-78828 Change-Id: I4ede5861a300d5b5007036d71ed84409ec4d450f Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2019-09-30 08:53:49 +00:00
#include <memory>
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
qml tool on OSX: wait for a timeout before exiting Double-clicking to open a QML file was not working because it would exit if no files are given on the command line. It needs to wait a while for the QFileOpenEvent. Task-number: QTBUG-34926 Change-Id: Icb585a777b0438db85120c62e7717f0f6eafffb1 Reviewed-by: Gabriel de Dietrich <gabriel.dedietrich@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Morten Johan Sørvig <morten.sorvig@digia.com>
2013-11-18 14:57:08 +00:00
#define FILE_OPEN_EVENT_WAIT_TIME 3000 // ms
qml: Deprecate the --dummy-data option [ChangeLog][QtQml][qml] The QML Runtime tool's --dummy-data option is now deprecated, because context properties are deprecated. This option will be removed in a future version of Qt. Task-number: QTBUG-96800 Change-Id: Id6ef8a384f6239ddeebd6c4f84854bbeaf630279 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-22 18:33:51 +00:00
Q_LOGGING_CATEGORY(lcDeprecated, "qt.tools.qml.deprecated")
qml runtime tool: group globals and declare static; improve padding This fixes a few code model warnings. Change-Id: I0739e19ad5601caa4177f0fd843b1a8d38c936a6 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-23 13:31:15 +00:00
enum QmlApplicationType {
QmlApplicationTypeUnknown
, QmlApplicationTypeCore
#ifdef QT_GUI_LIB
, QmlApplicationTypeGui
#ifdef QT_WIDGETS_LIB
, QmlApplicationTypeWidget
#endif // QT_WIDGETS_LIB
#endif // QT_GUI_LIB
};
static QmlApplicationType applicationType =
#ifndef QT_GUI_LIB
QmlApplicationTypeCore;
#else
QmlApplicationTypeGui;
#endif // QT_GUI_LIB
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
static Config *conf = nullptr;
static QQmlApplicationEngine *qae = nullptr;
Fix forced error warnings in -no-gui build compiling main.cpp main.cpp:361:23: error: unused parameter argc [-Werror=unused-parameter] void getAppFlags(int &argc, char **argv) ^ main.cpp:361:36: error: unused parameter argv [-Werror=unused-parameter] void getAppFlags(int &argc, char **argv) ^ main.cpp:74:12: error: exitTimerId defined but not used [-Werror=unused-variable] static int exitTimerId = -1; ^ Change-Id: I3eb7aff4ab3b5f1e89fdbf6d090107efedb376dd Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-04-12 13:45:18 +00:00
#if defined(Q_OS_DARWIN) || defined(QT_GUI_LIB)
qml tool on OSX: wait for a timeout before exiting Double-clicking to open a QML file was not working because it would exit if no files are given on the command line. It needs to wait a while for the QFileOpenEvent. Task-number: QTBUG-34926 Change-Id: Icb585a777b0438db85120c62e7717f0f6eafffb1 Reviewed-by: Gabriel de Dietrich <gabriel.dedietrich@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Morten Johan Sørvig <morten.sorvig@digia.com>
2013-11-18 14:57:08 +00:00
static int exitTimerId = -1;
Fix forced error warnings in -no-gui build compiling main.cpp main.cpp:361:23: error: unused parameter argc [-Werror=unused-parameter] void getAppFlags(int &argc, char **argv) ^ main.cpp:361:36: error: unused parameter argv [-Werror=unused-parameter] void getAppFlags(int &argc, char **argv) ^ main.cpp:74:12: error: exitTimerId defined but not used [-Werror=unused-variable] static int exitTimerId = -1; ^ Change-Id: I3eb7aff4ab3b5f1e89fdbf6d090107efedb376dd Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-04-12 13:45:18 +00:00
#endif
qml: Straighten out configuration QML module Use qt_add_qml_module correctly, apply a standard resource path, and move the files into the same directory as the module. Use upper case file names for the (re-usable) container definitions and lower case file names for the configuration entry points. This way we only need one directory and therefore only one QML module. Change-Id: Ic45dd0e8866f8f62bbaa639b6f138e9a75e05863 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2023-04-26 13:15:37 +00:00
static const QString iconResourcePath(QStringLiteral(":/qt-project.org/imports/QmlRuntime/Config/resources/qml-64.png"));
static const QString confResourcePath(QStringLiteral(":/qt-project.org/imports/QmlRuntime/Config/"));
Teach the qml runtime to load config files by basename Also, --list-conf will now list the conf files that it finds; and --verbose will show more information about the path(s) to them. [ChangeLog][QtQml][qml] The QML Runtime tool's -c / --config option now can find a directory containing a file called configuration.qml under QStandardPaths::AppConfigLocation, in addition to being able to give the full path to the configuration file, as before. I.e. on Linux you could write a custom configuration into ~/.config/QtProject/Qml Runtime/myconfig/configuration.qml and then use it via qml -c myconfig somefile.qml. The --list-conf option will list the configurations that can be found in this way. Task-number: QTBUG-26366 Fixes: QTBUG-96740 Change-Id: I72798b22255b71b9d4184a67f86b249766b64233 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-21 13:23:55 +00:00
static const QString customConfFileName(QStringLiteral("configuration.qml"));
qml runtime tool: group globals and declare static; improve padding This fixes a few code model warnings. Change-Id: I0739e19ad5601caa4177f0fd843b1a8d38c936a6 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-23 13:31:15 +00:00
static bool verboseMode = false;
static bool quietMode = false;
qml: Enable context sharing by default The qml utility now uses context sharing by default, as previously done by qmlscene. It can also be disabled in the same way, by specifying --disable-context-sharing. This is needed for compatibility with QtWebEngine among other things. Fixes: QTBUG-85107 Change-Id: I6155d32dfc55b385d33e1c805dae601b9710427e Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-03-18 14:10:46 +00:00
static bool glShareContexts = true;
qml tool: Disable shader caching by default When shaders are generated dynamically, such as with QtQuick3D, cached shaders may get out of date if the QML file is changed. Change-Id: I2c5484765e30da5c13fd175a9fcbad2473d55e62 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Christian Strømme <christian.stromme@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2023-02-02 10:00:13 +00:00
static bool disableShaderCache = true;
Fix some compile errors when compiling with -no-gui -no-qml-debug Change-Id: I33254477ad4535c898d1091b1275cc4d9a3de5d4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-01-16 09:50:41 +00:00
#if defined(QT_GUI_LIB)
Bring QSurfaceFormat configurability to qmlscene's level in the qml tool Restore the --transparent and --multisample options. Also make the default QSurfaceFormat setting universal (no need to tie it to the option of forcing a core profile context), and prevent the warning that is printed when the default surfaceformat is changed after the application is already created with AA_ShareOpenGLContexts set. This involves having to handle the relevant arguments manually early on, not through QCommandLineParser. All this matches the qmlscene behavior. NB qmlscene requests 16 samples with --multisample which is completely pointless in practice. Use the common 4 now. Change-Id: I671e5f22846a715675ea936bb7cf2a31a849dc28 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2023-02-02 12:50:19 +00:00
static bool requestAlphaChannel = false;
static bool requestMSAA = false;
static bool requestCoreProfile = false;
Fix some compile errors when compiling with -no-gui -no-qml-debug Change-Id: I33254477ad4535c898d1091b1275cc4d9a3de5d4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2024-01-16 09:50:41 +00:00
#endif
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
static void loadConf(const QString &override, bool quiet) // Terminates app on failure
{
qml runtime tool: support alternate conf; add resizeToItem conf The qmlscene --resize-to-root feature has always been missing from the qml runtime tool; however it was already possible to add it by writing a custom configuration file. Now we support loading different configurations from resources as well as from the filesystem, and the first new configuration being added here is resizeToItem.qml which provides behavior equivalent to qmlscene --resize-to-root. When the argument given to --config ends with .qml, by convention it's to be loaded from the filesystem; whereas configurations from resources are specified without the .qml extension (to make the command line shorter). [ChangeLog][QtQml][qml] The QML Runtime tool now has default behavior matching qmlscene when the root QML object is an Item: it will be wrapped in a Window which will resize the Item when the Window is resized. But you can alternatively use the --config resizeToItem option, resulting in the same behavior as qmlscene --resizeToRoot: resizing the root Item programmatically causes the wrapping Window to be resized. Behavior can still be customized in other ways using the --config option with an external QML configuration file. Task-number: QTBUG-53557 Change-Id: Icdcbbd12258105c33b64634049d735e022dfbd06 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-24 19:05:32 +00:00
const QString defaultFileName = QLatin1String("default.qml");
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
QUrl settingsUrl;
bool builtIn = false; //just for keeping track of the warning
if (override.isEmpty()) {
QFileInfo fi;
Replace deprecated DataLocation with AppDataLocation Task-number: QTBUG-87037 Change-Id: I1cb6cd15fbb5fe08a0280ed83d01fc1b49249524 Reviewed-by: Karsten Heimrich <karsten.heimrich@qt.io>
2020-10-23 22:06:41 +00:00
fi.setFile(QStandardPaths::locate(QStandardPaths::AppDataLocation, defaultFileName));
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
if (fi.exists()) {
qml: Don't mangle the settings URL If you do QUrl::fromLocalFile() on a file name starting with ":" you get a rather curious URL. Change-Id: I07d35e792b87a66fffc9c992462d92a4c0c8040d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-25 14:49:34 +00:00
settingsUrl = QQmlImports::urlFromLocalFileOrQrcOrUrl(fi.absoluteFilePath());
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
} else {
// ### If different built-in configs are needed per-platform, just apply QFileSelector to the qrc conf.qml path
qml runtime tool: support alternate conf; add resizeToItem conf The qmlscene --resize-to-root feature has always been missing from the qml runtime tool; however it was already possible to add it by writing a custom configuration file. Now we support loading different configurations from resources as well as from the filesystem, and the first new configuration being added here is resizeToItem.qml which provides behavior equivalent to qmlscene --resize-to-root. When the argument given to --config ends with .qml, by convention it's to be loaded from the filesystem; whereas configurations from resources are specified without the .qml extension (to make the command line shorter). [ChangeLog][QtQml][qml] The QML Runtime tool now has default behavior matching qmlscene when the root QML object is an Item: it will be wrapped in a Window which will resize the Item when the Window is resized. But you can alternatively use the --config resizeToItem option, resulting in the same behavior as qmlscene --resizeToRoot: resizing the root Item programmatically causes the wrapping Window to be resized. Behavior can still be customized in other ways using the --config option with an external QML configuration file. Task-number: QTBUG-53557 Change-Id: Icdcbbd12258105c33b64634049d735e022dfbd06 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-24 19:05:32 +00:00
fi.setFile(confResourcePath + defaultFileName);
qml: Don't mangle the settings URL If you do QUrl::fromLocalFile() on a file name starting with ":" you get a rather curious URL. Change-Id: I07d35e792b87a66fffc9c992462d92a4c0c8040d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-25 14:49:34 +00:00
settingsUrl = QQmlImports::urlFromLocalFileOrQrcOrUrl(fi.absoluteFilePath());
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
builtIn = true;
}
} else {
QFileInfo fi;
qml runtime tool: support alternate conf; add resizeToItem conf The qmlscene --resize-to-root feature has always been missing from the qml runtime tool; however it was already possible to add it by writing a custom configuration file. Now we support loading different configurations from resources as well as from the filesystem, and the first new configuration being added here is resizeToItem.qml which provides behavior equivalent to qmlscene --resize-to-root. When the argument given to --config ends with .qml, by convention it's to be loaded from the filesystem; whereas configurations from resources are specified without the .qml extension (to make the command line shorter). [ChangeLog][QtQml][qml] The QML Runtime tool now has default behavior matching qmlscene when the root QML object is an Item: it will be wrapped in a Window which will resize the Item when the Window is resized. But you can alternatively use the --config resizeToItem option, resulting in the same behavior as qmlscene --resizeToRoot: resizing the root Item programmatically causes the wrapping Window to be resized. Behavior can still be customized in other ways using the --config option with an external QML configuration file. Task-number: QTBUG-53557 Change-Id: Icdcbbd12258105c33b64634049d735e022dfbd06 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-24 19:05:32 +00:00
fi.setFile(confResourcePath + override + QLatin1String(".qml"));
if (fi.exists()) {
qml: Don't mangle the settings URL If you do QUrl::fromLocalFile() on a file name starting with ":" you get a rather curious URL. Change-Id: I07d35e792b87a66fffc9c992462d92a4c0c8040d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-25 14:49:34 +00:00
settingsUrl = QQmlImports::urlFromLocalFileOrQrcOrUrl(fi.absoluteFilePath());
qml runtime tool: support alternate conf; add resizeToItem conf The qmlscene --resize-to-root feature has always been missing from the qml runtime tool; however it was already possible to add it by writing a custom configuration file. Now we support loading different configurations from resources as well as from the filesystem, and the first new configuration being added here is resizeToItem.qml which provides behavior equivalent to qmlscene --resize-to-root. When the argument given to --config ends with .qml, by convention it's to be loaded from the filesystem; whereas configurations from resources are specified without the .qml extension (to make the command line shorter). [ChangeLog][QtQml][qml] The QML Runtime tool now has default behavior matching qmlscene when the root QML object is an Item: it will be wrapped in a Window which will resize the Item when the Window is resized. But you can alternatively use the --config resizeToItem option, resulting in the same behavior as qmlscene --resizeToRoot: resizing the root Item programmatically causes the wrapping Window to be resized. Behavior can still be customized in other ways using the --config option with an external QML configuration file. Task-number: QTBUG-53557 Change-Id: Icdcbbd12258105c33b64634049d735e022dfbd06 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-24 19:05:32 +00:00
builtIn = true;
} else {
Teach the qml runtime to load config files by basename Also, --list-conf will now list the conf files that it finds; and --verbose will show more information about the path(s) to them. [ChangeLog][QtQml][qml] The QML Runtime tool's -c / --config option now can find a directory containing a file called configuration.qml under QStandardPaths::AppConfigLocation, in addition to being able to give the full path to the configuration file, as before. I.e. on Linux you could write a custom configuration into ~/.config/QtProject/Qml Runtime/myconfig/configuration.qml and then use it via qml -c myconfig somefile.qml. The --list-conf option will list the configurations that can be found in this way. Task-number: QTBUG-26366 Fixes: QTBUG-96740 Change-Id: I72798b22255b71b9d4184a67f86b249766b64233 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-21 13:23:55 +00:00
fi.setFile(QDir(QStandardPaths::locate(QStandardPaths::AppConfigLocation, override, QStandardPaths::LocateDirectory)), customConfFileName);
if (fi.exists())
qml: Don't mangle the settings URL If you do QUrl::fromLocalFile() on a file name starting with ":" you get a rather curious URL. Change-Id: I07d35e792b87a66fffc9c992462d92a4c0c8040d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-25 14:49:34 +00:00
settingsUrl = QQmlImports::urlFromLocalFileOrQrcOrUrl(fi.absoluteFilePath());
Teach the qml runtime to load config files by basename Also, --list-conf will now list the conf files that it finds; and --verbose will show more information about the path(s) to them. [ChangeLog][QtQml][qml] The QML Runtime tool's -c / --config option now can find a directory containing a file called configuration.qml under QStandardPaths::AppConfigLocation, in addition to being able to give the full path to the configuration file, as before. I.e. on Linux you could write a custom configuration into ~/.config/QtProject/Qml Runtime/myconfig/configuration.qml and then use it via qml -c myconfig somefile.qml. The --list-conf option will list the configurations that can be found in this way. Task-number: QTBUG-26366 Fixes: QTBUG-96740 Change-Id: I72798b22255b71b9d4184a67f86b249766b64233 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-21 13:23:55 +00:00
else
fi.setFile(override);
qml runtime tool: support alternate conf; add resizeToItem conf The qmlscene --resize-to-root feature has always been missing from the qml runtime tool; however it was already possible to add it by writing a custom configuration file. Now we support loading different configurations from resources as well as from the filesystem, and the first new configuration being added here is resizeToItem.qml which provides behavior equivalent to qmlscene --resize-to-root. When the argument given to --config ends with .qml, by convention it's to be loaded from the filesystem; whereas configurations from resources are specified without the .qml extension (to make the command line shorter). [ChangeLog][QtQml][qml] The QML Runtime tool now has default behavior matching qmlscene when the root QML object is an Item: it will be wrapped in a Window which will resize the Item when the Window is resized. But you can alternatively use the --config resizeToItem option, resulting in the same behavior as qmlscene --resizeToRoot: resizing the root Item programmatically causes the wrapping Window to be resized. Behavior can still be customized in other ways using the --config option with an external QML configuration file. Task-number: QTBUG-53557 Change-Id: Icdcbbd12258105c33b64634049d735e022dfbd06 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-24 19:05:32 +00:00
if (!fi.exists()) {
printf("qml: Couldn't find required configuration file: %s\n",
qPrintable(QDir::toNativeSeparators(fi.absoluteFilePath())));
exit(1);
}
qml: Don't mangle the settings URL If you do QUrl::fromLocalFile() on a file name starting with ":" you get a rather curious URL. Change-Id: I07d35e792b87a66fffc9c992462d92a4c0c8040d Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-02-25 14:49:34 +00:00
settingsUrl = QQmlImports::urlFromLocalFileOrQrcOrUrl(fi.absoluteFilePath());
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
}
}
if (!quiet) {
qml: Output information about build and GL renderer in verbose mode. Make static contain() a member of LoadWatcher() and connect to QQuickWindow::onOpenGlContextCreated(). Print information similar to qtdiag. Change-Id: I0bc6bc43418e4392c6b5e2643d4f7899ff4f4f8b Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2015-06-03 09:05:12 +00:00
printf("qml: %s\n", QLibraryInfo::build());
qml runtime tool: support alternate conf; add resizeToItem conf The qmlscene --resize-to-root feature has always been missing from the qml runtime tool; however it was already possible to add it by writing a custom configuration file. Now we support loading different configurations from resources as well as from the filesystem, and the first new configuration being added here is resizeToItem.qml which provides behavior equivalent to qmlscene --resize-to-root. When the argument given to --config ends with .qml, by convention it's to be loaded from the filesystem; whereas configurations from resources are specified without the .qml extension (to make the command line shorter). [ChangeLog][QtQml][qml] The QML Runtime tool now has default behavior matching qmlscene when the root QML object is an Item: it will be wrapped in a Window which will resize the Item when the Window is resized. But you can alternatively use the --config resizeToItem option, resulting in the same behavior as qmlscene --resizeToRoot: resizing the root Item programmatically causes the wrapping Window to be resized. Behavior can still be customized in other ways using the --config option with an external QML configuration file. Task-number: QTBUG-53557 Change-Id: Icdcbbd12258105c33b64634049d735e022dfbd06 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-24 19:05:32 +00:00
if (builtIn) {
printf("qml: Using built-in configuration: %s\n",
qPrintable(override.isEmpty() ? defaultFileName : override));
} else {
printf("qml: Using configuration: %s\n",
Add a verbose mode to qml The extra output is primarily useful for debugging, and on windows it will actually make an ugly command prompt window appear. Change-Id: I552e479515a6f5249685844143601cb7449a10b5 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2013-10-23 22:37:16 +00:00
qPrintable(settingsUrl.isLocalFile()
? QDir::toNativeSeparators(settingsUrl.toLocalFile())
: settingsUrl.toString()));
qml runtime tool: support alternate conf; add resizeToItem conf The qmlscene --resize-to-root feature has always been missing from the qml runtime tool; however it was already possible to add it by writing a custom configuration file. Now we support loading different configurations from resources as well as from the filesystem, and the first new configuration being added here is resizeToItem.qml which provides behavior equivalent to qmlscene --resize-to-root. When the argument given to --config ends with .qml, by convention it's to be loaded from the filesystem; whereas configurations from resources are specified without the .qml extension (to make the command line shorter). [ChangeLog][QtQml][qml] The QML Runtime tool now has default behavior matching qmlscene when the root QML object is an Item: it will be wrapped in a Window which will resize the Item when the Window is resized. But you can alternatively use the --config resizeToItem option, resulting in the same behavior as qmlscene --resizeToRoot: resizing the root Item programmatically causes the wrapping Window to be resized. Behavior can still be customized in other ways using the --config option with an external QML configuration file. Task-number: QTBUG-53557 Change-Id: Icdcbbd12258105c33b64634049d735e022dfbd06 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-24 19:05:32 +00:00
}
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
}
// TODO: When we have better engine control, ban QtQuick* imports on this engine
QQmlEngine e2;
QQmlComponent c2(&e2, settingsUrl);
conf = qobject_cast<Config*>(c2.create());
if (!conf){
Add a verbose mode to qml The extra output is primarily useful for debugging, and on windows it will actually make an ugly command prompt window appear. Change-Id: I552e479515a6f5249685844143601cb7449a10b5 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2013-10-23 22:37:16 +00:00
printf("qml: Error loading configuration file: %s\n", qPrintable(c2.errorString()));
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
exit(1);
}
}
qml runtime tool: group globals and declare static; improve padding This fixes a few code model warnings. Change-Id: I0739e19ad5601caa4177f0fd843b1a8d38c936a6 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-23 13:31:15 +00:00
void noFilesGiven()
{
if (!quietMode)
printf("qml: No files specified. Terminating.\n");
exit(1);
}
Make qtdeclarative compile with -no-gui Change-Id: I079f5e09a0099550348388379c496fc8f8cfa27c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-10-12 02:59:09 +00:00
qml runtime tool: support alternate conf; add resizeToItem conf The qmlscene --resize-to-root feature has always been missing from the qml runtime tool; however it was already possible to add it by writing a custom configuration file. Now we support loading different configurations from resources as well as from the filesystem, and the first new configuration being added here is resizeToItem.qml which provides behavior equivalent to qmlscene --resize-to-root. When the argument given to --config ends with .qml, by convention it's to be loaded from the filesystem; whereas configurations from resources are specified without the .qml extension (to make the command line shorter). [ChangeLog][QtQml][qml] The QML Runtime tool now has default behavior matching qmlscene when the root QML object is an Item: it will be wrapped in a Window which will resize the Item when the Window is resized. But you can alternatively use the --config resizeToItem option, resulting in the same behavior as qmlscene --resizeToRoot: resizing the root Item programmatically causes the wrapping Window to be resized. Behavior can still be customized in other ways using the --config option with an external QML configuration file. Task-number: QTBUG-53557 Change-Id: Icdcbbd12258105c33b64634049d735e022dfbd06 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-24 19:05:32 +00:00
static void listConfFiles()
{
Teach the qml runtime to load config files by basename Also, --list-conf will now list the conf files that it finds; and --verbose will show more information about the path(s) to them. [ChangeLog][QtQml][qml] The QML Runtime tool's -c / --config option now can find a directory containing a file called configuration.qml under QStandardPaths::AppConfigLocation, in addition to being able to give the full path to the configuration file, as before. I.e. on Linux you could write a custom configuration into ~/.config/QtProject/Qml Runtime/myconfig/configuration.qml and then use it via qml -c myconfig somefile.qml. The --list-conf option will list the configurations that can be found in this way. Task-number: QTBUG-26366 Fixes: QTBUG-96740 Change-Id: I72798b22255b71b9d4184a67f86b249766b64233 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-21 13:23:55 +00:00
const QDir confResourceDir(confResourcePath);
qml runtime tool: support alternate conf; add resizeToItem conf The qmlscene --resize-to-root feature has always been missing from the qml runtime tool; however it was already possible to add it by writing a custom configuration file. Now we support loading different configurations from resources as well as from the filesystem, and the first new configuration being added here is resizeToItem.qml which provides behavior equivalent to qmlscene --resize-to-root. When the argument given to --config ends with .qml, by convention it's to be loaded from the filesystem; whereas configurations from resources are specified without the .qml extension (to make the command line shorter). [ChangeLog][QtQml][qml] The QML Runtime tool now has default behavior matching qmlscene when the root QML object is an Item: it will be wrapped in a Window which will resize the Item when the Window is resized. But you can alternatively use the --config resizeToItem option, resulting in the same behavior as qmlscene --resizeToRoot: resizing the root Item programmatically causes the wrapping Window to be resized. Behavior can still be customized in other ways using the --config option with an external QML configuration file. Task-number: QTBUG-53557 Change-Id: Icdcbbd12258105c33b64634049d735e022dfbd06 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-24 19:05:32 +00:00
printf("%s\n", qPrintable(QCoreApplication::translate("main", "Built-in configurations:")));
qml: Straighten out configuration QML module Use qt_add_qml_module correctly, apply a standard resource path, and move the files into the same directory as the module. Use upper case file names for the (re-usable) container definitions and lower case file names for the configuration entry points. This way we only need one directory and therefore only one QML module. Change-Id: Ic45dd0e8866f8f62bbaa639b6f138e9a75e05863 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2023-04-26 13:15:37 +00:00
for (const QFileInfo &fi : confResourceDir.entryInfoList(QDir::Files)) {
if (fi.completeSuffix() != QLatin1String("qml"))
continue;
const QString baseName = fi.baseName();
if (baseName.isEmpty() || baseName[0].isUpper())
continue;
printf(" %s\n", qPrintable(baseName));
}
Teach the qml runtime to load config files by basename Also, --list-conf will now list the conf files that it finds; and --verbose will show more information about the path(s) to them. [ChangeLog][QtQml][qml] The QML Runtime tool's -c / --config option now can find a directory containing a file called configuration.qml under QStandardPaths::AppConfigLocation, in addition to being able to give the full path to the configuration file, as before. I.e. on Linux you could write a custom configuration into ~/.config/QtProject/Qml Runtime/myconfig/configuration.qml and then use it via qml -c myconfig somefile.qml. The --list-conf option will list the configurations that can be found in this way. Task-number: QTBUG-26366 Fixes: QTBUG-96740 Change-Id: I72798b22255b71b9d4184a67f86b249766b64233 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-21 13:23:55 +00:00
printf("%s\n", qPrintable(QCoreApplication::translate("main", "Other configurations:")));
bool foundOther = false;
const QStringList otherLocations = QStandardPaths::standardLocations(QStandardPaths::AppConfigLocation);
for (const auto &confDirPath : otherLocations) {
const QDir confDir(confDirPath);
for (const QFileInfo &fi : confDir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot)) {
foundOther = true;
if (verboseMode)
printf(" %s\n", qPrintable(fi.absoluteFilePath()));
else
printf(" %s\n", qPrintable(fi.baseName()));
}
}
if (!foundOther)
printf(" %s\n", qPrintable(QCoreApplication::translate("main", "none")));
if (verboseMode) {
printf("%s\n", qPrintable(QCoreApplication::translate("main", "Checked in:")));
for (const auto &confDirPath : otherLocations)
printf(" %s\n", qPrintable(confDirPath));
}
qml runtime tool: support alternate conf; add resizeToItem conf The qmlscene --resize-to-root feature has always been missing from the qml runtime tool; however it was already possible to add it by writing a custom configuration file. Now we support loading different configurations from resources as well as from the filesystem, and the first new configuration being added here is resizeToItem.qml which provides behavior equivalent to qmlscene --resize-to-root. When the argument given to --config ends with .qml, by convention it's to be loaded from the filesystem; whereas configurations from resources are specified without the .qml extension (to make the command line shorter). [ChangeLog][QtQml][qml] The QML Runtime tool now has default behavior matching qmlscene when the root QML object is an Item: it will be wrapped in a Window which will resize the Item when the Window is resized. But you can alternatively use the --config resizeToItem option, resulting in the same behavior as qmlscene --resizeToRoot: resizing the root Item programmatically causes the wrapping Window to be resized. Behavior can still be customized in other ways using the --config option with an external QML configuration file. Task-number: QTBUG-53557 Change-Id: Icdcbbd12258105c33b64634049d735e022dfbd06 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-24 19:05:32 +00:00
exit(0);
}
qml runtime tool: group globals and declare static; improve padding This fixes a few code model warnings. Change-Id: I0739e19ad5601caa4177f0fd843b1a8d38c936a6 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-23 13:31:15 +00:00
#ifdef QT_GUI_LIB
qml tool on OSX: wait for a timeout before exiting Double-clicking to open a QML file was not working because it would exit if no files are given on the command line. It needs to wait a while for the QFileOpenEvent. Task-number: QTBUG-34926 Change-Id: Icb585a777b0438db85120c62e7717f0f6eafffb1 Reviewed-by: Gabriel de Dietrich <gabriel.dedietrich@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Morten Johan Sørvig <morten.sorvig@digia.com>
2013-11-18 14:57:08 +00:00
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
// Loads qml after receiving a QFileOpenEvent
class LoaderApplication : public QGuiApplication
{
public:
Update the QML Runtime icon A new one has been drawn; use it on all platforms, not just on macOS. It is now also used as the default window icon, to be more identifiable when minimized, etc. Of course it can be overridden by plugins that can be loaded from qml. [ChangeLog][QtQml][qml] The QML Runtime tool now has an updated application icon and a default window icon. QtQuick applications can still use QWindow::setIcon() to override the window icon. Task-number: QTBUG-70826 Task-number: QTBUG-74662 Change-Id: I8671d0c99f7f4283dbe2dc4c605abb560f7bf1a1 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2019-04-15 13:59:03 +00:00
LoaderApplication(int& argc, char **argv) : QGuiApplication(argc, argv)
{
setWindowIcon(QIcon(iconResourcePath));
}
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
sources: Add missing override and remove redundant virtual Change-Id: I48e26b1491024d41ebf75d40f0d1a7e9a1b20f22 Reviewed-by: Anton Kudryavtsev <antkudr@mail.ru> Reviewed-by: Marc Mutz <marc.mutz@kdab.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-12-07 22:53:14 +00:00
bool event(QEvent *ev) override
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
{
qml tool on OSX: wait for a timeout before exiting Double-clicking to open a QML file was not working because it would exit if no files are given on the command line. It needs to wait a while for the QFileOpenEvent. Task-number: QTBUG-34926 Change-Id: Icb585a777b0438db85120c62e7717f0f6eafffb1 Reviewed-by: Gabriel de Dietrich <gabriel.dedietrich@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Morten Johan Sørvig <morten.sorvig@digia.com>
2013-11-18 14:57:08 +00:00
if (ev->type() == QEvent::FileOpen) {
if (exitTimerId >= 0) {
killTimer(exitTimerId);
exitTimerId = -1;
}
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
qae->load(static_cast<QFileOpenEvent *>(ev)->url());
qml tool on OSX: wait for a timeout before exiting Double-clicking to open a QML file was not working because it would exit if no files are given on the command line. It needs to wait a while for the QFileOpenEvent. Task-number: QTBUG-34926 Change-Id: Icb585a777b0438db85120c62e7717f0f6eafffb1 Reviewed-by: Gabriel de Dietrich <gabriel.dedietrich@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Morten Johan Sørvig <morten.sorvig@digia.com>
2013-11-18 14:57:08 +00:00
}
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
else
return QGuiApplication::event(ev);
return true;
}
qml tool on OSX: wait for a timeout before exiting Double-clicking to open a QML file was not working because it would exit if no files are given on the command line. It needs to wait a while for the QFileOpenEvent. Task-number: QTBUG-34926 Change-Id: Icb585a777b0438db85120c62e7717f0f6eafffb1 Reviewed-by: Gabriel de Dietrich <gabriel.dedietrich@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Morten Johan Sørvig <morten.sorvig@digia.com>
2013-11-18 14:57:08 +00:00
sources: Add missing override and remove redundant virtual Change-Id: I48e26b1491024d41ebf75d40f0d1a7e9a1b20f22 Reviewed-by: Anton Kudryavtsev <antkudr@mail.ru> Reviewed-by: Marc Mutz <marc.mutz@kdab.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-12-07 22:53:14 +00:00
void timerEvent(QTimerEvent *) override {
qml tool on OSX: wait for a timeout before exiting Double-clicking to open a QML file was not working because it would exit if no files are given on the command line. It needs to wait a while for the QFileOpenEvent. Task-number: QTBUG-34926 Change-Id: Icb585a777b0438db85120c62e7717f0f6eafffb1 Reviewed-by: Gabriel de Dietrich <gabriel.dedietrich@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Morten Johan Sørvig <morten.sorvig@digia.com>
2013-11-18 14:57:08 +00:00
noFilesGiven();
}
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
};
Make qtdeclarative compile with -no-gui Change-Id: I079f5e09a0099550348388379c496fc8f8cfa27c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-10-12 02:59:09 +00:00
#endif // QT_GUI_LIB
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
// Listens to the appEngine signals to determine if all files failed to load
class LoadWatcher : public QObject
{
Q_OBJECT
public:
LoadWatcher(QQmlApplicationEngine *e, int expected)
: QObject(e)
Clean up LoadWatcher in the Qml Runtime Name the variables in a self-documenting way. While we're at it, do initialization at declaration when possible, reorder the public sections before the private ones, fix comment spacing, and use function-pointer connect syntax where possible. Change-Id: I3fddc8f6d27afa197d425fb7ae3baee02acedceb Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2019-01-14 08:42:29 +00:00
, expectedFileCount(expected)
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
{
Clean up LoadWatcher in the Qml Runtime Name the variables in a self-documenting way. While we're at it, do initialization at declaration when possible, reorder the public sections before the private ones, fix comment spacing, and use function-pointer connect syntax where possible. Change-Id: I3fddc8f6d27afa197d425fb7ae3baee02acedceb Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2019-01-14 08:42:29 +00:00
connect(e, &QQmlApplicationEngine::objectCreated, this, &LoadWatcher::checkFinished);
qml tool should exit on Qt.quit() In a QML/C++ application there may be additional code after app.exec(). In a pure QML application this is not the case, and you may wish to call Qt.quit() during scene creation (before app.exec()). [ChangeLog][QtQml][qml] qml tool now quits immediately if Qt.quit() is called before all scenes complete creation. Change-Id: I5c6fb64769724350ef3d74c34e2ede2d06562e4b Reviewed-by: Kevin Krammer <kevin.krammer@kdab.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2015-03-11 05:25:14 +00:00
// QQmlApplicationEngine also connects quit() to QCoreApplication::quit
Qt object: Add exit(int) This is similar to the Qt.quit() function but also specifies the return code that the event loop will return. [ChangeLog][QtQml] Added exit(int retCode) method to the Qt global object. An application can call Qt.exit to specify a return code of the engine. Task-number: QTBUG-54360 Change-Id: Iaa319e6dc4d6b99dc3a5c01845e87b936fd2cab0 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-08-03 14:54:26 +00:00
// and exit() to QCoreApplication::exit but if called before exec()
// then QCoreApplication::quit or QCoreApplication::exit does nothing
Clean up LoadWatcher in the Qml Runtime Name the variables in a self-documenting way. While we're at it, do initialization at declaration when possible, reorder the public sections before the private ones, fix comment spacing, and use function-pointer connect syntax where possible. Change-Id: I3fddc8f6d27afa197d425fb7ae3baee02acedceb Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2019-01-14 08:42:29 +00:00
connect(e, &QQmlEngine::quit, this, &LoadWatcher::quit);
connect(e, &QQmlEngine::exit, this, &LoadWatcher::exit);
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
}
Clean up LoadWatcher in the Qml Runtime Name the variables in a self-documenting way. While we're at it, do initialization at declaration when possible, reorder the public sections before the private ones, fix comment spacing, and use function-pointer connect syntax where possible. Change-Id: I3fddc8f6d27afa197d425fb7ae3baee02acedceb Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2019-01-14 08:42:29 +00:00
int returnCode = 0;
qml runtime tool: group globals and declare static; improve padding This fixes a few code model warnings. Change-Id: I0739e19ad5601caa4177f0fd843b1a8d38c936a6 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-23 13:31:15 +00:00
bool earlyExit = false;
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
public Q_SLOTS:
Clean up LoadWatcher in the Qml Runtime Name the variables in a self-documenting way. While we're at it, do initialization at declaration when possible, reorder the public sections before the private ones, fix comment spacing, and use function-pointer connect syntax where possible. Change-Id: I3fddc8f6d27afa197d425fb7ae3baee02acedceb Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2019-01-14 08:42:29 +00:00
void checkFinished(QObject *o, const QUrl &url)
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
{
Add ; to Q_UNUSED and UNUSED_PARAM This is required to remove the ; from the macro with Qt 6. Task-number: QTBUG-82978 Change-Id: Iead53d18fd790fb2d870d80ef2db79666f0d2392 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2020-06-26 12:43:02 +00:00
Q_UNUSED(url);
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
if (o) {
qml: Fix object counting We're not actually interested in whether an object is a window, and we don't really care how many objects are created. The only thing we need to know is whether at least one object is alive after all files have been processed. Pick-to: 6.5 Fixes: QTBUG-110112 Change-Id: I8d79359f3fb7ec5a54545dc5858cf310b0f52935 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-01-17 14:34:36 +00:00
++createdObjects;
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
if (conf && qae)
Port from qAsConst() to std::as_const() We've been requiring C++17 since Qt 6.0, and our qAsConst use finally starts to bother us (QTBUG-99313), so time to port away from it now. Since qAsConst has exactly the same semantics as std::as_const (down to rvalue treatment, constexpr'ness and noexcept'ness), there's really nothing more to it than a global search-and-replace. Task-number: QTBUG-99313 Change-Id: I601bf70f020f511019ed28731ba53b14b765dbf0 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2022-10-06 09:30:50 +00:00
for (PartialScene *ps : std::as_const(conf->completers))
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
if (o->inherits(ps->itemType().toUtf8().constData()))
contain(o, ps->container());
}
qml: Fix object counting We're not actually interested in whether an object is a window, and we don't really care how many objects are created. The only thing we need to know is whether at least one object is alive after all files have been processed. Pick-to: 6.5 Fixes: QTBUG-110112 Change-Id: I8d79359f3fb7ec5a54545dc5858cf310b0f52935 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-01-17 14:34:36 +00:00
if (!--expectedFileCount && !createdObjects) {
Add a verbose mode to qml The extra output is primarily useful for debugging, and on windows it will actually make an ugly command prompt window appear. Change-Id: I552e479515a6f5249685844143601cb7449a10b5 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2013-10-23 22:37:16 +00:00
printf("qml: Did not load any objects, exiting.\n");
qml: Avoid memory leaks when no objects are loaded Instead of std::exit() use the early return mechanism we already have so that any existing objects are gracefully destroyed. Change-Id: Icb197879cc33ab22f07fc1486da44f9ff5b177bc Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-07-08 12:32:44 +00:00
exit(2);
QCoreApplication::exit(2);
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
}
}
qml tool should exit on Qt.quit() In a QML/C++ application there may be additional code after app.exec(). In a pure QML application this is not the case, and you may wish to call Qt.quit() during scene creation (before app.exec()). [ChangeLog][QtQml][qml] qml tool now quits immediately if Qt.quit() is called before all scenes complete creation. Change-Id: I5c6fb64769724350ef3d74c34e2ede2d06562e4b Reviewed-by: Kevin Krammer <kevin.krammer@kdab.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2015-03-11 05:25:14 +00:00
void quit() {
Clean up LoadWatcher in the Qml Runtime Name the variables in a self-documenting way. While we're at it, do initialization at declaration when possible, reorder the public sections before the private ones, fix comment spacing, and use function-pointer connect syntax where possible. Change-Id: I3fddc8f6d27afa197d425fb7ae3baee02acedceb Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2019-01-14 08:42:29 +00:00
// Will be checked before calling exec()
qml tool should exit on Qt.quit() In a QML/C++ application there may be additional code after app.exec(). In a pure QML application this is not the case, and you may wish to call Qt.quit() during scene creation (before app.exec()). [ChangeLog][QtQml][qml] qml tool now quits immediately if Qt.quit() is called before all scenes complete creation. Change-Id: I5c6fb64769724350ef3d74c34e2ede2d06562e4b Reviewed-by: Kevin Krammer <kevin.krammer@kdab.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2015-03-11 05:25:14 +00:00
earlyExit = true;
Qt object: Add exit(int) This is similar to the Qt.quit() function but also specifies the return code that the event loop will return. [ChangeLog][QtQml] Added exit(int retCode) method to the Qt global object. An application can call Qt.exit to specify a return code of the engine. Task-number: QTBUG-54360 Change-Id: Iaa319e6dc4d6b99dc3a5c01845e87b936fd2cab0 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-08-03 14:54:26 +00:00
returnCode = 0;
qml tool should exit on Qt.quit() In a QML/C++ application there may be additional code after app.exec(). In a pure QML application this is not the case, and you may wish to call Qt.quit() during scene creation (before app.exec()). [ChangeLog][QtQml][qml] qml tool now quits immediately if Qt.quit() is called before all scenes complete creation. Change-Id: I5c6fb64769724350ef3d74c34e2ede2d06562e4b Reviewed-by: Kevin Krammer <kevin.krammer@kdab.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2015-03-11 05:25:14 +00:00
}
Qt object: Add exit(int) This is similar to the Qt.quit() function but also specifies the return code that the event loop will return. [ChangeLog][QtQml] Added exit(int retCode) method to the Qt global object. An application can call Qt.exit to specify a return code of the engine. Task-number: QTBUG-54360 Change-Id: Iaa319e6dc4d6b99dc3a5c01845e87b936fd2cab0 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-08-03 14:54:26 +00:00
void exit(int retCode) {
earlyExit = true;
returnCode = retCode;
}
Clean up LoadWatcher in the Qml Runtime Name the variables in a self-documenting way. While we're at it, do initialization at declaration when possible, reorder the public sections before the private ones, fix comment spacing, and use function-pointer connect syntax where possible. Change-Id: I3fddc8f6d27afa197d425fb7ae3baee02acedceb Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2019-01-14 08:42:29 +00:00
private:
void contain(QObject *o, const QUrl &containPath);
private:
qml runtime tool: group globals and declare static; improve padding This fixes a few code model warnings. Change-Id: I0739e19ad5601caa4177f0fd843b1a8d38c936a6 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-23 13:31:15 +00:00
int expectedFileCount;
qml: Fix object counting We're not actually interested in whether an object is a window, and we don't really care how many objects are created. The only thing we need to know is whether at least one object is alive after all files have been processed. Pick-to: 6.5 Fixes: QTBUG-110112 Change-Id: I8d79359f3fb7ec5a54545dc5858cf310b0f52935 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-01-17 14:34:36 +00:00
int createdObjects = 0;
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
};
qml: Output information about build and GL renderer in verbose mode. Make static contain() a member of LoadWatcher() and connect to QQuickWindow::onOpenGlContextCreated(). Print information similar to qtdiag. Change-Id: I0bc6bc43418e4392c6b5e2643d4f7899ff4f4f8b Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2015-06-03 09:05:12 +00:00
void LoadWatcher::contain(QObject *o, const QUrl &containPath)
{
QQmlComponent c(qae, containPath);
QObject *o2 = c.create();
if (!o2)
return;
qml: Don't leak the created objects Rather, parent them to the watcher. The watcher lives in the main() function's scope. Change-Id: I2ac1d14d80d4100756a3ad94b6502d46fda30074 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Andrei Golubev <andrei.golubev@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-05-20 15:07:33 +00:00
o2->setParent(this);
qml: Output information about build and GL renderer in verbose mode. Make static contain() a member of LoadWatcher() and connect to QQuickWindow::onOpenGlContextCreated(). Print information similar to qtdiag. Change-Id: I0bc6bc43418e4392c6b5e2643d4f7899ff4f4f8b Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2015-06-03 09:05:12 +00:00
bool success = false;
int idx;
if ((idx = o2->metaObject()->indexOfProperty("containedObject")) != -1)
success = o2->metaObject()->property(idx).write(o2, QVariant::fromValue<QObject*>(o));
if (!success)
Clean up LoadWatcher in the Qml Runtime Name the variables in a self-documenting way. While we're at it, do initialization at declaration when possible, reorder the public sections before the private ones, fix comment spacing, and use function-pointer connect syntax where possible. Change-Id: I3fddc8f6d27afa197d425fb7ae3baee02acedceb Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2019-01-14 08:42:29 +00:00
o->setParent(o2); // Set QObject parent, and assume container will react as needed
qml: Output information about build and GL renderer in verbose mode. Make static contain() a member of LoadWatcher() and connect to QQuickWindow::onOpenGlContextCreated(). Print information similar to qtdiag. Change-Id: I0bc6bc43418e4392c6b5e2643d4f7899ff4f4f8b Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2015-06-03 09:05:12 +00:00
}
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
void quietMessageHandler(QtMsgType type, const QMessageLogContext &ctxt, const QString &msg)
{
Q_UNUSED(ctxt);
Q_UNUSED(msg);
Clean up LoadWatcher in the Qml Runtime Name the variables in a self-documenting way. While we're at it, do initialization at declaration when possible, reorder the public sections before the private ones, fix comment spacing, and use function-pointer connect syntax where possible. Change-Id: I3fddc8f6d27afa197d425fb7ae3baee02acedceb Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2019-01-14 08:42:29 +00:00
// Doesn't print anything
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
switch (type) {
case QtFatalMsg:
Fix WinCE build. Change-Id: Ie0536ad94f88efe1e54226ed7f1d9e1042ffcc19 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-09-25 16:11:34 +00:00
exit(-1);
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
case QtCriticalMsg:
case QtDebugMsg:
qml runtime tool: --quiet disables categorized logging too [ChangeLog][QtQml][qml] The QML Runtime tool --quiet option now disables categorized logging in addition to qDebug, qInfo, qWarning and qFatal, except for some early QPA-level categorized logging that occurs during application construction. You can still override specific categories by setting QT_LOGGING_CONF or QT_LOGGING_RULES. Change-Id: Icf986a7fa9980d07beed308df8f69fcc4da9d771 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-23 13:20:15 +00:00
case QtInfoMsg:
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
case QtWarningMsg:
;
}
}
qml: Fix options that need to be set before QApplication instantiation Move the Open GL and scaling options setting QCoreApplication attributes into the helper getAppFlags() which already handles the application type. Change getAppFlags() to not modify argv which is not necessary since the parser will accept the options. Change-Id: Ib2f94f832e6551a938ff0e9bfe27649850d38d1e Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2020-01-15 09:55:27 +00:00
// Called before application initialization
static void getAppFlags(int argc, char **argv)
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
{
Make qtdeclarative compile with -no-gui Change-Id: I079f5e09a0099550348388379c496fc8f8cfa27c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-10-12 02:59:09 +00:00
#ifdef QT_GUI_LIB
Remove '-enable-debugger' argument from qml executable Task-number: QTBUG-34836 Change-Id: I3ab2a16036a1086c0ac1f50880a402caf9f54f2d Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-11-14 11:38:25 +00:00
for (int i=0; i<argc; i++) {
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
if (!strcmp(argv[i], "--apptype") || !strcmp(argv[i], "-a") || !strcmp(argv[i], "-apptype")) {
Make qtdeclarative compile with -no-gui Change-Id: I079f5e09a0099550348388379c496fc8f8cfa27c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-10-12 02:59:09 +00:00
applicationType = QmlApplicationTypeUnknown;
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
if (i+1 < argc) {
qml: Fix options that need to be set before QApplication instantiation Move the Open GL and scaling options setting QCoreApplication attributes into the helper getAppFlags() which already handles the application type. Change getAppFlags() to not modify argv which is not necessary since the parser will accept the options. Change-Id: Ib2f94f832e6551a938ff0e9bfe27649850d38d1e Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2020-01-15 09:55:27 +00:00
++i;
if (!strcmp(argv[i], "core"))
Make qtdeclarative compile with -no-gui Change-Id: I079f5e09a0099550348388379c496fc8f8cfa27c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-10-12 02:59:09 +00:00
applicationType = QmlApplicationTypeCore;
qml: Fix options that need to be set before QApplication instantiation Move the Open GL and scaling options setting QCoreApplication attributes into the helper getAppFlags() which already handles the application type. Change getAppFlags() to not modify argv which is not necessary since the parser will accept the options. Change-Id: Ib2f94f832e6551a938ff0e9bfe27649850d38d1e Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2020-01-15 09:55:27 +00:00
else if (!strcmp(argv[i], "gui"))
Make qtdeclarative compile with -no-gui Change-Id: I079f5e09a0099550348388379c496fc8f8cfa27c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-10-12 02:59:09 +00:00
applicationType = QmlApplicationTypeGui;
qml: Fix options that need to be set before QApplication instantiation Move the Open GL and scaling options setting QCoreApplication attributes into the helper getAppFlags() which already handles the application type. Change getAppFlags() to not modify argv which is not necessary since the parser will accept the options. Change-Id: Ib2f94f832e6551a938ff0e9bfe27649850d38d1e Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2020-01-15 09:55:27 +00:00
# ifdef QT_WIDGETS_LIB
else if (!strcmp(argv[i], "widget"))
Make qtdeclarative compile with -no-gui Change-Id: I079f5e09a0099550348388379c496fc8f8cfa27c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-10-12 02:59:09 +00:00
applicationType = QmlApplicationTypeWidget;
qml: Fix options that need to be set before QApplication instantiation Move the Open GL and scaling options setting QCoreApplication attributes into the helper getAppFlags() which already handles the application type. Change getAppFlags() to not modify argv which is not necessary since the parser will accept the options. Change-Id: Ib2f94f832e6551a938ff0e9bfe27649850d38d1e Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2020-01-15 09:55:27 +00:00
# endif // QT_WIDGETS_LIB
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
}
qml: Fix options that need to be set before QApplication instantiation Move the Open GL and scaling options setting QCoreApplication attributes into the helper getAppFlags() which already handles the application type. Change getAppFlags() to not modify argv which is not necessary since the parser will accept the options. Change-Id: Ib2f94f832e6551a938ff0e9bfe27649850d38d1e Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2020-01-15 09:55:27 +00:00
} else if (!strcmp(argv[i], "-desktop") || !strcmp(argv[i], "--desktop")) {
QCoreApplication::setAttribute(Qt::AA_UseDesktopOpenGL);
} else if (!strcmp(argv[i], "-gles") || !strcmp(argv[i], "--gles")) {
QCoreApplication::setAttribute(Qt::AA_UseOpenGLES);
} else if (!strcmp(argv[i], "-software") || !strcmp(argv[i], "--software")) {
QCoreApplication::setAttribute(Qt::AA_UseSoftwareOpenGL);
qml: Enable context sharing by default The qml utility now uses context sharing by default, as previously done by qmlscene. It can also be disabled in the same way, by specifying --disable-context-sharing. This is needed for compatibility with QtWebEngine among other things. Fixes: QTBUG-85107 Change-Id: I6155d32dfc55b385d33e1c805dae601b9710427e Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-03-18 14:10:46 +00:00
} else if (!strcmp(argv[i], "-disable-context-sharing") || !strcmp(argv[i], "--disable-context-sharing")) {
glShareContexts = false;
qml tool: Disable shader caching by default When shaders are generated dynamically, such as with QtQuick3D, cached shaders may get out of date if the QML file is changed. Change-Id: I2c5484765e30da5c13fd175a9fcbad2473d55e62 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Christian Strømme <christian.stromme@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2023-02-02 10:00:13 +00:00
} else if (!strcmp(argv[i], "-enable-shader-cache") || !strcmp(argv[i], "--enable-shader-cache")) {
disableShaderCache = false;
Bring QSurfaceFormat configurability to qmlscene's level in the qml tool Restore the --transparent and --multisample options. Also make the default QSurfaceFormat setting universal (no need to tie it to the option of forcing a core profile context), and prevent the warning that is printed when the default surfaceformat is changed after the application is already created with AA_ShareOpenGLContexts set. This involves having to handle the relevant arguments manually early on, not through QCommandLineParser. All this matches the qmlscene behavior. NB qmlscene requests 16 samples with --multisample which is completely pointless in practice. Use the common 4 now. Change-Id: I671e5f22846a715675ea936bb7cf2a31a849dc28 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2023-02-02 12:50:19 +00:00
} else if (!strcmp(argv[i], "-transparent") || !strcmp(argv[i], "--transparent")) {
requestAlphaChannel = true;
} else if (!strcmp(argv[i], "-multisample") || !strcmp(argv[i], "--multisample")) {
requestMSAA = true;
} else if (!strcmp(argv[i], "-core-profile") || !strcmp(argv[i], "--core-profile")) {
requestCoreProfile = true;
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
}
}
Fix forced error warnings in -no-gui build compiling main.cpp main.cpp:361:23: error: unused parameter argc [-Werror=unused-parameter] void getAppFlags(int &argc, char **argv) ^ main.cpp:361:36: error: unused parameter argv [-Werror=unused-parameter] void getAppFlags(int &argc, char **argv) ^ main.cpp:74:12: error: exitTimerId defined but not used [-Werror=unused-variable] static int exitTimerId = -1; ^ Change-Id: I3eb7aff4ab3b5f1e89fdbf6d090107efedb376dd Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2017-04-12 13:45:18 +00:00
#else
Add ; to Q_UNUSED and UNUSED_PARAM This is required to remove the ; from the macro with Qt 6. Task-number: QTBUG-82978 Change-Id: Iead53d18fd790fb2d870d80ef2db79666f0d2392 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2020-06-26 12:43:02 +00:00
Q_UNUSED(argc);
Q_UNUSED(argv);
Remove '-enable-debugger' argument from qml executable Task-number: QTBUG-34836 Change-Id: I3ab2a16036a1086c0ac1f50880a402caf9f54f2d Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-11-14 11:38:25 +00:00
#endif // QT_GUI_LIB
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
}
qml: Deprecate the --dummy-data option [ChangeLog][QtQml][qml] The QML Runtime tool's --dummy-data option is now deprecated, because context properties are deprecated. This option will be removed in a future version of Qt. Task-number: QTBUG-96800 Change-Id: Id6ef8a384f6239ddeebd6c4f84854bbeaf630279 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-22 18:33:51 +00:00
#if QT_DEPRECATED_SINCE(6, 3)
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
static void loadDummyDataFiles(QQmlEngine &engine, const QString& directory)
{
QDir dir(directory+"/dummydata", "*.qml");
QStringList list = dir.entryList();
for (int i = 0; i < list.size(); ++i) {
QString qml = list.at(i);
Fix crash in qml/qmlscene when using dummy-data with imports When using the tools qml and qmlscene with dummy-data it will crash or behave wrong, due to the dummy-data component will get the state not ready, if the dummy-data qml-files does an import of another folder or a js-file. By changing the way of loading dummy-data, by letting QQmlComponent handle the file opening instead of using the setData() method, qmlscene and qml will be able to handle this type of dummy-data. The tool qml also needed to load the dummy data before loading the regular components, otherwise the dummy-data would not be ready for the other components to use. Task-number: QTBUG-32721 Change-Id: Ia1cc2b2626187e23c7d7313be788202d91b12471 Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2014-03-01 06:28:29 +00:00
QQmlComponent comp(&engine, dir.filePath(qml));
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
QObject *dummyData = comp.create();
if (comp.isError()) {
tools: replace 'foreach' with 'range for' Mark some local variables or parameters as const to prevent detach()'ing. Use qAsConst where is not possible mark as const. Change-Id: I0a777c3bd855abd3bb1ad0907152360cf4a1050e Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-08-11 10:08:00 +00:00
const QList<QQmlError> errors = comp.errors();
for (const QQmlError &error : errors)
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
qWarning() << error;
}
if (dummyData && !quietMode) {
Add a verbose mode to qml The extra output is primarily useful for debugging, and on windows it will actually make an ugly command prompt window appear. Change-Id: I552e479515a6f5249685844143601cb7449a10b5 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2013-10-23 22:37:16 +00:00
printf("qml: Loaded dummy data: %s\n", qPrintable(dir.filePath(qml)));
Port from container::count() and length() to size() This is a semantic patch using ClangTidyTransformator as in qtbase/df9d882d41b741fef7c5beeddb0abe9d904443d8: auto QtContainerClass = anyOf( expr(hasType(cxxRecordDecl(isSameOrDerivedFrom(hasAnyName(classes))))).bind(o), expr(hasType(namedDecl(hasAnyName(<classes>)))).bind(o)); makeRule(cxxMemberCallExpr(on(QtContainerClass), callee(cxxMethodDecl(hasAnyName({"count", "length"), parameterCountIs(0))))), changeTo(cat(access(o, cat("size"), "()"))), cat("use 'size()' instead of 'count()/length()'")) a.k.a qt-port-to-std-compatible-api with config Scope: 'Container', with the extended set of container classes recognized. Change-Id: Idb1f75dfe2323bd1d9e8b4d58d54f1b4b80c7ed7 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-10-05 05:29:16 +00:00
qml.truncate(qml.size()-4);
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
engine.rootContext()->setContextProperty(qml, dummyData);
dummyData->setParent(&engine);
}
}
}
qml: Deprecate the --dummy-data option [ChangeLog][QtQml][qml] The QML Runtime tool's --dummy-data option is now deprecated, because context properties are deprecated. This option will be removed in a future version of Qt. Task-number: QTBUG-96800 Change-Id: Id6ef8a384f6239ddeebd6c4f84854bbeaf630279 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-22 18:33:51 +00:00
#endif
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
int main(int argc, char *argv[])
{
getAppFlags(argc, argv);
qml: Enable context sharing by default The qml utility now uses context sharing by default, as previously done by qmlscene. It can also be disabled in the same way, by specifying --disable-context-sharing. This is needed for compatibility with QtWebEngine among other things. Fixes: QTBUG-85107 Change-Id: I6155d32dfc55b385d33e1c805dae601b9710427e Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-03-18 14:10:46 +00:00
Bring QSurfaceFormat configurability to qmlscene's level in the qml tool Restore the --transparent and --multisample options. Also make the default QSurfaceFormat setting universal (no need to tie it to the option of forcing a core profile context), and prevent the warning that is printed when the default surfaceformat is changed after the application is already created with AA_ShareOpenGLContexts set. This involves having to handle the relevant arguments manually early on, not through QCommandLineParser. All this matches the qmlscene behavior. NB qmlscene requests 16 samples with --multisample which is completely pointless in practice. Use the common 4 now. Change-Id: I671e5f22846a715675ea936bb7cf2a31a849dc28 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2023-02-02 12:50:19 +00:00
// Must set the default QSurfaceFormat before creating the app object if
// AA_ShareOpenGLContexts is going to be set.
#if defined(QT_GUI_LIB)
QSurfaceFormat surfaceFormat;
surfaceFormat.setDepthBufferSize(24);
surfaceFormat.setStencilBufferSize(8);
if (requestMSAA)
surfaceFormat.setSamples(4);
qml tool: Fix incorrect mapping of --transparent to MSAA Change-Id: Ief9f12c1b3dfab928b110278c1d49abb1028efe0 Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2023-03-16 15:21:37 +00:00
if (requestAlphaChannel)
Bring QSurfaceFormat configurability to qmlscene's level in the qml tool Restore the --transparent and --multisample options. Also make the default QSurfaceFormat setting universal (no need to tie it to the option of forcing a core profile context), and prevent the warning that is printed when the default surfaceformat is changed after the application is already created with AA_ShareOpenGLContexts set. This involves having to handle the relevant arguments manually early on, not through QCommandLineParser. All this matches the qmlscene behavior. NB qmlscene requests 16 samples with --multisample which is completely pointless in practice. Use the common 4 now. Change-Id: I671e5f22846a715675ea936bb7cf2a31a849dc28 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2023-02-02 12:50:19 +00:00
surfaceFormat.setAlphaBufferSize(8);
if (qEnvironmentVariableIsSet("QSG_CORE_PROFILE")
|| qEnvironmentVariableIsSet("QML_CORE_PROFILE")
|| requestCoreProfile)
{
// intentionally requesting 4.1 core to play nice with macOS
surfaceFormat.setVersion(4, 1);
surfaceFormat.setProfile(QSurfaceFormat::CoreProfile);
}
QSurfaceFormat::setDefaultFormat(surfaceFormat);
#endif
qml: Enable context sharing by default The qml utility now uses context sharing by default, as previously done by qmlscene. It can also be disabled in the same way, by specifying --disable-context-sharing. This is needed for compatibility with QtWebEngine among other things. Fixes: QTBUG-85107 Change-Id: I6155d32dfc55b385d33e1c805dae601b9710427e Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-03-18 14:10:46 +00:00
if (glShareContexts)
QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
qml tool: Disable shader caching by default When shaders are generated dynamically, such as with QtQuick3D, cached shaders may get out of date if the QML file is changed. Change-Id: I2c5484765e30da5c13fd175a9fcbad2473d55e62 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Christian Strømme <christian.stromme@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2023-02-02 10:00:13 +00:00
if (disableShaderCache)
QCoreApplication::setAttribute(Qt::AA_DisableShaderDiskCache);
qml: Enable context sharing by default The qml utility now uses context sharing by default, as previously done by qmlscene. It can also be disabled in the same way, by specifying --disable-context-sharing. This is needed for compatibility with QtWebEngine among other things. Fixes: QTBUG-85107 Change-Id: I6155d32dfc55b385d33e1c805dae601b9710427e Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-03-18 14:10:46 +00:00
qml: Make sure the qml tool deletes its application Otherwise the shutdown mechanism for debug services doesn't work. Fixes: QTBUG-78828 Change-Id: I4ede5861a300d5b5007036d71ed84409ec4d450f Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2019-09-30 08:53:49 +00:00
std::unique_ptr<QCoreApplication> app;
Make qtdeclarative compile with -no-gui Change-Id: I079f5e09a0099550348388379c496fc8f8cfa27c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-10-12 02:59:09 +00:00
switch (applicationType) {
#ifdef QT_GUI_LIB
case QmlApplicationTypeGui:
Replace qt_make_unique with std::make_unique So we can remove it. Change-Id: I037373f85c696ce04c55920b41377cc9843b0da3 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2020-11-17 12:41:35 +00:00
app = std::make_unique<LoaderApplication>(argc, argv);
Make qtdeclarative compile with -no-gui Change-Id: I079f5e09a0099550348388379c496fc8f8cfa27c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-10-12 02:59:09 +00:00
break;
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
#ifdef QT_WIDGETS_LIB
Make qtdeclarative compile with -no-gui Change-Id: I079f5e09a0099550348388379c496fc8f8cfa27c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-10-12 02:59:09 +00:00
case QmlApplicationTypeWidget:
Replace qt_make_unique with std::make_unique So we can remove it. Change-Id: I037373f85c696ce04c55920b41377cc9843b0da3 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2020-11-17 12:41:35 +00:00
app = std::make_unique<QApplication>(argc, argv);
qml: Make sure the qml tool deletes its application Otherwise the shutdown mechanism for debug services doesn't work. Fixes: QTBUG-78828 Change-Id: I4ede5861a300d5b5007036d71ed84409ec4d450f Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2019-09-30 08:53:49 +00:00
static_cast<QApplication *>(app.get())->setWindowIcon(QIcon(iconResourcePath));
Make qtdeclarative compile with -no-gui Change-Id: I079f5e09a0099550348388379c496fc8f8cfa27c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-10-12 02:59:09 +00:00
break;
#endif // QT_WIDGETS_LIB
#endif // QT_GUI_LIB
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
case QmlApplicationTypeCore:
Q_FALLTHROUGH();
default: // QmlApplicationTypeUnknown: not allowed, but we'll exit after checking apptypeOption below
Replace qt_make_unique with std::make_unique So we can remove it. Change-Id: I037373f85c696ce04c55920b41377cc9843b0da3 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2020-11-17 12:41:35 +00:00
app = std::make_unique<QCoreApplication>(argc, argv);
Make qtdeclarative compile with -no-gui Change-Id: I079f5e09a0099550348388379c496fc8f8cfa27c Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2013-10-12 02:59:09 +00:00
break;
}
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
app->setApplicationName("Qml Runtime");
Tools and examples: consistently use organization name QtProject This affects the location of the QSettings files or registry entries. Other parts of Qt are using this organization name so it's good to have all the settings in the same place. [ChangeLog][QtQuick] tools and examples consistently use the QtProject organization name Change-Id: I1fae4eaed0248411fe95dda9572d38006648b162 Reviewed-by: J-P Nurmi <jpnurmi@digia.com>
2014-06-27 10:59:14 +00:00
app->setOrganizationName("QtProject");
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
app->setOrganizationDomain("qt-project.org");
Set Qt version on tools Change-Id: I21d77b2eba7107528fc00db0cf5d87f8347b63be Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2016-11-08 12:09:54 +00:00
QCoreApplication::setApplicationVersion(QLatin1String(QT_VERSION_STR));
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
QStringList files;
QString confFile;
QString translationFile;
Clean up LoadWatcher in the Qml Runtime Name the variables in a self-documenting way. While we're at it, do initialization at declaration when possible, reorder the public sections before the private ones, fix comment spacing, and use function-pointer connect syntax where possible. Change-Id: I3fddc8f6d27afa197d425fb7ae3baee02acedceb Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2019-01-14 08:42:29 +00:00
// Handle main arguments
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
QCommandLineParser parser;
parser.setSingleDashWordOptionMode(QCommandLineParser::ParseAsLongOptions);
parser.setOptionsAfterPositionalArgumentsMode(QCommandLineParser::ParseAsPositionalArguments);
qml tool: Use QCommandLineParser::process() rather than parse() This handles the --version, --help and --help-all options. Apparently there's no other way to handle --help-all, because addHelpOption() adds two options but only returns one of them. Amends bb6602bca2b20d98f24320b10c7a039e605c9a05 Fixes: QTBUG-100678 Pick-to: 6.2 6.5 5.15 Change-Id: Iddd1ba2dae975d7256935d8d357e2f3ac6c013d6 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2023-05-16 05:59:46 +00:00
parser.addHelpOption();
parser.addVersionOption();
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
#ifdef QT_GUI_LIB
QCommandLineOption apptypeOption(QStringList() << QStringLiteral("a") << QStringLiteral("apptype"),
QCoreApplication::translate("main", "Select which application class to use. Default is gui."),
#ifdef QT_WIDGETS_LIB
QStringLiteral("core|gui|widget"));
#else
QStringLiteral("core|gui"));
#endif // QT_WIDGETS_LIB
parser.addOption(apptypeOption); // Just for the help text... we've already handled this argument above
#endif // QT_GUI_LIB
QCommandLineOption importOption(QStringLiteral("I"),
QCoreApplication::translate("main", "Prepend the given path to the import paths."), QStringLiteral("path"));
parser.addOption(importOption);
QCommandLineOption qmlFileOption(QStringLiteral("f"),
QCoreApplication::translate("main", "Load the given file as a QML file."), QStringLiteral("file"));
parser.addOption(qmlFileOption);
QCommandLineOption configOption(QStringList() << QStringLiteral("c") << QStringLiteral("config"),
qml runtime tool: support alternate conf; add resizeToItem conf The qmlscene --resize-to-root feature has always been missing from the qml runtime tool; however it was already possible to add it by writing a custom configuration file. Now we support loading different configurations from resources as well as from the filesystem, and the first new configuration being added here is resizeToItem.qml which provides behavior equivalent to qmlscene --resize-to-root. When the argument given to --config ends with .qml, by convention it's to be loaded from the filesystem; whereas configurations from resources are specified without the .qml extension (to make the command line shorter). [ChangeLog][QtQml][qml] The QML Runtime tool now has default behavior matching qmlscene when the root QML object is an Item: it will be wrapped in a Window which will resize the Item when the Window is resized. But you can alternatively use the --config resizeToItem option, resulting in the same behavior as qmlscene --resizeToRoot: resizing the root Item programmatically causes the wrapping Window to be resized. Behavior can still be customized in other ways using the --config option with an external QML configuration file. Task-number: QTBUG-53557 Change-Id: Icdcbbd12258105c33b64634049d735e022dfbd06 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-24 19:05:32 +00:00
QCoreApplication::translate("main", "Load the given built-in configuration or configuration file."), QStringLiteral("file"));
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
parser.addOption(configOption);
qml runtime tool: support alternate conf; add resizeToItem conf The qmlscene --resize-to-root feature has always been missing from the qml runtime tool; however it was already possible to add it by writing a custom configuration file. Now we support loading different configurations from resources as well as from the filesystem, and the first new configuration being added here is resizeToItem.qml which provides behavior equivalent to qmlscene --resize-to-root. When the argument given to --config ends with .qml, by convention it's to be loaded from the filesystem; whereas configurations from resources are specified without the .qml extension (to make the command line shorter). [ChangeLog][QtQml][qml] The QML Runtime tool now has default behavior matching qmlscene when the root QML object is an Item: it will be wrapped in a Window which will resize the Item when the Window is resized. But you can alternatively use the --config resizeToItem option, resulting in the same behavior as qmlscene --resizeToRoot: resizing the root Item programmatically causes the wrapping Window to be resized. Behavior can still be customized in other ways using the --config option with an external QML configuration file. Task-number: QTBUG-53557 Change-Id: Icdcbbd12258105c33b64634049d735e022dfbd06 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-24 19:05:32 +00:00
QCommandLineOption listConfOption(QStringList() << QStringLiteral("list-conf"),
QCoreApplication::translate("main", "List the built-in configurations."));
parser.addOption(listConfOption);
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
QCommandLineOption translationOption(QStringLiteral("translation"),
QCoreApplication::translate("main", "Load the given file as the translations file."), QStringLiteral("file"));
parser.addOption(translationOption);
qml: Deprecate the --dummy-data option [ChangeLog][QtQml][qml] The QML Runtime tool's --dummy-data option is now deprecated, because context properties are deprecated. This option will be removed in a future version of Qt. Task-number: QTBUG-96800 Change-Id: Id6ef8a384f6239ddeebd6c4f84854bbeaf630279 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-22 18:33:51 +00:00
#if QT_DEPRECATED_SINCE(6, 3)
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
QCommandLineOption dummyDataOption(QStringLiteral("dummy-data"),
qml: Deprecate the --dummy-data option [ChangeLog][QtQml][qml] The QML Runtime tool's --dummy-data option is now deprecated, because context properties are deprecated. This option will be removed in a future version of Qt. Task-number: QTBUG-96800 Change-Id: Id6ef8a384f6239ddeebd6c4f84854bbeaf630279 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-22 18:33:51 +00:00
QCoreApplication::translate("main", "Load QML files from the given directory as context properties. (deprecated)"), QStringLiteral("file"));
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
parser.addOption(dummyDataOption);
qml: Deprecate the --dummy-data option [ChangeLog][QtQml][qml] The QML Runtime tool's --dummy-data option is now deprecated, because context properties are deprecated. This option will be removed in a future version of Qt. Task-number: QTBUG-96800 Change-Id: Id6ef8a384f6239ddeebd6c4f84854bbeaf630279 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-22 18:33:51 +00:00
#endif
qml: Fix options that need to be set before QApplication instantiation Move the Open GL and scaling options setting QCoreApplication attributes into the helper getAppFlags() which already handles the application type. Change getAppFlags() to not modify argv which is not necessary since the parser will accept the options. Change-Id: Ib2f94f832e6551a938ff0e9bfe27649850d38d1e Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2020-01-15 09:55:27 +00:00
#ifdef QT_GUI_LIB
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
// OpenGL options
QCommandLineOption glDesktopOption(QStringLiteral("desktop"),
QCoreApplication::translate("main", "Force use of desktop OpenGL (AA_UseDesktopOpenGL)."));
qml: Fix options that need to be set before QApplication instantiation Move the Open GL and scaling options setting QCoreApplication attributes into the helper getAppFlags() which already handles the application type. Change getAppFlags() to not modify argv which is not necessary since the parser will accept the options. Change-Id: Ib2f94f832e6551a938ff0e9bfe27649850d38d1e Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2020-01-15 09:55:27 +00:00
parser.addOption(glDesktopOption); // Just for the help text... we've already handled this argument above
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
QCommandLineOption glEsOption(QStringLiteral("gles"),
QCoreApplication::translate("main", "Force use of GLES (AA_UseOpenGLES)."));
qml: Fix options that need to be set before QApplication instantiation Move the Open GL and scaling options setting QCoreApplication attributes into the helper getAppFlags() which already handles the application type. Change getAppFlags() to not modify argv which is not necessary since the parser will accept the options. Change-Id: Ib2f94f832e6551a938ff0e9bfe27649850d38d1e Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2020-01-15 09:55:27 +00:00
parser.addOption(glEsOption); // Just for the help text... we've already handled this argument above
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
QCommandLineOption glSoftwareOption(QStringLiteral("software"),
QCoreApplication::translate("main", "Force use of software rendering (AA_UseSoftwareOpenGL)."));
qml: Fix options that need to be set before QApplication instantiation Move the Open GL and scaling options setting QCoreApplication attributes into the helper getAppFlags() which already handles the application type. Change getAppFlags() to not modify argv which is not necessary since the parser will accept the options. Change-Id: Ib2f94f832e6551a938ff0e9bfe27649850d38d1e Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2020-01-15 09:55:27 +00:00
parser.addOption(glSoftwareOption); // Just for the help text... we've already handled this argument above
tools/qml: Implement --core-profile option Already possible to do the same using environment variables but this ensures greater compatibility with qmlscene and better ease of use. Change-Id: I214aec41aad4369f54bca887e91ccb879153c8be Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
2021-03-16 09:40:54 +00:00
QCommandLineOption glCoreProfile(QStringLiteral("core-profile"),
QCoreApplication::translate("main", "Force use of OpenGL Core Profile."));
Bring QSurfaceFormat configurability to qmlscene's level in the qml tool Restore the --transparent and --multisample options. Also make the default QSurfaceFormat setting universal (no need to tie it to the option of forcing a core profile context), and prevent the warning that is printed when the default surfaceformat is changed after the application is already created with AA_ShareOpenGLContexts set. This involves having to handle the relevant arguments manually early on, not through QCommandLineParser. All this matches the qmlscene behavior. NB qmlscene requests 16 samples with --multisample which is completely pointless in practice. Use the common 4 now. Change-Id: I671e5f22846a715675ea936bb7cf2a31a849dc28 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2023-02-02 12:50:19 +00:00
parser.addOption(glCoreProfile); // Just for the help text... we've already handled this argument above
qml: Enable context sharing by default The qml utility now uses context sharing by default, as previously done by qmlscene. It can also be disabled in the same way, by specifying --disable-context-sharing. This is needed for compatibility with QtWebEngine among other things. Fixes: QTBUG-85107 Change-Id: I6155d32dfc55b385d33e1c805dae601b9710427e Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2021-03-18 14:10:46 +00:00
QCommandLineOption glContextSharing(QStringLiteral("disable-context-sharing"),
QCoreApplication::translate("main", "Disable the use of a shared GL context for QtQuick Windows"));
parser.addOption(glContextSharing); // Just for the help text... we've already handled this argument above
Bring QSurfaceFormat configurability to qmlscene's level in the qml tool Restore the --transparent and --multisample options. Also make the default QSurfaceFormat setting universal (no need to tie it to the option of forcing a core profile context), and prevent the warning that is printed when the default surfaceformat is changed after the application is already created with AA_ShareOpenGLContexts set. This involves having to handle the relevant arguments manually early on, not through QCommandLineParser. All this matches the qmlscene behavior. NB qmlscene requests 16 samples with --multisample which is completely pointless in practice. Use the common 4 now. Change-Id: I671e5f22846a715675ea936bb7cf2a31a849dc28 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2023-02-02 12:50:19 +00:00
// Options relevant for other 3D APIs as well
qml tool: Disable shader caching by default When shaders are generated dynamically, such as with QtQuick3D, cached shaders may get out of date if the QML file is changed. Change-Id: I2c5484765e30da5c13fd175a9fcbad2473d55e62 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Christian Strømme <christian.stromme@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2023-02-02 10:00:13 +00:00
QCommandLineOption shaderCaching(QStringLiteral("enable-shader-cache"),
QCoreApplication::translate("main", "Enable persistent caching of generated shaders"));
parser.addOption(shaderCaching); // Just for the help text... we've already handled this argument above
Bring QSurfaceFormat configurability to qmlscene's level in the qml tool Restore the --transparent and --multisample options. Also make the default QSurfaceFormat setting universal (no need to tie it to the option of forcing a core profile context), and prevent the warning that is printed when the default surfaceformat is changed after the application is already created with AA_ShareOpenGLContexts set. This involves having to handle the relevant arguments manually early on, not through QCommandLineParser. All this matches the qmlscene behavior. NB qmlscene requests 16 samples with --multisample which is completely pointless in practice. Use the common 4 now. Change-Id: I671e5f22846a715675ea936bb7cf2a31a849dc28 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2023-02-02 12:50:19 +00:00
QCommandLineOption transparentOption(QStringLiteral("transparent"),
QCoreApplication::translate("main", "Requests an alpha channel in order to enable semi-transparent windows."));
parser.addOption(transparentOption); // Just for the help text... we've already handled this argument above
QCommandLineOption multisampleOption(QStringLiteral("multisample"),
QCoreApplication::translate("main", "Requests 4x multisample antialiasing."));
parser.addOption(multisampleOption); // Just for the help text... we've already handled this argument above
qml: Fix options that need to be set before QApplication instantiation Move the Open GL and scaling options setting QCoreApplication attributes into the helper getAppFlags() which already handles the application type. Change getAppFlags() to not modify argv which is not necessary since the parser will accept the options. Change-Id: Ib2f94f832e6551a938ff0e9bfe27649850d38d1e Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2020-01-15 09:55:27 +00:00
#endif // QT_GUI_LIB
Bring QSurfaceFormat configurability to qmlscene's level in the qml tool Restore the --transparent and --multisample options. Also make the default QSurfaceFormat setting universal (no need to tie it to the option of forcing a core profile context), and prevent the warning that is printed when the default surfaceformat is changed after the application is already created with AA_ShareOpenGLContexts set. This involves having to handle the relevant arguments manually early on, not through QCommandLineParser. All this matches the qmlscene behavior. NB qmlscene requests 16 samples with --multisample which is completely pointless in practice. Use the common 4 now. Change-Id: I671e5f22846a715675ea936bb7cf2a31a849dc28 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2023-02-02 12:50:19 +00:00
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
// Debugging and verbosity options
QCommandLineOption quietOption(QStringLiteral("quiet"),
QCoreApplication::translate("main", "Suppress all output."));
parser.addOption(quietOption);
QCommandLineOption verboseOption(QStringLiteral("verbose"),
QCoreApplication::translate("main", "Print information about what qml is doing, like specific file URLs being loaded."));
parser.addOption(verboseOption);
QCommandLineOption slowAnimationsOption(QStringLiteral("slow-animations"),
QCoreApplication::translate("main", "Run all animations in slow motion."));
parser.addOption(slowAnimationsOption);
QCommandLineOption fixedAnimationsOption(QStringLiteral("fixed-animations"),
QCoreApplication::translate("main", "Run animations off animation tick rather than wall time."));
parser.addOption(fixedAnimationsOption);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
QCommandLineOption rhiOption(QStringList() << QStringLiteral("r") << QStringLiteral("rhi"),
Clean up QT_CONFIG(opengl) Accelerated graphics is now possible without OpenGL support. With this change, a Qt build with -no-opengl can still run Qt Quick with a Vulkan, Metal, or Direct3D backend. Fixes: QTBUG-84027 Change-Id: Ib63c733d28cfdf7de16b138df136fa7628e1747b Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-16 15:03:47 +00:00
QCoreApplication::translate("main", "Set the backend for the Qt graphics abstraction (RHI). "
Mention d3d12 in qml tool help text It works since 6.6 regardless, but the help text had no mentioning of it at all. Also use the nicer "opengl" instead of "gl" (both are accepted by QSG_RHI_BACKEND anyway) Pick-to: 6.7 6.6 Change-Id: Ibf6de9411d8641d244b8750fd7a015781a9297b1 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2024-03-08 08:37:39 +00:00
"Backend is one of: default, vulkan, metal, d3d11, d3d12, opengl"),
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
QStringLiteral("backend"));
parser.addOption(rhiOption);
Add support for file selectors to qml tool This allows defining file selectors using a command-line option. [ChangeLog][QtQml][qml] The QML Runtime tool --selector option now allows defining a custom QQmlFileSelector. Change-Id: I1be5efd273b2f387df72b1d5057f7281e5c0c156 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2020-01-30 14:43:57 +00:00
QCommandLineOption selectorOption(QStringLiteral("S"), QCoreApplication::translate("main",
"Add selector to the list of QQmlFileSelectors."), QStringLiteral("selector"));
parser.addOption(selectorOption);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
// Positional arguments
parser.addPositionalArgument("files",
QCoreApplication::translate("main", "Any number of QML files can be loaded. They will share the same engine."), "[files...]");
parser.addPositionalArgument("args",
QCoreApplication::translate("main", "Arguments after '--' are ignored, but passed through to the application.arguments variable in QML."), "[-- args...]");
qml tool: Use QCommandLineParser::process() rather than parse() This handles the --version, --help and --help-all options. Apparently there's no other way to handle --help-all, because addHelpOption() adds two options but only returns one of them. Amends bb6602bca2b20d98f24320b10c7a039e605c9a05 Fixes: QTBUG-100678 Pick-to: 6.2 6.5 5.15 Change-Id: Iddd1ba2dae975d7256935d8d357e2f3ac6c013d6 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2023-05-16 05:59:46 +00:00
parser.process(*app);
Teach the qml runtime to load config files by basename Also, --list-conf will now list the conf files that it finds; and --verbose will show more information about the path(s) to them. [ChangeLog][QtQml][qml] The QML Runtime tool's -c / --config option now can find a directory containing a file called configuration.qml under QStandardPaths::AppConfigLocation, in addition to being able to give the full path to the configuration file, as before. I.e. on Linux you could write a custom configuration into ~/.config/QtProject/Qml Runtime/myconfig/configuration.qml and then use it via qml -c myconfig somefile.qml. The --list-conf option will list the configurations that can be found in this way. Task-number: QTBUG-26366 Fixes: QTBUG-96740 Change-Id: I72798b22255b71b9d4184a67f86b249766b64233 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-21 13:23:55 +00:00
if (parser.isSet(verboseOption))
verboseMode = true;
if (parser.isSet(quietOption)) {
quietMode = true;
verboseMode = false;
}
qml runtime tool: support alternate conf; add resizeToItem conf The qmlscene --resize-to-root feature has always been missing from the qml runtime tool; however it was already possible to add it by writing a custom configuration file. Now we support loading different configurations from resources as well as from the filesystem, and the first new configuration being added here is resizeToItem.qml which provides behavior equivalent to qmlscene --resize-to-root. When the argument given to --config ends with .qml, by convention it's to be loaded from the filesystem; whereas configurations from resources are specified without the .qml extension (to make the command line shorter). [ChangeLog][QtQml][qml] The QML Runtime tool now has default behavior matching qmlscene when the root QML object is an Item: it will be wrapped in a Window which will resize the Item when the Window is resized. But you can alternatively use the --config resizeToItem option, resulting in the same behavior as qmlscene --resizeToRoot: resizing the root Item programmatically causes the wrapping Window to be resized. Behavior can still be customized in other ways using the --config option with an external QML configuration file. Task-number: QTBUG-53557 Change-Id: Icdcbbd12258105c33b64634049d735e022dfbd06 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-24 19:05:32 +00:00
if (parser.isSet(listConfOption))
listConfFiles();
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
if (applicationType == QmlApplicationTypeUnknown) {
#ifdef QT_WIDGETS_LIB
qWarning() << QCoreApplication::translate("main", "--apptype must be followed by one of the following: core gui widget\n");
#else
qWarning() << QCoreApplication::translate("main", "--apptype must be followed by one of the following: core gui\n");
#endif // QT_WIDGETS_LIB
parser.showHelp();
}
Add a feature for qml-animation It should be possible to switch it off without globally switching animations off in Qt. Change-Id: I3cae6b72b2c6b5c420f21625208de5e273839438 Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@qt.io> Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-12-19 15:37:24 +00:00
#if QT_CONFIG(qml_animation)
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
if (parser.isSet(slowAnimationsOption))
QUnifiedTimer::instance()->setSlowModeEnabled(true);
if (parser.isSet(fixedAnimationsOption))
QUnifiedTimer::instance()->setConsistentTiming(true);
Fix build without features.animation Change-Id: Ie45a2f01def64941a323973ea27446e3fc85a72b Reviewed-by: Robin Burchell <robin.burchell@crimson.no> Reviewed-by: Paul Olav Tvete <paul.tvete@qt.io>
2017-03-30 08:41:52 +00:00
#endif
qml: Construct QQmlApplicationEngine only when we need it Otherwise we leak a lot of memory if any of the exit() calls is triggered. Change-Id: I338abe2ef63217e6b80ffc2f8fe65d9cac03d994 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Semih Yavuz <semih.yavuz@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-04-26 13:26:36 +00:00
QQmlApplicationEngine e;
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
for (const QString &importPath : parser.values(importOption))
e.addImportPath(importPath);
Add support for file selectors to qml tool This allows defining file selectors using a command-line option. [ChangeLog][QtQml][qml] The QML Runtime tool --selector option now allows defining a custom QQmlFileSelector. Change-Id: I1be5efd273b2f387df72b1d5057f7281e5c0c156 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2020-01-30 14:43:57 +00:00
QStringList customSelectors;
for (const QString &selector : parser.values(selectorOption))
customSelectors.append(selector);
Clean up QQmlFileSelector The global static map of file selectors is not thread safe. If you add a file selector to engine A running in thread 1, you cannot at the same time retrieve the file selector of engine B running in thread 2. Alas, we only need the static map to discern file selectors from other URL interceptors, and we only need to do this on QQmlFileSelector::get(), which we don't use. Unfortunately it is public API, though. Deprecate QQmlFileSelector::get() and add a different hack to discern the interceptors for the case that it's still called. Also remove the duplicate setExtraSelectors() method. For this to work, we also add a method to QQmlApplicationEngine that allows us to pass extra file selectors and delay the initialization of QQmlApplicationEngine's QQmlFileSelector until the first file is loaded. [ChangeLog][QML] QQmlFileSelector::get() is deprecated. You can use the new method QQmlAplicationEngine::setExtraFileSelectors() to pass extra selectors to QQmlApplicationEngine's internal QQmlFileSelector. Manually created QQmlFileSelectors should be configured immediately after creation, before they are used by the QQmlEngine. Change-Id: Ia61a93777dc910b441a03ffb42d35a2a224c0e26 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2020-02-07 15:59:51 +00:00
if (!customSelectors.isEmpty())
e.setExtraFileSelectors(customSelectors);
Add support for file selectors to qml tool This allows defining file selectors using a command-line option. [ChangeLog][QtQml][qml] The QML Runtime tool --selector option now allows defining a custom QQmlFileSelector. Change-Id: I1be5efd273b2f387df72b1d5057f7281e5c0c156 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2020-01-30 14:43:57 +00:00
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
files << parser.values(qmlFileOption);
if (parser.isSet(configOption))
confFile = parser.value(configOption);
if (parser.isSet(translationOption))
translationFile = parser.value(translationOption);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (parser.isSet(rhiOption)) {
const QString rhiBackend = parser.value(rhiOption);
if (rhiBackend == QLatin1String("default"))
qunsetenv("QSG_RHI_BACKEND");
else
qputenv("QSG_RHI_BACKEND", rhiBackend.toLatin1());
}
Use QCommandLineParser in the qml runtime tool Some advantages: - support double-hyphen options as well as the existing single-hyphen options - support translation of the usage text [ChangeLog][QtQml][qml] The QML Runtime tool now accepts command-line arguments in double-dash GNU style as well as the old single-dash style. Task-number: QTBUG-53557 Change-Id: I9929c63841272894640abe254efaea9773eee633 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-16 15:25:36 +00:00
for (QString posArg : parser.positionalArguments()) {
if (posArg == QLatin1String("--"))
break;
else
files << posArg;
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
}
Get rid of most QT_NO_FOO usages Instead use QT_CONFIG(foo). This change actually detected a few mis-spelled macros and invalid usages. Change-Id: I06ac327098dd1a458e6bc379d637b8e2dac52f85 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2016-11-16 13:22:36 +00:00
#if QT_CONFIG(translation)
Use QTranslator::install(QLocale, ...) everywhere QTranslator::install(QLocale, ...) indirectly uses QLocale::uiLanguages(), which is the correct way to ask the system for ui languages. This was already attempted once in commit 427646b8d7, but reverted later on in commit 05d8ffb4df, because it requires shipping .qm files for the native language. Anyhow, we're shipping empty Qt translations for English since a while, and also have been fixing our examples to do so. [ChangeLog][Important Behavior Changes] The automatic translation loading in qml, qmlscene and QQmlApplicationEngine now tries to load translations for all languages in QLocale::uiLanguages(). This might require shipping an empty translation for the source language. Task-number: QTBUG-7329 Task-number: QTBUG-41977 Task-number: QTBUG-69196 Change-Id: Ifcf45b453ee9d05c018f379cc01e192d1b0a3f56 Reviewed-by: Jan Arve Sæther <jan-arve.saether@qt.io>
2018-06-28 14:47:11 +00:00
// Need to be installed before QQmlApplicationEngine's automatic translation loading
// (qt_ translations are loaded there)
bin/qml: Fix broken handling of --translation commandline argument The QTranslator was destructed right after it was loaded because it was inside a scope Pick-to: 6.5 Change-Id: I8c9d1604652f18f7d15aa7a0045f580cd8a25063 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2023-02-08 12:19:53 +00:00
QTranslator translator;
Use QTranslator::install(QLocale, ...) everywhere QTranslator::install(QLocale, ...) indirectly uses QLocale::uiLanguages(), which is the correct way to ask the system for ui languages. This was already attempted once in commit 427646b8d7, but reverted later on in commit 05d8ffb4df, because it requires shipping .qm files for the native language. Anyhow, we're shipping empty Qt translations for English since a while, and also have been fixing our examples to do so. [ChangeLog][Important Behavior Changes] The automatic translation loading in qml, qmlscene and QQmlApplicationEngine now tries to load translations for all languages in QLocale::uiLanguages(). This might require shipping an empty translation for the source language. Task-number: QTBUG-7329 Task-number: QTBUG-41977 Task-number: QTBUG-69196 Change-Id: Ifcf45b453ee9d05c018f379cc01e192d1b0a3f56 Reviewed-by: Jan Arve Sæther <jan-arve.saether@qt.io>
2018-06-28 14:47:11 +00:00
if (!translationFile.isEmpty()) {
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
if (translator.load(translationFile)) {
app->installTranslator(&translator);
Add a verbose mode to qml The extra output is primarily useful for debugging, and on windows it will actually make an ugly command prompt window appear. Change-Id: I552e479515a6f5249685844143601cb7449a10b5 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2013-10-23 22:37:16 +00:00
if (verboseMode)
printf("qml: Loaded translation file %s\n", qPrintable(QDir::toNativeSeparators(translationFile)));
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
} else {
if (!quietMode)
Add a verbose mode to qml The extra output is primarily useful for debugging, and on windows it will actually make an ugly command prompt window appear. Change-Id: I552e479515a6f5249685844143601cb7449a10b5 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2013-10-23 22:37:16 +00:00
printf("qml: Could not load the translation file %s\n", qPrintable(QDir::toNativeSeparators(translationFile)));
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
}
}
#else
if (!translationFile.isEmpty() && !quietMode)
Add a verbose mode to qml The extra output is primarily useful for debugging, and on windows it will actually make an ugly command prompt window appear. Change-Id: I552e479515a6f5249685844143601cb7449a10b5 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2013-10-23 22:37:16 +00:00
printf("qml: Translation file specified, but Qt built without translation support.\n");
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
#endif
qml runtime tool: --quiet disables categorized logging too [ChangeLog][QtQml][qml] The QML Runtime tool --quiet option now disables categorized logging in addition to qDebug, qInfo, qWarning and qFatal, except for some early QPA-level categorized logging that occurs during application construction. You can still override specific categories by setting QT_LOGGING_CONF or QT_LOGGING_RULES. Change-Id: Icf986a7fa9980d07beed308df8f69fcc4da9d771 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-23 13:20:15 +00:00
if (quietMode) {
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
qInstallMessageHandler(quietMessageHandler);
qml runtime tool: --quiet disables categorized logging too [ChangeLog][QtQml][qml] The QML Runtime tool --quiet option now disables categorized logging in addition to qDebug, qInfo, qWarning and qFatal, except for some early QPA-level categorized logging that occurs during application construction. You can still override specific categories by setting QT_LOGGING_CONF or QT_LOGGING_RULES. Change-Id: Icf986a7fa9980d07beed308df8f69fcc4da9d771 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-04-23 13:20:15 +00:00
QLoggingCategory::setFilterRules(QStringLiteral("*=false"));
}
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
Port from container::count() and length() to size() This is a semantic patch using ClangTidyTransformator as in qtbase/df9d882d41b741fef7c5beeddb0abe9d904443d8: auto QtContainerClass = anyOf( expr(hasType(cxxRecordDecl(isSameOrDerivedFrom(hasAnyName(classes))))).bind(o), expr(hasType(namedDecl(hasAnyName(<classes>)))).bind(o)); makeRule(cxxMemberCallExpr(on(QtContainerClass), callee(cxxMethodDecl(hasAnyName({"count", "length"), parameterCountIs(0))))), changeTo(cat(access(o, cat("size"), "()"))), cat("use 'size()' instead of 'count()/length()'")) a.k.a qt-port-to-std-compatible-api with config Scope: 'Container', with the extended set of container classes recognized. Change-Id: Idb1f75dfe2323bd1d9e8b4d58d54f1b4b80c7ed7 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-10-05 05:29:16 +00:00
if (files.size() <= 0) {
Fix -no-gui build on macOS Change-Id: Ifc520d58fc7294bad5c90e13ac72bb603f6fd33c Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2019-12-22 13:57:14 +00:00
#if defined(Q_OS_DARWIN) && defined(QT_GUI_LIB)
qml tool on OSX: wait for a timeout before exiting Double-clicking to open a QML file was not working because it would exit if no files are given on the command line. It needs to wait a while for the QFileOpenEvent. Task-number: QTBUG-34926 Change-Id: Icb585a777b0438db85120c62e7717f0f6eafffb1 Reviewed-by: Gabriel de Dietrich <gabriel.dedietrich@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Morten Johan Sørvig <morten.sorvig@digia.com>
2013-11-18 14:57:08 +00:00
if (applicationType == QmlApplicationTypeGui)
qml: Make sure the qml tool deletes its application Otherwise the shutdown mechanism for debug services doesn't work. Fixes: QTBUG-78828 Change-Id: I4ede5861a300d5b5007036d71ed84409ec4d450f Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2019-09-30 08:53:49 +00:00
exitTimerId = static_cast<LoaderApplication *>(app.get())->startTimer(FILE_OPEN_EVENT_WAIT_TIME);
qml tool on OSX: wait for a timeout before exiting Double-clicking to open a QML file was not working because it would exit if no files are given on the command line. It needs to wait a while for the QFileOpenEvent. Task-number: QTBUG-34926 Change-Id: Icb585a777b0438db85120c62e7717f0f6eafffb1 Reviewed-by: Gabriel de Dietrich <gabriel.dedietrich@digia.com> Reviewed-by: Alan Alpert <aalpert@blackberry.com> Reviewed-by: Morten Johan Sørvig <morten.sorvig@digia.com>
2013-11-18 14:57:08 +00:00
else
#endif
noFilesGiven();
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
}
qae = &e;
Add a verbose mode to qml The extra output is primarily useful for debugging, and on windows it will actually make an ugly command prompt window appear. Change-Id: I552e479515a6f5249685844143601cb7449a10b5 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2013-10-23 22:37:16 +00:00
loadConf(confFile, !verboseMode);
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
Clean up LoadWatcher in the Qml Runtime Name the variables in a self-documenting way. While we're at it, do initialization at declaration when possible, reorder the public sections before the private ones, fix comment spacing, and use function-pointer connect syntax where possible. Change-Id: I3fddc8f6d27afa197d425fb7ae3baee02acedceb Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2019-01-14 08:42:29 +00:00
// Load files
Port from container::count() and length() to size() This is a semantic patch using ClangTidyTransformator as in qtbase/df9d882d41b741fef7c5beeddb0abe9d904443d8: auto QtContainerClass = anyOf( expr(hasType(cxxRecordDecl(isSameOrDerivedFrom(hasAnyName(classes))))).bind(o), expr(hasType(namedDecl(hasAnyName(<classes>)))).bind(o)); makeRule(cxxMemberCallExpr(on(QtContainerClass), callee(cxxMethodDecl(hasAnyName({"count", "length"), parameterCountIs(0))))), changeTo(cat(access(o, cat("size"), "()"))), cat("use 'size()' instead of 'count()/length()'")) a.k.a qt-port-to-std-compatible-api with config Scope: 'Container', with the extended set of container classes recognized. Change-Id: Idb1f75dfe2323bd1d9e8b4d58d54f1b4b80c7ed7 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
2022-10-05 05:29:16 +00:00
QScopedPointer<LoadWatcher> lw(new LoadWatcher(&e, files.size()));
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
qml: Deprecate the --dummy-data option [ChangeLog][QtQml][qml] The QML Runtime tool's --dummy-data option is now deprecated, because context properties are deprecated. This option will be removed in a future version of Qt. Task-number: QTBUG-96800 Change-Id: Id6ef8a384f6239ddeebd6c4f84854bbeaf630279 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-22 18:33:51 +00:00
#if QT_DEPRECATED_SINCE(6, 3)
QString dummyDir;
if (parser.isSet(dummyDataOption))
dummyDir = parser.value(dummyDataOption);
Fix crash in qml/qmlscene when using dummy-data with imports When using the tools qml and qmlscene with dummy-data it will crash or behave wrong, due to the dummy-data component will get the state not ready, if the dummy-data qml-files does an import of another folder or a js-file. By changing the way of loading dummy-data, by letting QQmlComponent handle the file opening instead of using the setData() method, qmlscene and qml will be able to handle this type of dummy-data. The tool qml also needed to load the dummy data before loading the regular components, otherwise the dummy-data would not be ready for the other components to use. Task-number: QTBUG-32721 Change-Id: Ia1cc2b2626187e23c7d7313be788202d91b12471 Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2014-03-01 06:28:29 +00:00
// Load dummy data before loading QML-files
qml: Deprecate the --dummy-data option [ChangeLog][QtQml][qml] The QML Runtime tool's --dummy-data option is now deprecated, because context properties are deprecated. This option will be removed in a future version of Qt. Task-number: QTBUG-96800 Change-Id: Id6ef8a384f6239ddeebd6c4f84854bbeaf630279 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-22 18:33:51 +00:00
if (!dummyDir.isEmpty() && QFileInfo (dummyDir).isDir()) {
qCWarning(lcDeprecated()) << "Warning: the qml --dummy-data option is deprecated and will be removed in a future version of Qt.";
Fix crash in qml/qmlscene when using dummy-data with imports When using the tools qml and qmlscene with dummy-data it will crash or behave wrong, due to the dummy-data component will get the state not ready, if the dummy-data qml-files does an import of another folder or a js-file. By changing the way of loading dummy-data, by letting QQmlComponent handle the file opening instead of using the setData() method, qmlscene and qml will be able to handle this type of dummy-data. The tool qml also needed to load the dummy data before loading the regular components, otherwise the dummy-data would not be ready for the other components to use. Task-number: QTBUG-32721 Change-Id: Ia1cc2b2626187e23c7d7313be788202d91b12471 Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2014-03-01 06:28:29 +00:00
loadDummyDataFiles(e, dummyDir);
qml: Deprecate the --dummy-data option [ChangeLog][QtQml][qml] The QML Runtime tool's --dummy-data option is now deprecated, because context properties are deprecated. This option will be removed in a future version of Qt. Task-number: QTBUG-96800 Change-Id: Id6ef8a384f6239ddeebd6c4f84854bbeaf630279 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2021-09-22 18:33:51 +00:00
}
#endif
Fix crash in qml/qmlscene when using dummy-data with imports When using the tools qml and qmlscene with dummy-data it will crash or behave wrong, due to the dummy-data component will get the state not ready, if the dummy-data qml-files does an import of another folder or a js-file. By changing the way of loading dummy-data, by letting QQmlComponent handle the file opening instead of using the setData() method, qmlscene and qml will be able to handle this type of dummy-data. The tool qml also needed to load the dummy data before loading the regular components, otherwise the dummy-data would not be ready for the other components to use. Task-number: QTBUG-32721 Change-Id: Ia1cc2b2626187e23c7d7313be788202d91b12471 Reviewed-by: Alan Alpert <aalpert@blackberry.com>
2014-03-01 06:28:29 +00:00
Port from qAsConst() to std::as_const() We've been requiring C++17 since Qt 6.0, and our qAsConst use finally starts to bother us (QTBUG-99313), so time to port away from it now. Since qAsConst has exactly the same semantics as std::as_const (down to rvalue treatment, constexpr'ness and noexcept'ness), there's really nothing more to it than a global search-and-replace. Task-number: QTBUG-99313 Change-Id: I601bf70f020f511019ed28731ba53b14b765dbf0 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2022-10-06 09:30:50 +00:00
for (const QString &path : std::as_const(files)) {
qml runtime: don't assume http by default Avoid doing network operations unless a network-specific scheme is given. Task-number: QTBUG-57870 Change-Id: I1387603da5b8325232bef27b0ed45483a0ae30a4 Reviewed-by: David Faure <david.faure@kdab.com>
2017-03-15 10:16:20 +00:00
QUrl url = QUrl::fromUserInput(path, QDir::currentPath(), QUrl::AssumeLocalFile);
qml: use QUrl::fromUserInput("file.qml", QDir::currentPath()) After change dc6b73390b262b9554599cbf40539763b1280261 in qtbase, the qml runtime was failing at an assertion in QQmlTypeLoader::getType() which tries to avoid relative URLs and relative directory paths. It's important to convert relative paths to fully-qualified paths when converting to an URL, because QQmlTypeLoader uses it as a cache key, and we want to avoid ambiguity about which file is being cached. Task-number: QTBUG-57870 Change-Id: Ib984cf722009f5f04cb67fffbc52d12bcc98df89 Reviewed-by: David Faure <david.faure@kdab.com> Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2017-01-02 13:04:48 +00:00
if (verboseMode)
printf("qml: loading %s\n", qPrintable(url.toString()));
Uniformly support shebang The "qml" tool was the only way of loading QML files that would respect a shebang line. This is problematic as this way you cannot load such files programatically using QQmlComponent, limiting their re-use. Common tools like Qt Creator, but also qmllint, qmlformat, qmlcachegen, etc would not recognize files with shebangs. By moving she-bang support directly in the lexer all tools implicitly support it. Note that we could just as easily support '#' as extra comment character along with //, but here we narrowly add support for in the first line only, as node does (this means that javascript files using she-bang accepted by node, are now accepted also by qml). The only tool needing some adjustments is qmlformat, that has to emit the she-bang again as she-bang and as first line. Add tests for qmlformat, and sprinkle some she-bangs in the other tests just to be sure it doesn't affect anything. Change-Id: I1f6d881c7438bdb23163b5dbe829d59a35d11132 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io> Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2021-02-03 08:06:09 +00:00
e.load(url);
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
}
qml tool should exit on Qt.quit() In a QML/C++ application there may be additional code after app.exec(). In a pure QML application this is not the case, and you may wish to call Qt.quit() during scene creation (before app.exec()). [ChangeLog][QtQml][qml] qml tool now quits immediately if Qt.quit() is called before all scenes complete creation. Change-Id: I5c6fb64769724350ef3d74c34e2ede2d06562e4b Reviewed-by: Kevin Krammer <kevin.krammer@kdab.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2015-03-11 05:25:14 +00:00
if (lw->earlyExit)
Qt object: Add exit(int) This is similar to the Qt.quit() function but also specifies the return code that the event loop will return. [ChangeLog][QtQml] Added exit(int retCode) method to the Qt global object. An application can call Qt.exit to specify a return code of the engine. Task-number: QTBUG-54360 Change-Id: Iaa319e6dc4d6b99dc3a5c01845e87b936fd2cab0 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2016-08-03 14:54:26 +00:00
return lw->returnCode;
qml tool should exit on Qt.quit() In a QML/C++ application there may be additional code after app.exec(). In a pure QML application this is not the case, and you may wish to call Qt.quit() during scene creation (before app.exec()). [ChangeLog][QtQml][qml] qml tool now quits immediately if Qt.quit() is called before all scenes complete creation. Change-Id: I5c6fb64769724350ef3d74c34e2ede2d06562e4b Reviewed-by: Kevin Krammer <kevin.krammer@kdab.com> Reviewed-by: Shawn Rutledge <shawn.rutledge@digia.com>
2015-03-11 05:25:14 +00:00
Add qml tool This tool simply runs QML files using a QQmlApplicationEngine. It is configurable so as to behave, by default, like qmlscene in that it will automatically place non-Window QtQuick 2 Items inside a QQuickWindow with the size of the root item. The configuration is extensible so that other GUI scenes can also use it by altering the configuration files in their installation. On OS X, it is an app bundle, and handles the QFileOpenEvent so that it can be the tool with which qml files are usually launched by double-clicking. (This does not break the ability to use it on the command line too: the options still work, you just have to give the path to the executable inside the bundle.) Change-Id: I6bac813ce188be54842a78d7b532fcf2d54dc443 Reviewed-by: Alan Alpert (Personal) <416365416c@gmail.com>
2012-12-21 23:42:47 +00:00
return app->exec();
}
#include "main.moc"