");
} else {
// Deduce a description from '/foo/qt-folder/[qtbase]/bin/qmake' -> '/foo/qt-folder'.
// '/usr' indicates System Qt 4.X on Linux.
- for (FilePath dir = qmakeFilePath().parentDir(); !dir.isEmpty(); dir = dir.parentDir()) {
+ for (FilePath dir = queryToolFilePath().parentDir(); !dir.isEmpty(); dir = dir.parentDir()) {
const QString dirName = dir.fileName();
if (dirName == "usr") { // System-installed Qt.
location = QCoreApplication::translate("QtVersion", "System");
@@ -725,20 +727,23 @@ void QtVersion::fromMap(const QVariantMap &map)
d->m_isAutodetected = map.value(QTVERSIONAUTODETECTED).toBool();
d->m_detectionSource = map.value(QTVERSIONDETECTIONSOURCE).toString();
d->m_overrideFeatures = Utils::Id::fromStringList(map.value(QTVERSION_OVERRIDE_FEATURES).toStringList());
- d->m_qmakeCommand = FilePath::fromVariant(map.value(QTVERSIONQMAKEPATH));
+ d->m_queryTool = FilePath::fromVariant(map.value(QTVERSIONQUERYTOOLPATH,
+ map.value(QTVERSIONQMAKEPATH)));
+ if (!d->m_queryTool.baseName().contains("qtpaths"))
+ d->m_qmakeCommand = d->m_queryTool;
- FilePath qmake = d->m_qmakeCommand;
+ FilePath queryTool = d->m_queryTool;
// FIXME: Check this is still needed or whether ProcessArgs::splitArg handles it.
- QString string = d->m_qmakeCommand.path();
+ QString string = d->m_queryTool.path();
if (string.startsWith('~'))
string.remove(0, 1).prepend(QDir::homePath());
- qmake.setPath(string);
- if (!d->m_qmakeCommand.needsDevice()) {
- if (BuildableHelperLibrary::isQtChooser(qmake)) {
+ queryTool.setPath(string);
+ if (!d->m_queryTool.needsDevice()) {
+ if (BuildableHelperLibrary::isQtChooser(queryTool)) {
// we don't want to treat qtchooser as a normal qmake
// see e.g. QTCREATORBUG-9841, also this lead to users changing what
// qtchooser forwards too behind our backs, which will inadvertly lead to bugs
- d->m_qmakeCommand = BuildableHelperLibrary::qtChooserToQmakePath(qmake);
+ d->m_queryTool = BuildableHelperLibrary::qtChooserToQueryToolPath(queryTool);
}
}
@@ -769,6 +774,7 @@ QVariantMap QtVersion::toMap() const
result.insert(QTVERSION_OVERRIDE_FEATURES, Utils::Id::toStringList(d->m_overrideFeatures));
result.insert(QTVERSIONQMAKEPATH, qmakeFilePath().toVariant());
+ result.insert(QTVERSIONQUERYTOOLPATH, queryToolFilePath().toVariant());
return result;
}
@@ -779,8 +785,8 @@ bool QtVersion::isValid() const
d->updateVersionInfo();
d->updateMkspec();
- return !qmakeFilePath().isEmpty() && d->m_data.installed && !binPath().isEmpty()
- && !d->m_mkspecFullPath.isEmpty() && d->m_qmakeIsExecutable;
+ return !queryToolFilePath().isEmpty() && d->m_data.installed && !binPath().isEmpty()
+ && !d->m_mkspecFullPath.isEmpty() && d->m_queryToolIsExecutable;
}
QtVersion::Predicate QtVersion::isValidPredicate(const QtVersion::Predicate &predicate)
@@ -794,15 +800,18 @@ QString QtVersion::invalidReason() const
{
if (displayName().isEmpty())
return QCoreApplication::translate("QtVersion", "Qt version has no name");
- if (qmakeFilePath().isEmpty())
- return QCoreApplication::translate("QtVersion", "No qmake path set");
- if (!d->m_qmakeIsExecutable)
- return QCoreApplication::translate("QtVersion", "qmake does not exist or is not executable");
+ if (queryToolFilePath().isEmpty())
+ return QCoreApplication::translate("QtVersion", "No Qt query tool path set");
+ if (!d->m_queryToolIsExecutable)
+ return QCoreApplication::translate("QtVersion", "%1 does not exist or is not executable")
+ .arg(queryToolFilePath().baseName());
if (!d->m_data.installed)
return QCoreApplication::translate("QtVersion", "Qt version is not properly installed, please run make install");
if (binPath().isEmpty())
return QCoreApplication::translate("QtVersion",
- "Could not determine the path to the binaries of the Qt installation, maybe the qmake path is wrong?");
+ "Could not determine the path to the binaries of the "
+ "Qt installation, maybe the %1 path is wrong?")
+ .arg(queryToolFilePath().baseName());
if (d->m_mkspecUpToDate && d->m_mkspecFullPath.isEmpty())
return QCoreApplication::translate("QtVersion", "The default mkspec symlink is broken.");
return QString();
@@ -820,8 +829,20 @@ QStringList QtVersion::warningReason() const
return ret;
}
+FilePath QtVersion::queryToolFilePath() const
+{
+ return d->m_queryTool;
+}
+
FilePath QtVersion::qmakeFilePath() const
{
+ if (d->m_qmakeCommand.isEmpty() && d->m_queryTool.baseName().contains("qtpaths")) {
+ // TODO: might need a less lazy implementation
+ const FilePath qmake =
+ FilePath::fromString(d->m_queryTool.toString().replace("qtpaths", "qmake"));
+ if (qmake.exists())
+ d->m_qmakeCommand = qmake;
+ }
return d->m_qmakeCommand;
}
@@ -855,7 +876,7 @@ bool QtVersion::hasAbi(ProjectExplorer::Abi::OS os, ProjectExplorer::Abi::OSFlav
bool QtVersion::equals(QtVersion *other)
{
- if (d->m_qmakeCommand != other->d->m_qmakeCommand)
+ if (d->m_queryTool != other->d->m_queryTool)
return false;
if (type() != other->type())
return false;
@@ -933,13 +954,15 @@ QString QtVersion::toHtml(bool verbose) const
str << "| " << abis.at(i).toString() << " | ";
}
}
- const OsType osType = d->m_qmakeCommand.osType();
+ const OsType osType = d->m_queryTool.osType();
str << "| " << QCoreApplication::translate("QtVersion", "Source:")
<< " | " << sourcePath().toUserOutput() << " |
";
str << "| " << QCoreApplication::translate("QtVersion", "mkspec:")
<< " | " << QDir::toNativeSeparators(mkspec()) << " |
";
str << "| " << QCoreApplication::translate("QtVersion", "qmake:")
- << " | " << d->m_qmakeCommand.toUserOutput() << " |
";
+ << "" << qmakeFilePath().toUserOutput() << " | ";
+ str << "| " << QCoreApplication::translate("QtVersion", "Query tool:")
+ << " | " << d->m_queryTool.toUserOutput() << " |
";
ensureMkSpecParsed();
if (!mkspecPath().isEmpty()) {
if (d->m_defaultConfigIsDebug || d->m_defaultConfigIsDebugAndRelease) {
@@ -1164,13 +1187,13 @@ void QtVersionPrivate::updateMkspec()
return;
m_mkspecUpToDate = true;
- m_mkspecFullPath = mkspecFromVersionInfo(versionInfo(), m_qmakeCommand);
+ m_mkspecFullPath = mkspecFromVersionInfo(versionInfo(), m_queryTool);
m_mkspec = m_mkspecFullPath;
if (m_mkspecFullPath.isEmpty())
return;
- FilePath baseMkspecDir = mkspecDirectoryFromVersionInfo(versionInfo(), m_qmakeCommand);
+ FilePath baseMkspecDir = mkspecDirectoryFromVersionInfo(versionInfo(), m_queryTool);
if (m_mkspec.isChildOf(baseMkspecDir)) {
m_mkspec = m_mkspec.relativeChildPath(baseMkspecDir);
@@ -1197,7 +1220,7 @@ void QtVersion::ensureMkSpecParsed() const
QMakeVfs vfs;
QMakeGlobals option;
applyProperties(&option);
- Environment env = d->m_qmakeCommand.deviceEnvironment();
+ Environment env = d->m_queryTool.deviceEnvironment();
setupQmakeRunEnvironment(env);
option.environment = env.toProcessEnvironment();
ProMessageHandler msgHandler(true);
@@ -1310,7 +1333,7 @@ QtVersionNumber QtVersion::qtVersion() const
void QtVersionPrivate::updateVersionInfo()
{
- if (m_versionInfoUpToDate || !m_qmakeIsExecutable || m_isUpdating)
+ if (m_versionInfoUpToDate || !m_queryToolIsExecutable || m_isUpdating)
return;
m_isUpdating = true;
@@ -1321,16 +1344,16 @@ void QtVersionPrivate::updateVersionInfo()
m_data.hasExamples = false;
m_data.hasDocumentation = false;
- if (!queryQMakeVariables(m_qmakeCommand, q->qmakeRunEnvironment(), &m_versionInfo)) {
- m_qmakeIsExecutable = false;
+ if (!queryQtPaths(m_queryTool, q->qmakeRunEnvironment(), &m_versionInfo)) {
+ m_queryToolIsExecutable = false;
qWarning("Cannot update Qt version information: %s cannot be run.",
- qPrintable(m_qmakeCommand.toString()));
+ qPrintable(m_queryTool.toString()));
return;
}
- m_qmakeIsExecutable = true;
+ m_queryToolIsExecutable = true;
auto fileProperty = [this](const QByteArray &name) {
- return FilePath::fromUserInput(qmakeProperty(name)).onDevice(m_qmakeCommand);
+ return FilePath::fromUserInput(qmakeProperty(name)).onDevice(m_queryTool);
};
m_data.prefix = fileProperty("QT_INSTALL_PREFIX");
@@ -1385,8 +1408,8 @@ QHash QtVersionPrivate::versionInfo()
}
QString QtVersionPrivate::qmakeProperty(const QHash &versionInfo,
- const QByteArray &name,
- PropertyVariant variant)
+ const QByteArray &name,
+ PropertyVariant variant)
{
QString val = versionInfo
.value(ProKey(QString::fromLatin1(
@@ -1728,7 +1751,7 @@ void QtVersion::addToEnvironment(const Kit *k, Environment &env) const
Environment QtVersion::qmakeRunEnvironment() const
{
- Environment env = d->m_qmakeCommand.deviceEnvironment();
+ Environment env = d->m_queryTool.deviceEnvironment();
setupQmakeRunEnvironment(env);
return env;
}
@@ -1756,7 +1779,7 @@ Tasks QtVersion::reportIssuesImpl(const QString &proFile, const QString &buildDi
results.append(BuildSystemTask(Task::Error, msg));
}
- FilePath qmake = qmakeFilePath();
+ FilePath qmake = queryToolFilePath();
if (!qmake.isExecutableFile()) {
//: %1: Path to qmake executable
const QString msg = QCoreApplication::translate("QmakeProjectManager::QtVersion",
@@ -1816,20 +1839,21 @@ static QByteArray runQmakeQuery(const FilePath &binary, const Environment &env,
return process.readAllStandardOutput();
}
-bool QtVersionPrivate::queryQMakeVariables(const FilePath &binary, const Environment &env,
- QHash *versionInfo, QString *error)
+bool QtVersionPrivate::queryQtPaths(const FilePath &queryTool, const Environment &env,
+ QHash *versionInfo, QString *error)
{
QString tmp;
if (!error)
error = &tmp;
- if (!binary.isExecutableFile()) {
- *error = QCoreApplication::translate("QtVersion", "qmake \"%1\" is not an executable.").arg(binary.toUserOutput());
+ if (!queryTool.isExecutableFile()) {
+ *error = QCoreApplication::translate("QtVersion", "\"%1\" is not an executable.")
+ .arg(queryTool.toUserOutput());
return false;
}
QByteArray output;
- output = runQmakeQuery(binary, env, error);
+ output = runQmakeQuery(queryTool, env, error);
if (!output.contains("QMAKE_VERSION:")) {
// Some setups pass error messages via stdout, fooling the logic below.
@@ -1847,14 +1871,14 @@ bool QtVersionPrivate::queryQMakeVariables(const FilePath &binary, const Environ
// Try running qmake with all kinds of tool chains set up in the environment.
// This is required to make non-static qmakes work on windows where every tool chain
// tries to be incompatible with any other.
- const Abis abiList = Abi::abisOfBinary(binary);
+ const Abis abiList = Abi::abisOfBinary(queryTool);
const Toolchains tcList = ToolChainManager::toolchains([&abiList](const ToolChain *t) {
return abiList.contains(t->targetAbi());
});
for (ToolChain *tc : tcList) {
Environment realEnv = env;
tc->addToEnvironment(realEnv);
- output = runQmakeQuery(binary, realEnv, error);
+ output = runQmakeQuery(queryTool, realEnv, error);
if (error->isEmpty())
break;
}
@@ -1876,18 +1900,18 @@ QString QtVersionPrivate::qmakeProperty(const QByteArray &name,
}
FilePath QtVersionPrivate::mkspecDirectoryFromVersionInfo(const QHash &versionInfo,
- const FilePath &qmakeCommand)
+ const FilePath &queryTool)
{
QString dataDir = qmakeProperty(versionInfo, "QT_HOST_DATA", PropertyVariantSrc);
if (dataDir.isEmpty())
return FilePath();
- return FilePath::fromUserInput(dataDir + "/mkspecs").onDevice(qmakeCommand);
+ return FilePath::fromUserInput(dataDir + "/mkspecs").onDevice(queryTool);
}
FilePath QtVersionPrivate::mkspecFromVersionInfo(const QHash &versionInfo,
- const FilePath &qmakeCommand)
+ const FilePath &queryTool)
{
- FilePath baseMkspecDir = mkspecDirectoryFromVersionInfo(versionInfo, qmakeCommand);
+ FilePath baseMkspecDir = mkspecDirectoryFromVersionInfo(versionInfo, queryTool);
if (baseMkspecDir.isEmpty())
return FilePath();
@@ -2319,14 +2343,16 @@ void QtVersion::resetCache() const
static QList g_qtVersionFactories;
-QtVersion *QtVersionFactory::createQtVersionFromQMakePath
- (const FilePath &qmakePath, bool isAutoDetected, const QString &detectionSource, QString *error)
+QtVersion *QtVersionFactory::createQtVersionFromQueryToolPath(const FilePath &queryTool,
+ bool isAutoDetected,
+ const QString &detectionSource,
+ QString *error)
{
QHash versionInfo;
- const Environment env = qmakePath.deviceEnvironment();
- if (!QtVersionPrivate::queryQMakeVariables(qmakePath, env, &versionInfo, error))
+ const Environment env = queryTool.deviceEnvironment();
+ if (!QtVersionPrivate::queryQtPaths(queryTool, env, &versionInfo, error))
return nullptr;
- FilePath mkspec = QtVersionPrivate::mkspecFromVersionInfo(versionInfo, qmakePath);
+ FilePath mkspec = QtVersionPrivate::mkspecFromVersionInfo(versionInfo, queryTool);
QMakeVfs vfs;
QMakeGlobals globals;
@@ -2342,7 +2368,7 @@ QtVersion *QtVersionFactory::createQtVersionFromQMakePath
return l->m_priority > r->m_priority;
});
- if (!qmakePath.isExecutableFile())
+ if (!queryTool.isExecutableFile())
return nullptr;
QtVersionFactory::SetupData setup;
@@ -2355,8 +2381,8 @@ QtVersion *QtVersionFactory::createQtVersionFromQMakePath
QtVersion *ver = factory->create();
QTC_ASSERT(ver, continue);
ver->d->m_id = QtVersionManager::getUniqueId();
- QTC_CHECK(ver->d->m_qmakeCommand.isEmpty()); // Should only be used once.
- ver->d->m_qmakeCommand = qmakePath;
+ QTC_CHECK(ver->d->m_queryTool.isEmpty()); // Should only be used once.
+ ver->d->m_queryTool = queryTool;
ver->d->m_detectionSource = detectionSource;
ver->d->m_isAutodetected = isAutoDetected;
ver->updateDefaultDisplayName();
@@ -2367,7 +2393,7 @@ QtVersion *QtVersionFactory::createQtVersionFromQMakePath
ProFileCacheManager::instance()->decRefCount();
if (error) {
*error = QCoreApplication::translate("QtSupport::QtVersionFactory",
- "No factory found for qmake: \"%1\"").arg(qmakePath.toUserOutput());
+ "No factory found for query tool \"%1\"").arg(queryTool.toUserOutput());
}
return nullptr;
}
diff --git a/src/plugins/qtsupport/baseqtversion.h b/src/plugins/qtsupport/baseqtversion.h
index 269a6507168..f0400bc99b5 100644
--- a/src/plugins/qtsupport/baseqtversion.h
+++ b/src/plugins/qtsupport/baseqtversion.h
@@ -150,6 +150,8 @@ public:
bool hasDocs() const;
bool hasDemos() const;
+ Utils::FilePath queryToolFilePath() const;
+
// former local functions
Utils::FilePath qmakeFilePath() const;
diff --git a/src/plugins/qtsupport/qtkitinformation.cpp b/src/plugins/qtsupport/qtkitinformation.cpp
index 43bbc07c1c3..672ad493df4 100644
--- a/src/plugins/qtsupport/qtkitinformation.cpp
+++ b/src/plugins/qtsupport/qtkitinformation.cpp
@@ -324,6 +324,11 @@ void QtKitAspect::addToMacroExpander(Kit *kit, MacroExpander *expander) const
QtVersion *version = qtVersion(kit);
return version ? version->qmakeFilePath().path() : QString();
});
+ expander->registerVariable("Qt:queryToolExecutable", tr("Path to the query tool executable"),
+ [kit]() -> QString {
+ QtVersion *version = qtVersion(kit);
+ return version ? version->queryToolFilePath().path() : QString();
+ });
}
Id QtKitAspect::id()
diff --git a/src/plugins/qtsupport/qtoptionspage.cpp b/src/plugins/qtsupport/qtoptionspage.cpp
index c0049058abd..06a8a6bbd52 100644
--- a/src/plugins/qtsupport/qtoptionspage.cpp
+++ b/src/plugins/qtsupport/qtoptionspage.cpp
@@ -51,6 +51,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -111,7 +112,7 @@ public:
if (column == 0)
return m_version->displayName();
if (column == 1)
- return m_version->qmakeFilePath().toUserOutput();
+ return m_version->queryToolFilePath().toUserOutput();
}
if (role == Qt::FontRole && m_changed) {
@@ -128,7 +129,8 @@ public:
"%2";
return QString(""
+ row.arg(tr("Qt Version"), m_version->qtVersionString())
- + row.arg(tr("Location of qmake"), m_version->qmakeFilePath().toUserOutput())
+ + row.arg(tr("Location of the query tool"),
+ m_version->queryToolFilePath().toUserOutput())
+ "
");
}
@@ -600,27 +602,42 @@ QtOptionsPageWidget::~QtOptionsPageWidget()
delete m_configurationWidget;
}
+static bool isIncompatibleQtPathsTool(const FilePath &tool)
+{
+ if (!tool.baseName().startsWith("qtpaths"))
+ return false;
+ QtcProcess process;
+ process.setTimeoutS(1);
+ process.setCommand({tool, {"-query"}});
+ process.runBlocking();
+ return process.result() != ProcessResult::FinishedWithSuccess;
+}
+
void QtOptionsPageWidget::addQtDir()
{
- FilePath qtVersion = FileUtils::getOpenFilePath(this,
- tr("Select a qmake Executable"),
- {},
- BuildableHelperLibrary::filterForQmakeFileDialog(),
- 0,
- QFileDialog::DontResolveSymlinks);
- if (qtVersion.isEmpty())
+ FilePath qtQueryTool =
+ FileUtils::getOpenFilePath(this,
+ tr("Select a qmake or qtpaths Executable"),
+ {},
+ BuildableHelperLibrary::filterForQtQueryToolsFileDialog(),
+ 0,
+ QFileDialog::DontResolveSymlinks);
+ if (qtQueryTool.isEmpty())
return;
- // should add all qt versions here ?
- if (BuildableHelperLibrary::isQtChooser(qtVersion))
- qtVersion = BuildableHelperLibrary::qtChooserToQmakePath(qtVersion.symLinkTarget());
+ if (isIncompatibleQtPathsTool(qtQueryTool))
+ qtQueryTool = qtQueryTool.parentDir() / HostOsInfo::withExecutableSuffix("qmake");
- auto checkAlreadyExists = [qtVersion](TreeItem *parent) {
+ // should add all qt versions here ?
+ if (BuildableHelperLibrary::isQtChooser(qtQueryTool))
+ qtQueryTool = BuildableHelperLibrary::qtChooserToQueryToolPath(qtQueryTool.symLinkTarget());
+
+ auto checkAlreadyExists = [qtQueryTool](TreeItem *parent) {
for (int i = 0; i < parent->childCount(); ++i) {
auto item = static_cast(parent->childAt(i));
- if (item->version()->qmakeFilePath() == qtVersion) {
+ // Compare parent dirs, since it could be either qmake or qtpaths
+ if (item->version()->queryToolFilePath().parentDir() == qtQueryTool.parentDir())
return std::make_pair(true, item->version()->displayName());
- }
}
return std::make_pair(false, QString());
};
@@ -640,7 +657,8 @@ void QtOptionsPageWidget::addQtDir()
}
QString error;
- QtVersion *version = QtVersionFactory::createQtVersionFromQMakePath(qtVersion, false, QString(), &error);
+ QtVersion *version = QtVersionFactory::createQtVersionFromQueryToolPath(qtQueryTool, false,
+ QString(), &error);
if (version) {
auto item = new QtVersionItem(version);
item->setIcon(version->isValid()? m_validVersionIcon : m_invalidVersionIcon);
@@ -650,8 +668,9 @@ void QtOptionsPageWidget::addQtDir()
m_versionUi.nameEdit->setFocus();
m_versionUi.nameEdit->selectAll();
} else {
- QMessageBox::warning(this, tr("Qmake Not Executable"),
- tr("The qmake executable %1 could not be added: %2").arg(qtVersion.toUserOutput()).arg(error));
+ QMessageBox::warning(this, tr("Not Executable"),
+ tr("The executable %1 could not be added: %2").arg(
+ qtQueryTool.toUserOutput()).arg(error));
return;
}
updateCleanUpButton();
@@ -671,16 +690,16 @@ void QtOptionsPageWidget::removeQtDir()
void QtOptionsPageWidget::editPath()
{
QtVersion *current = currentVersion();
- FilePath qtVersion =
+ const FilePath queryTool =
FileUtils::getOpenFilePath(this,
- tr("Select a qmake Executable"),
- current->qmakeFilePath().absolutePath(),
- BuildableHelperLibrary::filterForQmakeFileDialog(),
+ tr("Select a qmake or qtpaths Executable"),
+ current->queryToolFilePath().absolutePath(),
+ BuildableHelperLibrary::filterForQtQueryToolsFileDialog(),
nullptr,
QFileDialog::DontResolveSymlinks);
- if (qtVersion.isEmpty())
+ if (queryTool.isEmpty())
return;
- QtVersion *version = QtVersionFactory::createQtVersionFromQMakePath(qtVersion);
+ QtVersion *version = QtVersionFactory::createQtVersionFromQueryToolPath(queryTool);
if (!version)
return;
// Same type? then replace!
@@ -768,7 +787,7 @@ void QtOptionsPageWidget::updateWidgets()
QtVersion *version = currentVersion();
if (version) {
m_versionUi.nameEdit->setText(version->unexpandedDisplayName());
- m_versionUi.qmakePath->setText(version->qmakeFilePath().toUserOutput());
+ m_versionUi.queryToolPath->setText(version->queryToolFilePath().toUserOutput());
m_configurationWidget = version->createConfigurationWidget();
if (m_configurationWidget) {
m_versionUi.formLayout->addRow(m_configurationWidget);
@@ -778,7 +797,7 @@ void QtOptionsPageWidget::updateWidgets()
}
} else {
m_versionUi.nameEdit->clear();
- m_versionUi.qmakePath->clear();
+ m_versionUi.queryToolPath->clear();
}
const bool enabled = version != nullptr;
diff --git a/src/plugins/qtsupport/qtprojectimporter.cpp b/src/plugins/qtsupport/qtprojectimporter.cpp
index 9014aa71f08..fc44f3b7d37 100644
--- a/src/plugins/qtsupport/qtprojectimporter.cpp
+++ b/src/plugins/qtsupport/qtprojectimporter.cpp
@@ -57,7 +57,7 @@ QtProjectImporter::QtVersionData
QtProjectImporter::findOrCreateQtVersion(const Utils::FilePath &qmakePath) const
{
QtVersionData result;
- result.qt = QtVersionManager::version(Utils::equal(&QtVersion::qmakeFilePath, qmakePath));
+ result.qt = QtVersionManager::version(Utils::equal(&QtVersion::queryToolFilePath, qmakePath));
if (result.qt) {
// Check if version is a temporary qt
const int qtId = result.qt->uniqueId();
@@ -67,7 +67,7 @@ QtProjectImporter::findOrCreateQtVersion(const Utils::FilePath &qmakePath) const
// Create a new version if not found:
// Do not use the canonical path here...
- result.qt = QtVersionFactory::createQtVersionFromQMakePath(qmakePath);
+ result.qt = QtVersionFactory::createQtVersionFromQueryToolPath(qmakePath);
result.isTemporary = true;
if (result.qt) {
UpdateGuard guard(*this);
@@ -281,7 +281,7 @@ static QStringList additionalFilesToCopy(const QtVersion *qt)
} else if (HostOsInfo::isWindowsHost()) {
const QString release = QString("bin/Qt%1Core.dll").arg(major);
const QString debug = QString("bin/Qt%1Cored.dll").arg(major);
- const FilePath base = qt->qmakeFilePath().parentDir().parentDir();
+ const FilePath base = qt->queryToolFilePath().parentDir().parentDir();
if (base.pathAppended(release).exists())
return {release};
if (base.pathAppended(debug).exists())
@@ -289,7 +289,7 @@ static QStringList additionalFilesToCopy(const QtVersion *qt)
return {release};
} else if (HostOsInfo::isLinuxHost()) {
const QString core = QString("lib/libQt%1Core.so.%1").arg(major);
- const QDir base(qt->qmakeFilePath().parentDir().parentDir().pathAppended("lib").toString());
+ const QDir base(qt->queryToolFilePath().parentDir().parentDir().pathAppended("lib").toString());
const QStringList icuLibs = Utils::transform(base.entryList({"libicu*.so.*"}), [](const QString &lib) { return QString("lib/" + lib); });
return QStringList(core) + icuLibs;
}
@@ -300,7 +300,7 @@ static QStringList additionalFilesToCopy(const QtVersion *qt)
static Utils::FilePath setupQmake(const QtVersion *qt, const QString &path)
{
// This is a hack and only works with local, "standard" installations of Qt
- const FilePath qmake = qt->qmakeFilePath().canonicalPath();
+ const FilePath qmake = qt->queryToolFilePath().canonicalPath();
const QString qmakeFile = "bin/" + qmake.fileName();
const FilePath source = qmake.parentDir().parentDir();
const FilePath target = FilePath::fromString(path);
diff --git a/src/plugins/qtsupport/qtversionfactory.h b/src/plugins/qtsupport/qtversionfactory.h
index bc01ad7601a..96bf8e2088a 100644
--- a/src/plugins/qtsupport/qtversionfactory.h
+++ b/src/plugins/qtsupport/qtversionfactory.h
@@ -51,7 +51,7 @@ public:
/// the desktop factory claims to handle all paths
int priority() const { return m_priority; }
- static QtVersion *createQtVersionFromQMakePath(const Utils::FilePath &qmakePath,
+ static QtVersion *createQtVersionFromQueryToolPath(const Utils::FilePath &qmakePath,
bool isAutoDetected = false,
const QString &detectionSource = {},
QString *error = nullptr);
diff --git a/src/plugins/qtsupport/qtversioninfo.ui b/src/plugins/qtsupport/qtversioninfo.ui
index 467e898a20e..815be818177 100644
--- a/src/plugins/qtsupport/qtversioninfo.ui
+++ b/src/plugins/qtsupport/qtversioninfo.ui
@@ -39,14 +39,14 @@
-
- qmake path:
+ Query tool path:
-
-
-
+
0
diff --git a/src/plugins/qtsupport/qtversionmanager.cpp b/src/plugins/qtsupport/qtversionmanager.cpp
index 2ca6c3a1237..c5f00e96189 100644
--- a/src/plugins/qtsupport/qtversionmanager.cpp
+++ b/src/plugins/qtsupport/qtversionmanager.cpp
@@ -265,7 +265,8 @@ void QtVersionManager::updateFromInstaller(bool emitSignal)
if (log().isDebugEnabled()) {
qCDebug(log) << "======= Existing Qt versions =======";
for (QtVersion *version : qAsConst(m_versions)) {
- qCDebug(log) << version->qmakeFilePath().toUserOutput() << "id:"<uniqueId();
+ qCDebug(log) << version->queryToolFilePath().toUserOutput()
+ << "id:" <uniqueId();
qCDebug(log) << " autodetection source:" << version->detectionSource();
qCDebug(log) << "";
}
@@ -341,7 +342,8 @@ void QtVersionManager::updateFromInstaller(bool emitSignal)
if (log().isDebugEnabled()) {
qCDebug(log) << "======= Before removing outdated sdk versions =======";
for (QtVersion *version : qAsConst(m_versions)) {
- qCDebug(log) << version->qmakeFilePath().toUserOutput() << "id:" << version->uniqueId();
+ qCDebug(log) << version->queryToolFilePath().toUserOutput()
+ << "id:" << version->uniqueId();
qCDebug(log) << " autodetection source:" << version->detectionSource();
qCDebug(log) << "";
}
@@ -360,7 +362,8 @@ void QtVersionManager::updateFromInstaller(bool emitSignal)
if (log().isDebugEnabled()) {
qCDebug(log)<< "======= End result =======";
for (QtVersion *version : qAsConst(m_versions)) {
- qCDebug(log) << version->qmakeFilePath().toUserOutput() << "id:" << version->uniqueId();
+ qCDebug(log) << version->queryToolFilePath().toUserOutput()
+ << "id:" << version->uniqueId();
qCDebug(log) << " autodetection source:" << version->detectionSource();
qCDebug(log) << "";
}
@@ -401,14 +404,20 @@ static QList runQtChooser(const QString &qtchooser, const QStringLis
}
// Asks qtchooser for the qmake path of a given version
+// TODO: Extend to qtpaths if qtchooser is also used for Qt 6
static QString qmakePath(const QString &qtchooser, const QString &version)
{
const QList outputs = runQtChooser(qtchooser,
{QStringLiteral("-qt=%1").arg(version),
QStringLiteral("-print-env")});
+ // Exemplary output of "qtchooser -qt=qt5-x86_64-linux-gnu -print-env":
+ // QT_SELECT="qt5-x86_64-linux-gnu"
+ // QTTOOLDIR="/usr/lib/qt5/bin"
+ // QTLIBDIR="/usr/lib/x86_64-linux-gnu"
+ const QByteArray qtToolDirPrefix("QTTOOLDIR=\"");
for (const QByteArray &output : outputs) {
- if (output.startsWith("QTTOOLDIR=\"")) {
- QByteArray withoutVarName = output.mid(11); // remove QTTOOLDIR="
+ if (output.startsWith(qtToolDirPrefix)) {
+ QByteArray withoutVarName = output.mid(qtToolDirPrefix.size()); // remove QTTOOLDIR="
withoutVarName.chop(1); // remove trailing quote
return QStandardPaths::findExecutable(QStringLiteral("qmake"), QStringList()
<< QString::fromLocal8Bit(withoutVarName));
@@ -424,6 +433,15 @@ static FilePaths gatherQmakePathsFromQtChooser()
return FilePaths();
const QList versions = runQtChooser(qtchooser, QStringList("-l"));
+ // Exemplary output of "qtchooser -l":
+ // 4
+ // 5
+ // default
+ // qt4-x86_64-linux-gnu
+ // qt4
+ // qt5-x86_64-linux-gnu
+ // qt5
+ // ""
QSet foundQMakes;
for (const QByteArray &version : versions) {
FilePath possibleQMake = FilePath::fromString(
@@ -436,19 +454,20 @@ static FilePaths gatherQmakePathsFromQtChooser()
static void findSystemQt()
{
- FilePaths systemQMakes
+ FilePaths systemQueryTools
= BuildableHelperLibrary::findQtsInEnvironment(Environment::systemEnvironment());
- systemQMakes.append(gatherQmakePathsFromQtChooser());
- for (const FilePath &qmakePath : qAsConst(systemQMakes)) {
- if (BuildableHelperLibrary::isQtChooser(qmakePath))
+ systemQueryTools.append(gatherQmakePathsFromQtChooser());
+ for (const FilePath &queryToolPath : qAsConst(systemQueryTools)) {
+ if (BuildableHelperLibrary::isQtChooser(queryToolPath))
continue;
- const auto isSameQmake = [qmakePath](const QtVersion *version) {
+ const auto isSameQueryTool = [queryToolPath](const QtVersion *version) {
return Environment::systemEnvironment().
- isSameExecutable(qmakePath.toString(), version->qmakeFilePath().toString());
+ isSameExecutable(queryToolPath.toString(),
+ version->queryToolFilePath().toString());
};
- if (contains(m_versions, isSameQmake))
+ if (contains(m_versions, isSameQueryTool))
continue;
- QtVersion *version = QtVersionFactory::createQtVersionFromQMakePath(qmakePath,
+ QtVersion *version = QtVersionFactory::createQtVersionFromQueryToolPath(queryToolPath,
false,
"PATH");
if (version)