diff --git a/src/plugins/qt4projectmanager/projectloadwizard.cpp b/src/plugins/qt4projectmanager/projectloadwizard.cpp
index 5797e99b1742c4a2db9ffefd718a2dde286f80ba..6fbe43eb57cd6dd799a884f2b8c0fbbe5f2debd0 100644
--- a/src/plugins/qt4projectmanager/projectloadwizard.cpp
+++ b/src/plugins/qt4projectmanager/projectloadwizard.cpp
@@ -89,14 +89,9 @@ void ProjectLoadWizard::setupTargetPage()
if (m_targetSetupPage)
return;
- QList<TargetSetupPage::ImportInfo> importVersions = TargetSetupPage::scanDefaultProjectDirectories(m_project);
- importVersions.append(TargetSetupPage::importInfosForKnownQtVersions(m_project->file()->fileName()));
-
m_targetSetupPage = new TargetSetupPage(this);
m_targetSetupPage->setProFilePath(m_project->file()->fileName());
- m_targetSetupPage->setImportInfos(importVersions);
- m_targetSetupPage->setImportDirectoryBrowsingEnabled(true);
- m_targetSetupPage->setImportDirectoryBrowsingLocation(m_project->projectDirectory());
+ m_targetSetupPage->setImportSearch(true);
resize(900, 450);
addPage(m_targetSetupPage);
diff --git a/src/plugins/qt4projectmanager/qt-desktop/qt4desktoptargetfactory.cpp b/src/plugins/qt4projectmanager/qt-desktop/qt4desktoptargetfactory.cpp
index b0dc98ca12d145825590b2268554503fbaec35b2..776ace2b51fe3f92304e80d2da1a3e0e35fa82c4 100644
--- a/src/plugins/qt4projectmanager/qt-desktop/qt4desktoptargetfactory.cpp
+++ b/src/plugins/qt4projectmanager/qt-desktop/qt4desktoptargetfactory.cpp
@@ -42,8 +42,10 @@
#include <projectexplorer/customexecutablerunconfiguration.h>
#include <projectexplorer/projectexplorerconstants.h>
+#include <QtGui/QVBoxLayout>
#include <QtGui/QApplication>
#include <QtGui/QStyle>
+#include <QtGui/QLabel>
using namespace Qt4ProjectManager;
using namespace Qt4ProjectManager::Internal;
@@ -67,7 +69,7 @@ bool Qt4DesktopTargetFactory::supportsTargetId(const QString &id) const
QStringList Qt4DesktopTargetFactory::supportedTargetIds(ProjectExplorer::Project *parent) const
{
- if (!qobject_cast<Qt4Project *>(parent))
+ if (parent && !qobject_cast<Qt4Project *>(parent))
return QStringList();
if (!QtVersionManager::instance()->supportsTargetId(Constants::DESKTOP_TARGET_ID))
return QStringList();
@@ -126,23 +128,31 @@ QString Qt4DesktopTargetFactory::defaultShadowBuildDirectory(const QString &proj
return projectLocation + QLatin1String("-desktop");
}
-QList<BuildConfigurationInfo> Qt4DesktopTargetFactory::availableBuildConfigurations(const QString &proFilePath)
+QList<BuildConfigurationInfo> Qt4DesktopTargetFactory::availableBuildConfigurations(const QString &id, const QString &proFilePath, const QtVersionNumber &minimumQtVersion)
{
+ Q_ASSERT(id == Constants::DESKTOP_TARGET_ID);
QList<BuildConfigurationInfo> infos;
- QList<QtVersion *> knownVersions = QtVersionManager::instance()->versionsForTargetId(Constants::DESKTOP_TARGET_ID);
+ QList<QtVersion *> knownVersions = QtVersionManager::instance()->versionsForTargetId(id, minimumQtVersion);
foreach (QtVersion *version, knownVersions) {
if (!version->isValid())
continue;
QtVersion::QmakeBuildConfigs config = version->defaultBuildConfig();
- QString dir = defaultShadowBuildDirectory(Qt4Project::defaultTopLevelBuildDirectory(proFilePath), Constants::DESKTOP_TARGET_ID);
+ QString dir = defaultShadowBuildDirectory(Qt4Project::defaultTopLevelBuildDirectory(proFilePath), id);
infos.append(BuildConfigurationInfo(version, config, QString(), dir));
infos.append(BuildConfigurationInfo(version, config ^ QtVersion::DebugBuild, QString(), dir));
}
return infos;
}
+Qt4TargetSetupWidget *Qt4DesktopTargetFactory::createTargetSetupWidget(const QString &id, const QString &proFilePath, const QtVersionNumber &number, bool importEnabled, QList<BuildConfigurationInfo> importInfos)
+{
+ Qt4DefaultTargetSetupWidget *widget = new Qt4DefaultTargetSetupWidget(this, id, proFilePath, number, importEnabled, importInfos);
+ widget->setShadowBuildCheckBoxVisible(true);
+ return widget;
+}
+
Qt4BaseTarget *Qt4DesktopTargetFactory::create(ProjectExplorer::Project *parent, const QString &id)
{
if (!canCreate(parent, id))
@@ -162,10 +172,18 @@ Qt4BaseTarget *Qt4DesktopTargetFactory::create(ProjectExplorer::Project *parent,
return create(parent, id, infos);
}
-Qt4BaseTarget *Qt4DesktopTargetFactory::create(ProjectExplorer::Project *parent, const QString &id, QList<BuildConfigurationInfo> infos)
+bool Qt4DesktopTargetFactory::isMobileTarget(const QString &id)
+{
+ Q_UNUSED(id)
+ return false;
+}
+
+Qt4BaseTarget *Qt4DesktopTargetFactory::create(ProjectExplorer::Project *parent, const QString &id, const QList<BuildConfigurationInfo> &infos)
{
if (!canCreate(parent, id))
return 0;
+ if (infos.isEmpty())
+ return 0;
Qt4DesktopTarget *t = new Qt4DesktopTarget(static_cast<Qt4Project *>(parent), id);
foreach (const BuildConfigurationInfo &info, infos)
diff --git a/src/plugins/qt4projectmanager/qt-desktop/qt4desktoptargetfactory.h b/src/plugins/qt4projectmanager/qt-desktop/qt4desktoptargetfactory.h
index 2c99a7822bf7d7a1f43c914432ade31fbd88505d..48f2778a7e581075be6fc9fc96d75847a9b84f94 100644
--- a/src/plugins/qt4projectmanager/qt-desktop/qt4desktoptargetfactory.h
+++ b/src/plugins/qt4projectmanager/qt-desktop/qt4desktoptargetfactory.h
@@ -56,11 +56,13 @@ public:
virtual bool supportsTargetId(const QString &id) const;
- QList<BuildConfigurationInfo> availableBuildConfigurations(const QString &proFilePath);
+ Qt4TargetSetupWidget *createTargetSetupWidget(const QString &id, const QString &proFilePath, const QtVersionNumber &minimumQtVersion, bool importEnabled, QList<BuildConfigurationInfo> importInfos);
+ bool isMobileTarget(const QString &id);
+ QList<BuildConfigurationInfo> availableBuildConfigurations(const QString &id, const QString &proFilePath, const QtVersionNumber &minimumQtVersion);
Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id);
- Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id, QList<BuildConfigurationInfo> infos);
+ Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id, const QList<BuildConfigurationInfo> &infos);
+
};
}
}
-
#endif // QT4DESKTOPTARGETFACTORY_H
diff --git a/src/plugins/qt4projectmanager/qt-desktop/qt4simulatortargetfactory.cpp b/src/plugins/qt4projectmanager/qt-desktop/qt4simulatortargetfactory.cpp
index 3061a95d592b877320e589e23856df03b74b5c79..7a0c7a150c993b512ed4c1d93f24b97b691d90fd 100644
--- a/src/plugins/qt4projectmanager/qt-desktop/qt4simulatortargetfactory.cpp
+++ b/src/plugins/qt4projectmanager/qt-desktop/qt4simulatortargetfactory.cpp
@@ -70,7 +70,7 @@ bool Qt4SimulatorTargetFactory::supportsTargetId(const QString &id) const
QStringList Qt4SimulatorTargetFactory::supportedTargetIds(ProjectExplorer::Project *parent) const
{
- if (!qobject_cast<Qt4Project *>(parent))
+ if (parent && !qobject_cast<Qt4Project *>(parent))
return QStringList();
if (!QtVersionManager::instance()->supportsTargetId(Constants::QT_SIMULATOR_TARGET_ID))
return QStringList();
@@ -128,22 +128,29 @@ QString Qt4SimulatorTargetFactory::defaultShadowBuildDirectory(const QString &pr
return projectLocation + QLatin1String("-simulator");
}
-QList<BuildConfigurationInfo> Qt4SimulatorTargetFactory::availableBuildConfigurations(const QString &proFilePath)
+QList<BuildConfigurationInfo> Qt4SimulatorTargetFactory::availableBuildConfigurations(const QString &id, const QString &proFilePath, const QtVersionNumber &minimumQtVersion)
{
+ Q_ASSERT(id == Constants::QT_SIMULATOR_TARGET_ID);
QList<BuildConfigurationInfo> infos;
- QList<QtVersion *> knownVersions = QtVersionManager::instance()->versionsForTargetId(Constants::QT_SIMULATOR_TARGET_ID);
+ QList<QtVersion *> knownVersions = QtVersionManager::instance()->versionsForTargetId(id, minimumQtVersion);
foreach (QtVersion *version, knownVersions) {
if (!version->isValid())
continue;
QtVersion::QmakeBuildConfigs config = version->defaultBuildConfig();
- QString dir = defaultShadowBuildDirectory(Qt4Project::defaultTopLevelBuildDirectory(proFilePath), Constants::QT_SIMULATOR_TARGET_ID);
+ QString dir = defaultShadowBuildDirectory(Qt4Project::defaultTopLevelBuildDirectory(proFilePath), id);
infos.append(BuildConfigurationInfo(version, config, QString(), dir));
infos.append(BuildConfigurationInfo(version, config ^ QtVersion::DebugBuild, QString(), dir));
}
return infos;
}
+bool Qt4SimulatorTargetFactory::isMobileTarget(const QString &id)
+{
+ Q_UNUSED(id)
+ return true;
+}
+
Qt4BaseTarget *Qt4SimulatorTargetFactory::create(ProjectExplorer::Project *parent, const QString &id)
{
if (!canCreate(parent, id))
@@ -162,10 +169,12 @@ Qt4BaseTarget *Qt4SimulatorTargetFactory::create(ProjectExplorer::Project *paren
return create(parent, id, infos);
}
-Qt4BaseTarget *Qt4SimulatorTargetFactory::create(ProjectExplorer::Project *parent, const QString &id, QList<BuildConfigurationInfo> infos)
+Qt4BaseTarget *Qt4SimulatorTargetFactory::create(ProjectExplorer::Project *parent, const QString &id, const QList<BuildConfigurationInfo> &infos)
{
if (!canCreate(parent, id))
return 0;
+ if (infos.isEmpty())
+ return 0;
Qt4SimulatorTarget *t = new Qt4SimulatorTarget(static_cast<Qt4Project *>(parent), id);
foreach (const BuildConfigurationInfo &info, infos)
diff --git a/src/plugins/qt4projectmanager/qt-desktop/qt4simulatortargetfactory.h b/src/plugins/qt4projectmanager/qt-desktop/qt4simulatortargetfactory.h
index 0f560a6ee003da4e7a8c9f6992acbb733feef070..09fc6b12403563d467c0eaae5a1a42d6213da157 100644
--- a/src/plugins/qt4projectmanager/qt-desktop/qt4simulatortargetfactory.h
+++ b/src/plugins/qt4projectmanager/qt-desktop/qt4simulatortargetfactory.h
@@ -56,11 +56,12 @@ public:
Qt4ProjectManager::Qt4BaseTarget *restore(ProjectExplorer::Project *parent, const QVariantMap &map);
QString defaultShadowBuildDirectory(const QString &projectLocation, const QString &id);
- virtual bool supportsTargetId(const QString &id) const;
+ bool supportsTargetId(const QString &id) const;
- QList<BuildConfigurationInfo> availableBuildConfigurations(const QString &proFilePath);
+ QList<BuildConfigurationInfo> availableBuildConfigurations(const QString &id, const QString &proFilePath, const QtVersionNumber &minimumQtVersion);
+ bool isMobileTarget(const QString &id);
Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id);
- Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id, QList<BuildConfigurationInfo> infos);
+ Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id, const QList<BuildConfigurationInfo> &infos);
};
}
diff --git a/src/plugins/qt4projectmanager/qt-maemo/qt4maemotargetfactory.cpp b/src/plugins/qt4projectmanager/qt-maemo/qt4maemotargetfactory.cpp
index 4dbfe011abd876a1bbca3d19533d2c9b58e14fd2..b485fb6febe5ea81aef1146131764c4a4ed88004 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/qt4maemotargetfactory.cpp
+++ b/src/plugins/qt4projectmanager/qt-maemo/qt4maemotargetfactory.cpp
@@ -44,8 +44,6 @@
#include <projectexplorer/projectexplorerconstants.h>
#include <projectexplorer/customexecutablerunconfiguration.h>
-#include <QtGui/QApplication>
-
using namespace Qt4ProjectManager;
using namespace Qt4ProjectManager::Internal;
using ProjectExplorer::idFromMap;
@@ -72,7 +70,7 @@ bool Qt4MaemoTargetFactory::supportsTargetId(const QString &id) const
QStringList Qt4MaemoTargetFactory::supportedTargetIds(ProjectExplorer::Project *parent) const
{
QStringList targetIds;
- if (!qobject_cast<Qt4Project *>(parent))
+ if (parent && !qobject_cast<Qt4Project *>(parent))
return targetIds;
if (QtVersionManager::instance()->supportsTargetId(QLatin1String(Constants::MAEMO5_DEVICE_TARGET_ID)))
targetIds << QLatin1String(Constants::MAEMO5_DEVICE_TARGET_ID);
@@ -151,19 +149,10 @@ QString Qt4MaemoTargetFactory::defaultShadowBuildDirectory(const QString &projec
return projectLocation + QLatin1Char('-') + suffix;
}
-QList<BuildConfigurationInfo> Qt4MaemoTargetFactory::availableBuildConfigurations(const QString &proFilePath)
-{
- return QList<BuildConfigurationInfo>()
- << availableBuildConfigurations(proFilePath, QLatin1String(Constants::MAEMO5_DEVICE_TARGET_ID))
- << availableBuildConfigurations(proFilePath, QLatin1String(Constants::HARMATTAN_DEVICE_TARGET_ID))
- << availableBuildConfigurations(proFilePath, QLatin1String(Constants::MEEGO_DEVICE_TARGET_ID));
-}
-
-QList<BuildConfigurationInfo> Qt4MaemoTargetFactory::availableBuildConfigurations(const QString &proFilePath,
- const QString &id)
+QList<BuildConfigurationInfo> Qt4MaemoTargetFactory::availableBuildConfigurations(const QString &id, const QString &proFilePath, const QtVersionNumber &minimumQtVersion)
{
QList<BuildConfigurationInfo> infos;
- QList<QtVersion *> knownVersions = QtVersionManager::instance()->versionsForTargetId(id);
+ QList<QtVersion *> knownVersions = QtVersionManager::instance()->versionsForTargetId(id, minimumQtVersion);
foreach (QtVersion *version, knownVersions) {
if (!version->isValid())
@@ -176,6 +165,12 @@ QList<BuildConfigurationInfo> Qt4MaemoTargetFactory::availableBuildConfiguration
return infos;
}
+bool Qt4MaemoTargetFactory::isMobileTarget(const QString &id)
+{
+ Q_UNUSED(id)
+ return true;
+}
+
Qt4BaseTarget *Qt4MaemoTargetFactory::create(ProjectExplorer::Project *parent, const QString &id)
{
if (!canCreate(parent, id))
@@ -196,7 +191,7 @@ Qt4BaseTarget *Qt4MaemoTargetFactory::create(ProjectExplorer::Project *parent, c
}
Qt4BaseTarget *Qt4MaemoTargetFactory::create(ProjectExplorer::Project *parent,
- const QString &id, QList<BuildConfigurationInfo> infos)
+ const QString &id, const QList<BuildConfigurationInfo> &infos)
{
if (!canCreate(parent, id))
return 0;
diff --git a/src/plugins/qt4projectmanager/qt-maemo/qt4maemotargetfactory.h b/src/plugins/qt4projectmanager/qt-maemo/qt4maemotargetfactory.h
index 819de2b09e28079aacbb7e83035aabae00f4db90..fbf02731a85caf16b8c68547174f01a4cbe6840f 100644
--- a/src/plugins/qt4projectmanager/qt-maemo/qt4maemotargetfactory.h
+++ b/src/plugins/qt4projectmanager/qt-maemo/qt4maemotargetfactory.h
@@ -55,15 +55,13 @@ public:
Qt4ProjectManager::Qt4BaseTarget *restore(ProjectExplorer::Project *parent, const QVariantMap &map);
QString defaultShadowBuildDirectory(const QString &projectLocation, const QString &id);
- virtual bool supportsTargetId(const QString &id) const;
+ bool supportsTargetId(const QString &id) const;
- QList<BuildConfigurationInfo> availableBuildConfigurations(const QString &proFilePath);
Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id);
- Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id, QList<BuildConfigurationInfo> infos);
+ Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id, const QList<BuildConfigurationInfo> &infos);
-private:
- QList<BuildConfigurationInfo> availableBuildConfigurations(const QString &proFilePath,
- const QString &id);
+ QList<BuildConfigurationInfo> availableBuildConfigurations(const QString &id, const QString &proFilePath, const QtVersionNumber &minimumQtVersion);
+ bool isMobileTarget(const QString &id);
};
} // namespace Internal
diff --git a/src/plugins/qt4projectmanager/qt-s60/qt4symbiantargetfactory.cpp b/src/plugins/qt4projectmanager/qt-s60/qt4symbiantargetfactory.cpp
index 767c068bd6425fa8db01a644a8c3faf369a90340..7766ca4b211060ab5fb3bf25bcd794a6facb6501 100644
--- a/src/plugins/qt4projectmanager/qt-s60/qt4symbiantargetfactory.cpp
+++ b/src/plugins/qt4projectmanager/qt-s60/qt4symbiantargetfactory.cpp
@@ -72,7 +72,7 @@ bool Qt4SymbianTargetFactory::supportsTargetId(const QString &id) const
QStringList Qt4SymbianTargetFactory::supportedTargetIds(ProjectExplorer::Project *parent) const
{
- if (!qobject_cast<Qt4Project *>(parent))
+ if (parent && !qobject_cast<Qt4Project *>(parent))
return QStringList();
QStringList ids;
@@ -139,33 +139,34 @@ QString Qt4SymbianTargetFactory::defaultShadowBuildDirectory(const QString &proj
return projectLocation + QChar('-') + shortName;
}
-QList<BuildConfigurationInfo> Qt4SymbianTargetFactory::availableBuildConfigurations(const QString &proFilePath)
+QList<BuildConfigurationInfo> Qt4SymbianTargetFactory::availableBuildConfigurations(const QString &id, const QString &proFilePath, const QtVersionNumber &minimumQtVersion)
{
QList<BuildConfigurationInfo> infos;
- QList<QtVersion *> knownVersions = QtVersionManager::instance()->versionsForTargetId(Constants::S60_EMULATOR_TARGET_ID);
+ QList<QtVersion *> knownVersions = QtVersionManager::instance()->versionsForTargetId(id, minimumQtVersion);
foreach (QtVersion *version, knownVersions) {
if (!version->isValid())
continue;
bool buildAll = version->defaultBuildConfig() & QtVersion::BuildAll;
QtVersion::QmakeBuildConfigs config = buildAll ? QtVersion::BuildAll : QtVersion::QmakeBuildConfig(0);
- QString dir = defaultShadowBuildDirectory(Qt4Project::defaultTopLevelBuildDirectory(proFilePath), Constants::S60_EMULATOR_TARGET_ID);
- infos.append(BuildConfigurationInfo(version, config | QtVersion::DebugBuild, QString(), dir));
- }
-
- knownVersions = QtVersionManager::instance()->versionsForTargetId(Constants::S60_DEVICE_TARGET_ID);
- foreach (QtVersion *version, knownVersions) {
- if (!version->isValid())
- continue;
- QtVersion::QmakeBuildConfigs config = version->defaultBuildConfig();
- QString dir = defaultShadowBuildDirectory(Qt4Project::defaultTopLevelBuildDirectory(proFilePath), Constants::S60_DEVICE_TARGET_ID);
- infos.append(BuildConfigurationInfo(version, config, QString(), dir));
- infos.append(BuildConfigurationInfo(version, config ^ QtVersion::DebugBuild, QString(), dir));
+ QString dir = defaultShadowBuildDirectory(Qt4Project::defaultTopLevelBuildDirectory(proFilePath), id);
+ if (id == Constants::S60_EMULATOR_TARGET_ID) {
+ infos.append(BuildConfigurationInfo(version, config | QtVersion::DebugBuild, QString(), dir));
+ } else {
+ infos.append(BuildConfigurationInfo(version, config, QString(), dir));
+ infos.append(BuildConfigurationInfo(version, config ^ QtVersion::DebugBuild, QString(), dir));
+ }
}
return infos;
}
+bool Qt4SymbianTargetFactory::isMobileTarget(const QString &id)
+{
+ Q_UNUSED(id)
+ return true;
+}
+
Qt4BaseTarget *Qt4SymbianTargetFactory::create(ProjectExplorer::Project *parent, const QString &id)
{
if (!canCreate(parent, id))
@@ -192,7 +193,7 @@ Qt4BaseTarget *Qt4SymbianTargetFactory::create(ProjectExplorer::Project *parent,
return create(parent, id, infos);
}
-Qt4BaseTarget *Qt4SymbianTargetFactory::create(ProjectExplorer::Project *parent, const QString &id, QList<BuildConfigurationInfo> infos)
+Qt4BaseTarget *Qt4SymbianTargetFactory::create(ProjectExplorer::Project *parent, const QString &id, const QList<BuildConfigurationInfo> &infos)
{
if (!canCreate(parent, id))
return 0;
@@ -210,3 +211,11 @@ Qt4BaseTarget *Qt4SymbianTargetFactory::create(ProjectExplorer::Project *parent,
t->addRunConfiguration(new ProjectExplorer::CustomExecutableRunConfiguration(t));
return t;
}
+
+Qt4BaseTarget *Qt4SymbianTargetFactory::create(ProjectExplorer::Project *parent, const QString &id, Qt4TargetSetupWidget *widget)
+{
+ if (!widget->isTargetSelected())
+ return 0;
+ Qt4DefaultTargetSetupWidget *w = static_cast<Qt4DefaultTargetSetupWidget *>(widget);
+ return create(parent, id, w->buildConfigurationInfos());
+}
diff --git a/src/plugins/qt4projectmanager/qt-s60/qt4symbiantargetfactory.h b/src/plugins/qt4projectmanager/qt-s60/qt4symbiantargetfactory.h
index f591a2b4b45a7697b73359027ce2060370626e27..923efb329aa08b1b37d6292f2db3ad51aa4441ba 100644
--- a/src/plugins/qt4projectmanager/qt-s60/qt4symbiantargetfactory.h
+++ b/src/plugins/qt4projectmanager/qt-s60/qt4symbiantargetfactory.h
@@ -52,13 +52,15 @@ public:
bool canCreate(ProjectExplorer::Project *parent, const QString &id) const;
bool canRestore(ProjectExplorer::Project *parent, const QVariantMap &map) const;
-
Qt4ProjectManager::Qt4BaseTarget *restore(ProjectExplorer::Project *parent, const QVariantMap &map);
+
Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id);
- Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id, QList<BuildConfigurationInfo> infos);
+ Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id, const QList<BuildConfigurationInfo> &infos);
+ Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id, Qt4TargetSetupWidget *widget);
QString defaultShadowBuildDirectory(const QString &projectLocation, const QString &id);
- QList<BuildConfigurationInfo> availableBuildConfigurations(const QString &proFilePath);
+ QList<BuildConfigurationInfo> availableBuildConfigurations(const QString &id, const QString &proFilePath, const QtVersionNumber &minimumQtVersion);
+ bool isMobileTarget(const QString &id);
};
} // namespace Internal
diff --git a/src/plugins/qt4projectmanager/qt-s60/s60symbiancertificate.cpp b/src/plugins/qt4projectmanager/qt-s60/s60symbiancertificate.cpp
index f60288555c7c37826f3ac5eb32594f35d4d48ea8..26f0e23f47ae68e10c577b2b1f92a8ee44bd89b4 100644
--- a/src/plugins/qt4projectmanager/qt-s60/s60symbiancertificate.cpp
+++ b/src/plugins/qt4projectmanager/qt-s60/s60symbiancertificate.cpp
@@ -67,7 +67,7 @@ namespace {
/*
* X.509 S60 Certificate Extension
*/
-class S60CertificateExtension : public Certificate_Extension
+class S60CertificateExtension : Certificate_Extension
{
public:
OID oid_of() const;
diff --git a/src/plugins/qt4projectmanager/qt4target.cpp b/src/plugins/qt4projectmanager/qt4target.cpp
index 1549a670d98cdc02502a2c339df40675e6bd5bcc..e220109fef8f14d065621f086c7cb7d16b1b8411 100644
--- a/src/plugins/qt4projectmanager/qt4target.cpp
+++ b/src/plugins/qt4projectmanager/qt4target.cpp
@@ -39,12 +39,21 @@
#include "qt4projectmanagerconstants.h"
#include "qt4projectconfigwidget.h"
+#include <coreplugin/icore.h>
#include <extensionsystem/pluginmanager.h>
#include <projectexplorer/buildsteplist.h>
#include <projectexplorer/runconfiguration.h>
#include <projectexplorer/customexecutablerunconfiguration.h>
#include <projectexplorer/toolchainmanager.h>
#include <projectexplorer/projectexplorerconstants.h>
+#include <projectexplorer/task.h>
+#include <utils/pathchooser.h>
+#include <utils/detailswidget.h>
+
+#include <QtGui/QPushButton>
+#include <QtGui/QMessageBox>
+#include <QtGui/QCheckBox>
+#include <QtGui/QMainWindow>
using namespace Qt4ProjectManager;
using namespace Qt4ProjectManager::Internal;
@@ -64,6 +73,24 @@ Qt4BaseTargetFactory::~Qt4BaseTargetFactory()
}
+Qt4TargetSetupWidget *Qt4BaseTargetFactory::createTargetSetupWidget(const QString &id,
+ const QString &proFilePath,
+ const QtVersionNumber &number,
+ bool importEnabled,
+ QList<BuildConfigurationInfo> importInfos)
+{
+ return new Qt4DefaultTargetSetupWidget(this, id, proFilePath, number, importEnabled, importInfos);
+}
+
+Qt4BaseTarget *Qt4BaseTargetFactory::create(ProjectExplorer::Project *parent, const QString &id, Qt4TargetSetupWidget *widget)
+{
+ if (!widget->isTargetSelected())
+ return 0;
+ Q_ASSERT(qobject_cast<Qt4DefaultTargetSetupWidget *>(widget));
+ Qt4DefaultTargetSetupWidget *w = static_cast<Qt4DefaultTargetSetupWidget *>(widget);
+ return create(parent, id, w->buildConfigurationInfos());
+}
+
Qt4BaseTargetFactory *Qt4BaseTargetFactory::qt4BaseTargetFactoryForId(const QString &id)
{
QList<Qt4BaseTargetFactory *> factories = ExtensionSystem::PluginManager::instance()->getObjects<Qt4BaseTargetFactory>();
@@ -229,3 +256,534 @@ void Qt4BaseTarget::emitProFileEvaluateNeeded()
{
emit proFileEvaluateNeeded(this);
}
+
+// -------------------------------------------------------------------------
+// Qt4TargetSetupWidget
+// -------------------------------------------------------------------------
+
+Qt4TargetSetupWidget::Qt4TargetSetupWidget()
+ : QWidget(0)
+{
+
+}
+
+Qt4TargetSetupWidget::~Qt4TargetSetupWidget()
+{
+
+}
+
+// -------------------------------------------------------------------------
+// Qt4DefaultTargetSetupWidget
+// -------------------------------------------------------------------------
+
+Qt4DefaultTargetSetupWidget::Qt4DefaultTargetSetupWidget(Qt4BaseTargetFactory *factory,
+ const QString &id,
+ const QString &proFilePath,
+ const QtVersionNumber &minimumQtVersion,
+ bool importEnabled,
+ QList<BuildConfigurationInfo> importInfos)
+ : Qt4TargetSetupWidget(),
+ m_id(id),
+ m_factory(factory),
+ m_proFilePath(proFilePath),
+ m_minimumQtVersion(minimumQtVersion),
+ m_importInfos(importInfos),
+ m_directoriesEnabled(true),
+ m_hasInSourceBuild(false),
+ m_ignoreChange(false),
+ m_showImport(importEnabled),
+ m_selected(0)
+{
+ QString sourceDir = QFileInfo(m_proFilePath).absolutePath();
+
+ setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
+ QVBoxLayout *vboxLayout = new QVBoxLayout();
+ vboxLayout->setMargin(0);
+ setLayout(vboxLayout);
+ m_detailsWidget = new Utils::DetailsWidget(this);
+ m_detailsWidget->setSummaryText(factory->displayNameForId(id));
+ m_detailsWidget->setUseCheckBox(true);
+ m_detailsWidget->setChecked(true);
+ m_detailsWidget->setSummaryFontBold(true);
+ m_detailsWidget->setIcon(factory->iconForId(id));
+ vboxLayout->addWidget(m_detailsWidget);
+
+ QWidget *widget = new QWidget;
+ QVBoxLayout *layout = new QVBoxLayout;
+ widget->setLayout(layout);
+
+ m_importLayout = new QGridLayout;
+ m_importLayout->setMargin(0);
+ layout->addLayout(m_importLayout);
+
+ m_importLineLayout = new QHBoxLayout();
+ m_importLineLabel = new QLabel();
+ m_importLineLabel->setText(tr("Import build from:"));
+ m_importLineLayout->addWidget(m_importLineLabel);
+
+ m_importLinePath = new Utils::PathChooser();
+ m_importLinePath->setExpectedKind(Utils::PathChooser::ExistingDirectory);
+ m_importLinePath->setPath(sourceDir);
+ m_importLineLayout->addWidget(m_importLinePath);
+
+ m_importLineButton = new QPushButton;
+ m_importLineButton->setText(tr("Add Build"));
+ m_importLineLayout->addWidget(m_importLineButton);
+ layout->addLayout(m_importLineLayout);
+
+ if (!m_showImport) {
+ m_importLineLabel->setVisible(false);
+ m_importLinePath->setVisible(false);
+ m_importLineButton->setVisible(false);
+ }
+
+ m_spacerTopWidget = new QWidget;
+ m_spacerTopWidget->setMinimumHeight(12);
+ layout->addWidget(m_spacerTopWidget);
+
+ m_shadowBuildEnabled = new QCheckBox;
+ m_shadowBuildEnabled->setText(tr("Use Shadow Building"));
+ m_shadowBuildEnabled->setChecked(true);
+ m_shadowBuildEnabled->setVisible(false);
+ layout->addWidget(m_shadowBuildEnabled);
+
+ m_spacerBottomWidget = new QWidget;
+ m_spacerBottomWidget->setMinimumHeight(0);
+ layout->addWidget(m_spacerBottomWidget);
+
+ m_newBuildsLayout = new QGridLayout;
+ m_newBuildsLayout->setMargin(0);
+ layout->addLayout(m_newBuildsLayout);
+
+ m_spacerTopWidget->setVisible(false);
+ m_spacerBottomWidget->setVisible(false);
+
+ m_detailsWidget->setWidget(widget);
+
+ for (int i = 0; i < m_importInfos.size(); ++i) {
+ if (m_importInfos.at(i).directory == sourceDir)
+ m_hasInSourceBuild = true;
+ m_importEnabled << true;
+ }
+
+ m_selected += m_importInfos.size();
+
+ setupImportWidgets();
+
+ setBuildConfigurationInfos(factory->availableBuildConfigurations(id, proFilePath, minimumQtVersion));
+
+ if (!m_importInfos.isEmpty())
+ m_detailsWidget->setState(Utils::DetailsWidget::Expanded);
+
+ connect(m_importLineButton, SIGNAL(clicked()),
+ this, SLOT(addImportClicked()));
+
+ connect(m_detailsWidget, SIGNAL(checked(bool)),
+ this, SIGNAL(selectedToggled()));
+ connect(m_detailsWidget, SIGNAL(checked(bool)),
+ widget, SLOT(setEnabled(bool)));
+ connect(m_shadowBuildEnabled, SIGNAL(toggled(bool)),
+ this, SLOT(shadowBuildingToggled()));
+
+}
+
+Qt4DefaultTargetSetupWidget::~Qt4DefaultTargetSetupWidget()
+{
+}
+
+bool Qt4DefaultTargetSetupWidget::isTargetSelected() const
+{
+ return m_detailsWidget->isChecked() && m_selected;
+}
+
+void Qt4DefaultTargetSetupWidget::setTargetSelected(bool b)
+{
+ // Only check target if there are build configurations possible
+ b == b && !buildConfigurationInfos().isEmpty();
+ m_detailsWidget->setChecked(b);
+ // We want the shadow build option to be visible
+ if (m_shadowBuildEnabled->isVisible() && b)
+ m_detailsWidget->setState(Utils::DetailsWidget::Expanded);
+}
+
+QString Qt4DefaultTargetSetupWidget::displayNameFrom(const BuildConfigurationInfo &info)
+{
+ QString buildType;
+ if ((info.buildConfig & QtVersion::BuildAll) == 0) {
+ if (info.buildConfig & QtVersion::DebugBuild)
+ //: Debug build
+ buildType = tr("debug");
+ else
+ //: release build
+ buildType = tr("release");
+ }
+ return info.version->displayName() + " " + buildType;
+}
+
+void Qt4DefaultTargetSetupWidget::setProFilePath(const QString &proFilePath)
+{
+ m_proFilePath = proFilePath;
+ setBuildConfigurationInfos(m_factory->availableBuildConfigurations(m_id, proFilePath, m_minimumQtVersion), false);
+}
+
+void Qt4DefaultTargetSetupWidget::setShadowBuildCheckBoxVisible(bool b)
+{
+ m_shadowBuildEnabled->setVisible(b);
+ m_spacerTopWidget->setVisible(b && !m_importInfos.isEmpty());
+ m_spacerBottomWidget->setVisible(b);
+ m_shadowBuildEnabled->setChecked(!m_hasInSourceBuild);
+}
+
+QList<BuildConfigurationInfo> Qt4DefaultTargetSetupWidget::buildConfigurationInfos() const
+{
+ QList<BuildConfigurationInfo> infos;
+ for (int i = 0; i < m_importInfos.size(); ++i) {
+ if (m_importEnabled.at(i))
+ infos << m_importInfos.at(i);
+ }
+
+ QString sourceDir = QFileInfo(m_proFilePath).absolutePath();
+
+ int size = m_infos.size();
+ for (int i=0; i < size; ++i) {
+ if (m_enabled.at(i)) {
+ BuildConfigurationInfo info = m_infos.at(i);
+ if (m_shadowBuildEnabled->isChecked())
+ info.directory = sourceDir;
+ infos << info;
+ }
+ }
+ return infos;
+}
+
+void Qt4DefaultTargetSetupWidget::addImportClicked()
+{
+ BuildConfigurationInfo info = BuildConfigurationInfo::checkForBuild(m_importLinePath->path(), m_proFilePath);
+ if (!info.isValid()) {
+ QMessageBox::critical(Core::ICore::instance()->mainWindow(),
+ tr("No build found"),
+ tr("No Build found in %1 matching project %2.").arg(m_importLinePath->path()).arg(m_proFilePath));
+ return;
+ }
+
+ if (!info.version->supportsTargetId(m_id)) {
+ QMessageBox::critical(Core::ICore::instance()->mainWindow(),
+ tr("Incompatible build found"),
+ tr("The Build found in %1 is incompatible with this target").arg(m_importLinePath->path()));
+ return;
+ }
+ ++m_selected;
+ m_importEnabled << true;
+
+ m_importInfos << info;
+
+ createImportWidget(info, m_importEnabled.size() - 1);
+ emit newImportBuildConfiguration(info);
+}
+
+QList<BuildConfigurationInfo> Qt4DefaultTargetSetupWidget::usedImportInfos()
+{
+ QList<BuildConfigurationInfo> infos;
+ for (int i = 0; i < m_importInfos.size(); ++i) {
+ if (m_importEnabled.at(i))
+ infos << m_importInfos.at(i);
+ }
+ return infos;
+}
+
+void Qt4DefaultTargetSetupWidget::setBuildConfigurationInfos(const QList<BuildConfigurationInfo> &infos, bool resetEnabled)
+{
+ m_infos = infos;
+ if (resetEnabled || m_infos.size() != m_enabled.size()) {
+ m_enabled.clear();
+ m_selected = 0;
+ QStringList existingBuilds;
+ for (int i = 0; i < m_importInfos.size(); ++i) {
+ const BuildConfigurationInfo &info = m_importInfos.at(i);
+ existingBuilds << info.directory;
+ if (m_importEnabled.at(i))
+ ++m_selected;
+ }
+
+ // Default to importing existing builds and disable
+ // builds that would overwrite imports
+ for (int i=0; i < m_infos.size(); ++i) {
+ if (existingBuilds.contains(m_infos.at(i).directory) || m_hasInSourceBuild) {
+ m_enabled << false;
+ } else {
+ m_enabled << true;
+ ++m_selected;
+ }
+ }
+
+ clearWidgets();
+ setupWidgets();
+ } else {
+ m_ignoreChange = true;
+ QString sourceDir = QFileInfo(m_proFilePath).absolutePath();
+ for (int i=0; i < m_checkboxes.size(); ++i) {
+ const BuildConfigurationInfo &info = m_infos.at(i);
+
+ m_checkboxes[i]->setText(displayNameFrom(info));
+ if (m_shadowBuildEnabled->isChecked())
+ m_pathChoosers[i]->setPath(info.directory);
+ else
+ m_pathChoosers[i]->setPath(sourceDir);
+ reportIssues(i);
+ }
+ m_ignoreChange = false;
+ }
+}
+
+void Qt4DefaultTargetSetupWidget::setupImportWidgets()
+{
+ for (int i = 0; i < m_importInfos.size(); ++i)
+ createImportWidget(m_importInfos.at(i), i);
+}
+
+void Qt4DefaultTargetSetupWidget::createImportWidget(const BuildConfigurationInfo &info, int pos)
+{
+ QCheckBox *checkBox = new QCheckBox;
+ checkBox->setText(tr("Import build from %1").arg(info.directory));
+ checkBox->setChecked(m_importEnabled.at(pos));
+ m_importLayout->addWidget(checkBox, pos, 0, 1, 2);
+
+ connect(checkBox, SIGNAL(toggled(bool)),
+ this, SLOT(importCheckBoxToggled(bool)));
+
+ m_importCheckBoxes.append(checkBox);
+}
+
+void Qt4DefaultTargetSetupWidget::setupWidgets()
+{
+ m_ignoreChange = true;
+ QString sourceDir = QFileInfo(m_proFilePath).absolutePath();
+ for (int i = 0; i < m_infos.size(); ++i) {
+ const BuildConfigurationInfo &info = m_infos.at(i);
+ QCheckBox *checkbox = new QCheckBox;
+ checkbox->setText(displayNameFrom(info));
+ checkbox->setChecked(m_enabled.at(i));
+ m_newBuildsLayout->addWidget(checkbox, i * 2, 0);
+
+ Utils::PathChooser *pathChooser = new Utils::PathChooser();
+ pathChooser->setExpectedKind(Utils::PathChooser::Directory);
+ if (m_shadowBuildEnabled->isChecked())
+ pathChooser->setPath(info.directory);
+ else
+ pathChooser->setPath(sourceDir);
+ pathChooser->setReadOnly(!m_directoriesEnabled);
+ m_newBuildsLayout->addWidget(pathChooser, i * 2, 1);
+
+ QLabel *reportIssuesLabel = new QLabel;
+ reportIssuesLabel->setIndent(32);
+ m_newBuildsLayout->addWidget(reportIssuesLabel, i * 2 + 1, 0, 1, 2);
+
+ connect(checkbox, SIGNAL(toggled(bool)),
+ this, SLOT(checkBoxToggled(bool)));
+
+ connect(pathChooser, SIGNAL(changed(QString)),
+ this, SLOT(pathChanged()));
+
+ m_checkboxes.append(checkbox);
+ m_pathChoosers.append(pathChooser);
+ m_reportIssuesLabels.append(reportIssuesLabel);
+ reportIssues(i);
+ }
+ m_ignoreChange = false;
+}
+
+void Qt4DefaultTargetSetupWidget::clearWidgets()
+{
+ qDeleteAll(m_checkboxes);
+ m_checkboxes.clear();
+ qDeleteAll(m_pathChoosers);
+ m_pathChoosers.clear();
+ qDeleteAll(m_reportIssuesLabels);
+ m_reportIssuesLabels.clear();
+}
+
+void Qt4DefaultTargetSetupWidget::checkBoxToggled(bool b)
+{
+ QCheckBox *box = qobject_cast<QCheckBox *>(sender());
+ if (!box)
+ return;
+ int index = m_checkboxes.indexOf(box);
+ if (index == -1)
+ return;
+ if (m_enabled[index] == b)
+ return;
+ m_selected += b ? 1 : -1;
+ m_enabled[index] = b;
+ if ((m_selected == 0 && !b) || (m_selected == 1 && b))
+ emit selectedToggled();
+}
+
+void Qt4DefaultTargetSetupWidget::importCheckBoxToggled(bool b)
+{
+ QCheckBox *box = qobject_cast<QCheckBox *>(sender());
+ if (!box)
+ return;
+ int index = m_importCheckBoxes.indexOf(box);
+ if (index == -1)
+ return;
+ if (m_importEnabled[index] == b)
+ return;
+ m_selected += b ? 1 : -1;
+ m_importEnabled[index] = b;
+ if ((m_selected == 0 && !b) || (m_selected == 1 && b))
+ emit selectedToggled();
+}
+
+void Qt4DefaultTargetSetupWidget::pathChanged()
+{
+ if (m_ignoreChange)
+ return;
+ Utils::PathChooser *pathChooser = qobject_cast<Utils::PathChooser *>(sender());
+ if (!pathChooser)
+ return;
+ int index = m_pathChoosers.indexOf(pathChooser);
+ if (index == -1)
+ return;
+ m_infos[index].directory = pathChooser->path();
+ reportIssues(index);
+}
+
+void Qt4DefaultTargetSetupWidget::shadowBuildingToggled()
+{
+ m_ignoreChange = true;
+ bool b = m_shadowBuildEnabled->isChecked();
+ if (m_directoriesEnabled == b)
+ return;
+ m_directoriesEnabled = b;
+ QString sourceDir = QFileInfo(m_proFilePath).absolutePath();
+ for (int i = 0; i < m_pathChoosers.size(); ++i) {
+ Utils::PathChooser *pathChooser = m_pathChoosers.at(i);
+ pathChooser->setReadOnly(!b);
+ if (b)
+ pathChooser->setPath(m_infos.at(i).directory);
+ else
+ pathChooser->setPath(sourceDir);
+ reportIssues(i);
+ }
+ m_ignoreChange = false;
+}
+
+void Qt4DefaultTargetSetupWidget::reportIssues(int index)
+{
+ QPair<ProjectExplorer::Task::TaskType, QString> issues = findIssues(m_infos.at(index));
+ QLabel *reportIssuesLabel = m_reportIssuesLabels.at(index);
+ reportIssuesLabel->setText(issues.second);
+ reportIssuesLabel->setVisible(issues.first != ProjectExplorer::Task::Unknown);
+}
+
+QPair<ProjectExplorer::Task::TaskType, QString> Qt4DefaultTargetSetupWidget::findIssues(const BuildConfigurationInfo &info)
+{
+ if (m_proFilePath.isEmpty())
+ return qMakePair(ProjectExplorer::Task::Unknown, QString());
+
+ QString buildDir = info.directory;
+ QtVersion *version = info.version;
+
+ QList<ProjectExplorer::Task> issues = version->reportIssues(m_proFilePath, buildDir);
+
+ QString text;
+ ProjectExplorer::Task::TaskType highestType = ProjectExplorer::Task::Unknown;
+ foreach (const ProjectExplorer::Task &t, issues) {
+ if (!text.isEmpty())
+ text.append(QLatin1String("<br>"));
+ // set severity:
+ QString severity;
+ if (t.type == ProjectExplorer::Task::Error) {
+ highestType = ProjectExplorer::Task::Error;
+ severity = tr("<b>Error:</b> ", "Severity is Task::Error");
+ } else if (t.type == ProjectExplorer::Task::Warning) {
+ if (highestType == ProjectExplorer::Task::Unknown)
+ highestType = ProjectExplorer::Task::Warning;
+ severity = tr("<b>Warning:</b> ", "Severity is Task::Warning");
+ }
+ text.append(severity + t.description);
+ }
+ if (!text.isEmpty())
+ text = QLatin1String("<nobr>") + text;
+ return qMakePair(highestType, text);
+}
+
+// -----------------------
+// BuildConfigurationInfo
+// -----------------------
+
+QList<BuildConfigurationInfo> BuildConfigurationInfo::filterBuildConfigurationInfos(const QList<BuildConfigurationInfo> &infos, const QString &id)
+{
+ QList<BuildConfigurationInfo> result;
+ foreach (const BuildConfigurationInfo &info, infos)
+ if (info.version->supportsTargetId(id))
+ result.append(info);
+ return result;
+}
+
+QList<BuildConfigurationInfo> BuildConfigurationInfo::importBuildConfigurations(const QString &proFilePath)
+{
+ QList<BuildConfigurationInfo> result;
+
+ // Check for in source build first
+ QString sourceDir = QFileInfo(proFilePath).absolutePath();
+ result.append(checkForBuild(sourceDir, proFilePath));
+
+ // If we found a in source build, we do not search for out of source builds
+ if (!result.isEmpty())
+ return result;
+
+ // Check for builds in build directoy
+ QList<Qt4BaseTargetFactory *> factories =
+ ExtensionSystem::PluginManager::instance()->getObjects<Qt4BaseTargetFactory>();
+ QString defaultTopLevelBuildDirectory = Qt4Project::defaultTopLevelBuildDirectory(proFilePath);
+ foreach (Qt4BaseTargetFactory *factory, factories) {
+ foreach (const QString &id, factory->supportedTargetIds(0)) {
+ QString expectedBuild = factory->defaultShadowBuildDirectory(defaultTopLevelBuildDirectory, id);
+ result.append(checkForBuild(expectedBuild, proFilePath));
+ }
+ }
+ return result;
+}
+
+BuildConfigurationInfo BuildConfigurationInfo::checkForBuild(const QString &directory, const QString &proFilePath)
+{
+ QString makefile = directory + "/Makefile";
+ QString qmakeBinary = QtVersionManager::findQMakeBinaryFromMakefile(makefile);
+ if (qmakeBinary.isEmpty())
+ return BuildConfigurationInfo();
+ if (!QtVersionManager::makefileIsFor(makefile, proFilePath))
+ return BuildConfigurationInfo();
+
+ bool temporaryQtVersion = false;
+ QtVersion *version = QtVersionManager::instance()->qtVersionForQMakeBinary(qmakeBinary);
+ if (!version) {
+ version = new QtVersion(qmakeBinary);
+ temporaryQtVersion = true;
+ }
+
+ QPair<QtVersion::QmakeBuildConfigs, QString> makefileBuildConfig =
+ QtVersionManager::scanMakeFile(makefile, version->defaultBuildConfig());
+
+ QString additionalArguments = makefileBuildConfig.second;
+ QString parsedSpec = Qt4BuildConfiguration::extractSpecFromArguments(&additionalArguments, directory, version);
+ QString versionSpec = version->mkspec();
+
+ QString specArgument;
+ // Compare mkspecs and add to additional arguments
+ if (parsedSpec.isEmpty() || parsedSpec == versionSpec || parsedSpec == "default") {
+ // using the default spec, don't modify additional arguments
+ } else {
+ specArgument = "-spec " + Utils::QtcProcess::quoteArg(parsedSpec);
+ }
+ Utils::QtcProcess::addArgs(&specArgument, additionalArguments);
+
+
+ BuildConfigurationInfo info = BuildConfigurationInfo(version,
+ makefileBuildConfig.first,
+ specArgument,
+ directory,
+ true,
+ temporaryQtVersion);
+ return info;
+}
diff --git a/src/plugins/qt4projectmanager/qt4target.h b/src/plugins/qt4projectmanager/qt4target.h
index 7aa7be7381a9286ea13ee1989bba9b1907e5a787..cfc1e53249eb64af3f4d96b34c9e5f1be9aa3e11 100644
--- a/src/plugins/qt4projectmanager/qt4target.h
+++ b/src/plugins/qt4projectmanager/qt4target.h
@@ -40,6 +40,19 @@
#include <projectexplorer/target.h>
#include <projectexplorer/projectnodes.h>
+namespace Utils {
+class DetailsWidget;
+class PathChooser;
+}
+
+QT_BEGIN_NAMESPACE
+class QCheckBox;
+class QHBoxLayout;
+class QGridLayout;
+class QLabel;
+class QPushButton;
+QT_END_NAMESPACE
+
namespace Qt4ProjectManager {
class Qt4Project;
@@ -49,14 +62,31 @@ class Qt4ProFileNode;
}
struct BuildConfigurationInfo {
+ explicit BuildConfigurationInfo()
+ : version(0), buildConfig(QtVersion::QmakeBuildConfig(0)), importing(false), temporaryQtVersion(false)
+ {}
+
explicit BuildConfigurationInfo(QtVersion *v, QtVersion::QmakeBuildConfigs bc,
- const QString &aa, const QString &d) :
- version(v), buildConfig(bc), additionalArguments(aa), directory(d)
+ const QString &aa, const QString &d, bool importing_ = false, bool temporaryQtVersion_ = false) :
+ version(v), buildConfig(bc), additionalArguments(aa), directory(d), importing(importing_), temporaryQtVersion(temporaryQtVersion_)
{ }
+
+ bool isValid() const
+ {
+ return version != 0;
+ }
+
QtVersion *version;
QtVersion::QmakeBuildConfigs buildConfig;
QString additionalArguments;
QString directory;
+ bool importing;
+ bool temporaryQtVersion;
+
+
+ static QList<BuildConfigurationInfo> importBuildConfigurations(const QString &proFilePath);
+ static BuildConfigurationInfo checkForBuild(const QString &directory, const QString &proFilePath);
+ static QList<BuildConfigurationInfo> filterBuildConfigurationInfos(const QList<BuildConfigurationInfo> &infos, const QString &id);
};
class Qt4BaseTarget : public ProjectExplorer::Target
@@ -101,6 +131,21 @@ private slots:
void emitProFileEvaluateNeeded();
};
+class QT4PROJECTMANAGER_EXPORT Qt4TargetSetupWidget : public QWidget
+{
+ Q_OBJECT
+public:
+ Qt4TargetSetupWidget();
+ ~Qt4TargetSetupWidget();
+ virtual bool isTargetSelected() const = 0;
+ virtual void setTargetSelected(bool b) = 0;
+ virtual void setProFilePath(const QString &proFilePath) = 0;
+ virtual QList<BuildConfigurationInfo> usedImportInfos() = 0;
+signals:
+ void selectedToggled() const;
+ void newImportBuildConfiguration(const BuildConfigurationInfo &info);
+};
+
class QT4PROJECTMANAGER_EXPORT Qt4BaseTargetFactory : public ProjectExplorer::ITargetFactory
{
Q_OBJECT
@@ -108,23 +153,101 @@ public:
Qt4BaseTargetFactory(QObject *parent);
~Qt4BaseTargetFactory();
- virtual QString defaultShadowBuildDirectory(const QString &projectLocation, const QString &id) =0;
- virtual QList<BuildConfigurationInfo> availableBuildConfigurations(const QString &proFilePath) = 0;
-
- virtual Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id) = 0;
- virtual Qt4BaseTarget *create(ProjectExplorer::Project *parent,
- const QString &id,
- QList<BuildConfigurationInfo> infos) = 0;
+ virtual Qt4TargetSetupWidget *createTargetSetupWidget(const QString &id,
+ const QString &proFilePath,
+ const QtVersionNumber &minimumQtVersion,
+ bool importEnabled,
+ QList<BuildConfigurationInfo> importInfos);
+ virtual QString defaultShadowBuildDirectory(const QString &projectLocation, const QString &id) =0;
+ /// used by the default implementation of createTargetSetupWidget
+ /// not needed otherwise
+ virtual QList<BuildConfigurationInfo> availableBuildConfigurations(const QString &id, const QString &proFilePath, const QtVersionNumber &minimumQtVersion) = 0;
/// only used in the TargetSetupPage
virtual QIcon iconForId(const QString &id) const = 0;
+ virtual bool isMobileTarget(const QString &id) = 0;
+
+ virtual Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id) = 0;
+ virtual Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id, const QList<BuildConfigurationInfo> &infos) = 0;
+ virtual Qt4BaseTarget *create(ProjectExplorer::Project *parent, const QString &id, Qt4TargetSetupWidget *widget);
+
static Qt4BaseTargetFactory *qt4BaseTargetFactoryForId(const QString &id);
protected:
static QString msgBuildConfigurationName(const BuildConfigurationInfo &info);
};
+class Qt4DefaultTargetSetupWidget : public Qt4TargetSetupWidget
+{
+ Q_OBJECT
+public:
+ Qt4DefaultTargetSetupWidget(Qt4BaseTargetFactory *factory,
+ const QString &id,
+ const QString &proFilePath,
+ const QtVersionNumber &minimumQtVersion,
+ bool importEnabled,
+ QList<BuildConfigurationInfo> importInfos);
+ ~Qt4DefaultTargetSetupWidget();
+ bool isTargetSelected() const;
+ void setTargetSelected(bool b);
+ QList<BuildConfigurationInfo> usedImportInfos();
+
+ QList<BuildConfigurationInfo> buildConfigurationInfos() const;
+ void setProFilePath(const QString &proFilePath);
+
+ void setShadowBuildCheckBoxVisible(bool b);
+
+public slots:
+ void addImportClicked();
+ void checkBoxToggled(bool b);
+ void importCheckBoxToggled(bool b);
+ void pathChanged();
+ void shadowBuildingToggled();
+
+private:
+ void setBuildConfigurationInfos(const QList<BuildConfigurationInfo> &list, bool resetEnabled = true);
+ void reportIssues(int index);
+ QPair<ProjectExplorer::Task::TaskType, QString> findIssues(const BuildConfigurationInfo &info);
+ void createImportWidget(const BuildConfigurationInfo &info, int pos);
+
+ QString m_id;
+ Qt4BaseTargetFactory *m_factory;
+ QString m_proFilePath;
+ QtVersionNumber m_minimumQtVersion;
+ Utils::DetailsWidget *m_detailsWidget;
+ QGridLayout *m_importLayout;
+ QGridLayout *m_newBuildsLayout;
+ QCheckBox *m_shadowBuildEnabled;
+ QWidget *m_spacerTopWidget;
+ QWidget *m_spacerBottomWidget;
+
+ // import line widgets
+ QHBoxLayout *m_importLineLayout;
+ QLabel *m_importLineLabel;
+ Utils::PathChooser *m_importLinePath;
+ QPushButton *m_importLineButton;
+
+ void setupWidgets();
+ void clearWidgets();
+ void setupImportWidgets();
+ QString displayNameFrom(const BuildConfigurationInfo &info);
+ QList<QCheckBox *> m_checkboxes;
+ QList<Utils::PathChooser *> m_pathChoosers;
+ QList<BuildConfigurationInfo> m_infos;
+ QList<bool> m_enabled;
+ QList<QCheckBox *> m_importCheckBoxes;
+ QList<BuildConfigurationInfo> m_importInfos;
+ QList<bool> m_importEnabled;
+ QList<QLabel *> m_reportIssuesLabels;
+ bool m_directoriesEnabled;
+ bool m_hasInSourceBuild;
+ bool m_ignoreChange;
+ bool m_showImport;
+ int m_selected;
+
+};
+
} // namespace Qt4ProjectManager
#endif // QT4TARGET_H
diff --git a/src/plugins/qt4projectmanager/qtversionmanager.cpp b/src/plugins/qt4projectmanager/qtversionmanager.cpp
index 8132e2502f76f1eaeefe42debd24c7ccda43d10b..8cbe5961af3c4f4415e538c84a6c7b8ad4dc72d9 100644
--- a/src/plugins/qt4projectmanager/qtversionmanager.cpp
+++ b/src/plugins/qt4projectmanager/qtversionmanager.cpp
@@ -1377,16 +1377,6 @@ QSet<QString> QtVersion::supportedTargetIds() const
return m_targetIds;
}
-bool QtVersion::supportsMobileTarget() const
-{
- return supportsTargetId(Constants::S60_DEVICE_TARGET_ID) ||
- supportsTargetId(Constants::S60_EMULATOR_TARGET_ID) ||
- supportsTargetId(Constants::MAEMO5_DEVICE_TARGET_ID) ||
- supportsTargetId(Constants::HARMATTAN_DEVICE_TARGET_ID) ||
- supportsTargetId(Constants::MEEGO_DEVICE_TARGET_ID) ||
- supportsTargetId(Constants::QT_SIMULATOR_TARGET_ID);
-}
-
QList<ProjectExplorer::Abi> QtVersion::qtAbis() const
{
updateAbiAndMkspec();
diff --git a/src/plugins/qt4projectmanager/qtversionmanager.h b/src/plugins/qt4projectmanager/qtversionmanager.h
index f8ca79ccf4e37f042b0d9c7b1128ad3224df923f..aa6f896370c8be1919fe47cb7542616bfe860084 100644
--- a/src/plugins/qt4projectmanager/qtversionmanager.h
+++ b/src/plugins/qt4projectmanager/qtversionmanager.h
@@ -110,7 +110,6 @@ public:
bool supportsTargetId(const QString &id) const;
QSet<QString> supportedTargetIds() const;
- bool supportsMobileTarget() const;
QList<ProjectExplorer::Abi> qtAbis() const;
diff --git a/src/plugins/qt4projectmanager/wizards/abstractmobileappwizard.cpp b/src/plugins/qt4projectmanager/wizards/abstractmobileappwizard.cpp
index 1ccb3c063cd07642d4aff4ba4467a4f9ab7f3490..4cb1a3c8463975a376b8a746c7ebe0d9bcbe8fc7 100644
--- a/src/plugins/qt4projectmanager/wizards/abstractmobileappwizard.cpp
+++ b/src/plugins/qt4projectmanager/wizards/abstractmobileappwizard.cpp
@@ -54,8 +54,9 @@ AbstractMobileAppWizardDialog::AbstractMobileAppWizardDialog(QWidget *parent)
: ProjectExplorer::BaseProjectWizardDialog(parent)
{
m_targetsPage = new TargetSetupPage;
+ m_targetsPage->setPreferMobile(true);
+ m_targetsPage->setMinimumQtVersion(QtVersionNumber(4,7,0));
resize(900, 450);
- m_targetsPage->setImportDirectoryBrowsingEnabled(false);
m_targetsPageId = addPageWithTitle(m_targetsPage, tr("Qt Versions"));
m_genericOptionsPage = new MobileAppWizardGenericOptionsPage;
m_genericOptionsPageId = addPageWithTitle(m_genericOptionsPage,
diff --git a/src/plugins/qt4projectmanager/wizards/html5appwizard.cpp b/src/plugins/qt4projectmanager/wizards/html5appwizard.cpp
index 2afece5bc498bf8e3fb7b20891ce2b355880f804..495203083fcf6c639efaf4e0664224a4beea74ca 100644
--- a/src/plugins/qt4projectmanager/wizards/html5appwizard.cpp
+++ b/src/plugins/qt4projectmanager/wizards/html5appwizard.cpp
@@ -117,7 +117,7 @@ AbstractMobileAppWizardDialog *Html5AppWizard::createWizardDialogInternal(QWidge
void Html5AppWizard::projectPathChanged(const QString &path) const
{
- m_d->wizardDialog->m_targetsPage->setImportInfos(TargetSetupPage::importInfosForKnownQtVersions(path));
+ m_d->wizardDialog->m_targetsPage->setProFilePath(path);
}
void Html5AppWizard::prepareGenerateFiles(const QWizard *w,
diff --git a/src/plugins/qt4projectmanager/wizards/mobileappwizard.cpp b/src/plugins/qt4projectmanager/wizards/mobileappwizard.cpp
index ac6407e1beda57330e0cb2ab317ae38afa40e492..3bbb12e2fcca9a70ab747330d87e5d082d199464 100644
--- a/src/plugins/qt4projectmanager/wizards/mobileappwizard.cpp
+++ b/src/plugins/qt4projectmanager/wizards/mobileappwizard.cpp
@@ -109,7 +109,7 @@ AbstractMobileAppWizardDialog *MobileAppWizard::createWizardDialogInternal(QWidg
void MobileAppWizard::projectPathChanged(const QString &path) const
{
- m_d->wizardDialog->m_targetsPage->setImportInfos(TargetSetupPage::importInfosForKnownQtVersions(path));
+ m_d->wizardDialog->m_targetsPage->setProFilePath(path);
}
void MobileAppWizard::prepareGenerateFiles(const QWizard *w,
diff --git a/src/plugins/qt4projectmanager/wizards/qtquickappwizard.cpp b/src/plugins/qt4projectmanager/wizards/qtquickappwizard.cpp
index b3b5f31df48b26b85e60743711bfc9abae6eb0a6..04204fccf2f6c44b0b02337d95704efcd48be38e 100644
--- a/src/plugins/qt4projectmanager/wizards/qtquickappwizard.cpp
+++ b/src/plugins/qt4projectmanager/wizards/qtquickappwizard.cpp
@@ -117,21 +117,7 @@ AbstractMobileAppWizardDialog *QtQuickAppWizard::createWizardDialogInternal(QWid
void QtQuickAppWizard::projectPathChanged(const QString &path) const
{
- const QList<TargetSetupPage::ImportInfo> &qtVersions
- = TargetSetupPage::importInfosForKnownQtVersions(path);
- QList<TargetSetupPage::ImportInfo> qmlQtVersions;
- foreach (const TargetSetupPage::ImportInfo &qtVersion, qtVersions) {
- const QString versionString = qtVersion.version->qtVersionString();
- bool isNumber;
- const int majorVersion = versionString.mid(0, 1).toInt(&isNumber);
- if (!isNumber || majorVersion < 4)
- continue;
- const int minorVersion = versionString.mid(2, 1).toInt(&isNumber);
- if (!isNumber || (majorVersion == 4 && minorVersion < 7))
- continue;
- qmlQtVersions << qtVersion;
- }
- m_d->wizardDialog->m_targetsPage->setImportInfos(qmlQtVersions);
+ m_d->wizardDialog->m_targetsPage->setProFilePath(path);
}
void QtQuickAppWizard::prepareGenerateFiles(const QWizard *w,
diff --git a/src/plugins/qt4projectmanager/wizards/qtwizard.cpp b/src/plugins/qt4projectmanager/wizards/qtwizard.cpp
index dc7a3a53f066d63c3d7b7ea1f784800171ce194e..9f2815572e218732e0506c8f731998b3575c815d 100644
--- a/src/plugins/qt4projectmanager/wizards/qtwizard.cpp
+++ b/src/plugins/qt4projectmanager/wizards/qtwizard.cpp
@@ -240,25 +240,13 @@ int BaseQt4ProjectWizardDialog::addTargetSetupPage(QSet<QString> targets, bool m
m_targets = targets;
resize(900, 450);
- connect(this, SIGNAL(projectLocationChanged(QString)),
- m_targetSetupPage, SLOT(setProFilePath(QString)));
-
- QList<TargetSetupPage::ImportInfo> infos = TargetSetupPage::importInfosForKnownQtVersions(path());
- if (!targets.isEmpty())
- infos = TargetSetupPage::filterImportInfos(targets, infos);
- m_targetSetupPage->setImportDirectoryBrowsingEnabled(false);
m_targetSetupPage->setPreferMobile(mobile);
- if (infos.count() <= 1)
- return -1;
-
- m_targetSetupPage->setImportInfos(infos);
-
if (id >= 0)
setPage(id, m_targetSetupPage);
else
id = addPage(m_targetSetupPage);
- wizardProgress()->item(id)->setTitle(tr("Qt Versions"));
+ wizardProgress()->item(id)->setTitle(tr("Targets"));
return id;
}
@@ -324,11 +312,7 @@ bool BaseQt4ProjectWizardDialog::isTargetSelected(const QString &targetid) const
void BaseQt4ProjectWizardDialog::generateProfileName(const QString &name, const QString &path)
{
const QString proFile = QDir::fromNativeSeparators(path) + QChar('/') + name + QChar('/') + name + QLatin1String(".pro");
- QList<TargetSetupPage::ImportInfo> infos = TargetSetupPage::importInfosForKnownQtVersions(proFile);
- if (!m_targets.isEmpty())
- infos = TargetSetupPage::filterImportInfos(m_targets, infos);
- m_targetSetupPage->setImportInfos(infos);
- emit projectLocationChanged(proFile);
+ m_targetSetupPage->setProFilePath(proFile);
}
QSet<QString> BaseQt4ProjectWizardDialog::desktopTarget()
diff --git a/src/plugins/qt4projectmanager/wizards/qtwizard.h b/src/plugins/qt4projectmanager/wizards/qtwizard.h
index a0a507bee2e2718c6f9febbab872a82b88d648dd..0177b02b6b995a6c0bed6a92d76b1bd5dd59be51 100644
--- a/src/plugins/qt4projectmanager/wizards/qtwizard.h
+++ b/src/plugins/qt4projectmanager/wizards/qtwizard.h
@@ -146,9 +146,6 @@ public:
bool setupProject(Qt4Project *project) const;
bool isTargetSelected(const QString &targetid) const;
-signals:
- void projectLocationChanged(const QString &proFileName);
-
private slots:
void generateProfileName(const QString &name, const QString &path);
diff --git a/src/plugins/qt4projectmanager/wizards/targetsetuppage.cpp b/src/plugins/qt4projectmanager/wizards/targetsetuppage.cpp
index 5bd3daa712131f5ac267939fff3d770fd3ce560b..9d8b05ac4c349764138c2455c6c8c5562ddd7ea8 100644
--- a/src/plugins/qt4projectmanager/wizards/targetsetuppage.cpp
+++ b/src/plugins/qt4projectmanager/wizards/targetsetuppage.cpp
@@ -46,245 +46,163 @@
#include <utils/qtcassert.h>
#include <utils/qtcprocess.h>
-#include <QtGui/QAction>
-#include <QtGui/QFileDialog>
-#include <QtGui/QHeaderView>
#include <QtGui/QLabel>
#include <QtGui/QLayout>
-#include <QtGui/QMenu>
-#include <QtGui/QMessageBox>
-#include <QtGui/QPushButton>
-#include <QtGui/QTreeWidget>
using namespace Qt4ProjectManager;
using namespace Qt4ProjectManager::Internal;
-namespace {
-enum Columns {
- NAME_COLUMN = 0,
- STATUS_COLUMN,
- DIRECTORY_COLUMN
-};
-} // namespace
-
TargetSetupPage::TargetSetupPage(QWidget *parent) :
QWizardPage(parent),
m_preferMobile(false),
- m_toggleWillCheck(false),
- m_ui(new Ui::TargetSetupPage),
- m_contextMenu(0)
+ m_importSearch(false),
+ m_spacer(new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding)),
+ m_ui(new Ui::TargetSetupPage)
{
m_ui->setupUi(this);
- m_ui->versionTree->header()->setResizeMode(0, QHeaderView::ResizeToContents);
- m_ui->versionTree->header()->setResizeMode(1, QHeaderView::ResizeToContents);
-
- m_ui->versionTree->setContextMenuPolicy(Qt::CustomContextMenu);
- m_contextMenu = new QMenu(this);
-
- connect(m_ui->importButton, SIGNAL(clicked()),
- this, SLOT(addShadowBuildLocation()));
- connect(m_ui->uncheckButton, SIGNAL(clicked()),
- this, SLOT(checkAllButtonClicked()));
- connect(m_ui->versionTree, SIGNAL(customContextMenuRequested(QPoint)),
- this, SLOT(contextMenuRequested(QPoint)));
+ QWidget *centralWidget = new QWidget(this);
+ m_ui->scrollArea->setWidget(centralWidget);
+ m_layout = new QVBoxLayout;
+ centralWidget->setLayout(m_layout);
+ m_layout->addSpacerItem(m_spacer);
- setTitle(tr("Qt Versions"));
+ setTitle(tr("Target setup"));
}
void TargetSetupPage::initializePage()
{
- // WORKAROUND: Somebody sets all buttons to autoDefault between the ctor and here!
- m_ui->importButton->setAutoDefault(false);
- m_ui->uncheckButton->setAutoDefault(false);
+ cleanupImportInfos();
+ deleteWidgets();
+
+ setupImportInfos();
+ setupWidgets();
}
TargetSetupPage::~TargetSetupPage()
{
- resetInfos();
+ deleteWidgets();
delete m_ui;
+ cleanupImportInfos();
}
-void TargetSetupPage::setImportInfos(const QList<ImportInfo> &infos)
+bool TargetSetupPage::isTargetSelected(const QString &id) const
{
- disconnect(m_ui->versionTree, SIGNAL(itemChanged(QTreeWidgetItem*,int)),
- this, SLOT(itemWasChanged()));
-
- // Create a list of all temporary Qt versions we need to delete in our existing list
- QList<QtVersion *> toDelete;
- foreach (const ImportInfo &info, m_infos) {
- if (info.isTemporary)
- toDelete.append(info.version);
- }
- // Remove those that got copied into the new list to set up
- foreach (const ImportInfo &info, infos) {
- if (info.isTemporary)
- toDelete.removeAll(info.version);
- }
- // Delete the rest
- qDeleteAll(toDelete);
- // ... and clear the list
- m_infos.clear();
-
- // Find possible targets:
- QStringList targetIds;
- foreach (const ImportInfo &i, infos) {
- // Make sure we have no duplicate directories:
- bool skip = false;
- foreach (const ImportInfo &j, m_infos) {
- if (j.isExistingBuild && i.isExistingBuild && (j.directory == i.directory)) {
- skip = true;
- break;
- }
- }
- if (skip) {
- if (i.isTemporary)
- delete i.version;
- continue;
- }
+ Qt4TargetSetupWidget *widget = m_widgets.value(id);
+ return widget && widget->isTargetSelected();
+}
- m_infos.append(i);
+bool TargetSetupPage::isComplete() const
+{
+ foreach (Qt4TargetSetupWidget *widget, m_widgets)
+ if (widget->isTargetSelected())
+ return true;
+ return false;
+}
- QSet<QString> versionTargets = i.version->supportedTargetIds();
- foreach (const QString &t, versionTargets) {
- if (!targetIds.contains(t))
- targetIds.append(t);
- }
- }
- qSort(targetIds.begin(), targetIds.end());
+void TargetSetupPage::setPreferMobile(bool mobile)
+{
+ m_preferMobile = mobile;
+}
- m_ui->versionTree->clear();
+void TargetSetupPage::setMinimumQtVersion(const QtVersionNumber &number)
+{
+ m_minimumQtVersionNumber = number;
+}
- foreach (const QString &targetId, targetIds) {
- QTreeWidgetItem *targetItem = new QTreeWidgetItem(m_ui->versionTree);
+void TargetSetupPage::setImportSearch(bool b)
+{
+ m_importSearch = b;
+}
- Qt4BaseTargetFactory *factory = 0;
- QList<Qt4BaseTargetFactory *> factories =
- ExtensionSystem::PluginManager::instance()->getObjects<Qt4BaseTargetFactory>();
- foreach (Qt4BaseTargetFactory *fac, factories) {
- if (fac->supportsTargetId(targetId)) {
- factory = fac;
- break;
+void TargetSetupPage::setupWidgets()
+{
+ QList<Qt4BaseTargetFactory *> factories = ExtensionSystem::PluginManager::instance()->getObjects<Qt4BaseTargetFactory>();
+ foreach (Qt4BaseTargetFactory *factory, factories) {
+ QStringList ids = factory->supportedTargetIds(0);
+ foreach (const QString &id, ids) {
+ QList<BuildConfigurationInfo> infos = BuildConfigurationInfo::filterBuildConfigurationInfos(m_importInfos, id);
+ Qt4TargetSetupWidget *widget =
+ factory->createTargetSetupWidget(id, m_proFilePath, m_minimumQtVersionNumber, m_importSearch, infos);
+ if (widget) {
+ widget->setTargetSelected( (m_preferMobile == factory->isMobileTarget(id) && m_importInfos.isEmpty())
+ || !infos.isEmpty());
+ m_widgets.insert(id, widget);
+ m_factories.insert(widget, factory);
+ m_layout->addWidget(widget);
+ connect(widget, SIGNAL(selectedToggled()),
+ this, SIGNAL(completeChanged()));
+ connect(widget, SIGNAL(newImportBuildConfiguration(BuildConfigurationInfo)),
+ this, SLOT(newImportBuildConfiguration(BuildConfigurationInfo)));
}
}
- if (!factory)
- continue;
-
- QString displayName = factory->displayNameForId(targetId);
-
- targetItem->setText(0, displayName);
- targetItem->setToolTip(0, displayName);
- targetItem->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
- targetItem->setData(NAME_COLUMN, Qt::UserRole, targetId);
- targetItem->setExpanded(true);
-
- int pos = -1;
- foreach (const ImportInfo &i, m_infos) {
- ++pos;
-
- if (!i.version->supportsTargetId(targetId))
- continue;
- QTreeWidgetItem *versionItem = new QTreeWidgetItem(targetItem);
- updateVersionItem(versionItem, pos);
+ }
+ m_layout->addSpacerItem(m_spacer);
+}
- // Prefer imports to creating new builds, but precheck any
- // Qt that exists (if there is no import with that version)
- bool shouldCheck = true;
- if (!i.isExistingBuild) {
- foreach (const ImportInfo &j, m_infos) {
- if (j.isExistingBuild && j.version == i.version) {
- shouldCheck = false;
- break;
- }
- }
- }
+void TargetSetupPage::deleteWidgets()
+{
+ foreach (Qt4TargetSetupWidget *widget, m_widgets)
+ delete widget;
+ m_widgets.clear();
+ m_factories.clear();
+ m_layout->removeItem(m_spacer);
+}
- shouldCheck = shouldCheck && (m_preferMobile == i.version->supportsMobileTarget());
- shouldCheck = shouldCheck || i.isExistingBuild; // always check imports
- shouldCheck = shouldCheck || m_infos.count() == 1; // always check only option
- versionItem->setCheckState(NAME_COLUMN, shouldCheck ? Qt::Checked : Qt::Unchecked);
- }
+void TargetSetupPage::setProFilePath(const QString &path)
+{
+ m_proFilePath = path;
+ if (!m_proFilePath.isEmpty()) {
+ m_ui->descriptionLabel->setText(tr("Qt Creator can set up the following targets for project <b>%1</b>:",
+ "%1: Project name").arg(QFileInfo(m_proFilePath).baseName()));
}
- connect(m_ui->versionTree, SIGNAL(itemChanged(QTreeWidgetItem*,int)),
- this, SLOT(itemWasChanged()));
-
- emit completeChanged();
+ deleteWidgets();
+ setupWidgets();
}
-QList<TargetSetupPage::ImportInfo> TargetSetupPage::importInfos() const
+void TargetSetupPage::setupImportInfos()
{
- return m_infos;
+ if (m_importSearch)
+ m_importInfos = BuildConfigurationInfo::importBuildConfigurations(m_proFilePath);
}
-bool TargetSetupPage::hasSelection() const
+void TargetSetupPage::cleanupImportInfos()
{
- for (int i = 0; i < m_ui->versionTree->topLevelItemCount(); ++i) {
- QTreeWidgetItem * current = m_ui->versionTree->topLevelItem(i);
- for (int j = 0; j < current->childCount(); ++j) {
- QTreeWidgetItem * child = current->child(j);
- if (child->checkState(NAME_COLUMN) == Qt::Checked)
- return true;
- }
+ foreach (const BuildConfigurationInfo &info, m_importInfos) {
+ if (info.temporaryQtVersion)
+ delete info.version;
}
- return false;
}
-bool TargetSetupPage::isTargetSelected(const QString &targetid) const
+void TargetSetupPage::newImportBuildConfiguration(const BuildConfigurationInfo &info)
{
- for (int i = 0; i < m_ui->versionTree->topLevelItemCount(); ++i) {
- QTreeWidgetItem * current = m_ui->versionTree->topLevelItem(i);
- if (current->data(NAME_COLUMN, Qt::UserRole).toString() != targetid)
- continue;
- for (int j = 0; j < current->childCount(); ++j) {
- QTreeWidgetItem * child = current->child(j);
- if (child->checkState(NAME_COLUMN) == Qt::Checked)
- return true;
- }
- }
- return false;
+ m_importInfos.append(info);
}
bool TargetSetupPage::setupProject(Qt4ProjectManager::Qt4Project *project)
{
- Q_ASSERT(project->targets().isEmpty());
- QtVersionManager *vm = QtVersionManager::instance();
- for (int i = 0; i < m_ui->versionTree->topLevelItemCount(); ++i) {
- QTreeWidgetItem *current = m_ui->versionTree->topLevelItem(i);
- QString targetId = current->data(NAME_COLUMN, Qt::UserRole).toString();
-
- Qt4BaseTargetFactory *qt4TargetFactory = Qt4BaseTargetFactory::qt4BaseTargetFactoryForId(targetId);
- if (qt4TargetFactory && qt4TargetFactory->canCreate(project, targetId)) {
- QList<BuildConfigurationInfo> targetInfos;
- for (int j = 0; j < current->childCount(); ++j) {
- QTreeWidgetItem *child = current->child(j);
- if (child->checkState(0) != Qt::Checked)
- continue;
- ImportInfo &info = m_infos[child->data(0, Qt::UserRole).toInt()];
-
- // Register temporary Qt version
- if (info.isTemporary) {
- vm->addVersion(info.version);
- info.isTemporary = false;
+ QMap<QString, Qt4TargetSetupWidget *>::const_iterator it, end;
+ end = m_widgets.constEnd();
+ it = m_widgets.constBegin();
+ for ( ; it != end; ++it) {
+ Qt4BaseTargetFactory *factory = m_factories.value(it.value());
+
+ foreach (const BuildConfigurationInfo &info, it.value()->usedImportInfos()) {
+ QtVersion *version = info.version;
+ for (int i=0; i < m_importInfos.size(); ++i) {
+ if (m_importInfos.at(i).version == version) {
+ if (m_importInfos[i].temporaryQtVersion) {
+ QtVersionManager::instance()->addVersion(m_importInfos[i].version);
+ m_importInfos[i].temporaryQtVersion = false;
+ }
}
-
- targetInfos.append(BuildConfigurationInfo(info.version, info.buildConfig,
- info.additionalArguments, info.directory));
- }
-
- // create the target:
- Qt4BaseTarget *target = 0;
- if (!targetInfos.isEmpty()) {
- target = qt4TargetFactory->create(project, targetId, targetInfos);
- }
-
- if (target) {
- project->addTarget(target);
- if (target->id() == QLatin1String(Constants::QT_SIMULATOR_TARGET_ID))
- project->setActiveTarget(target);
}
}
- }
+ Qt4BaseTarget *target = factory->create(project, it.key(), it.value());
+ if (target)
+ project->addTarget(target);
+ }
// Create a desktop target if nothing else was set up:
if (project->targets().isEmpty()) {
@@ -315,346 +233,3 @@ bool TargetSetupPage::setupProject(Qt4ProjectManager::Qt4Project *project)
return !project->targets().isEmpty();
}
-
-void TargetSetupPage::itemWasChanged()
-{
- emit completeChanged();
-}
-
-bool TargetSetupPage::isComplete() const
-{
- return hasSelection();
-}
-
-void TargetSetupPage::setImportDirectoryBrowsingEnabled(bool browsing)
-{
- m_ui->importButton->setEnabled(browsing);
- m_ui->importButton->setVisible(browsing);
-}
-
-void TargetSetupPage::setImportDirectoryBrowsingLocation(const QString &directory)
-{
- m_defaultShadowBuildLocation = directory;
-}
-
-void TargetSetupPage::setPreferMobile(bool mobile)
-{
- m_preferMobile = mobile;
-}
-
-void TargetSetupPage::setProFilePath(const QString &path)
-{
- m_proFilePath = path;
- if (!m_proFilePath.isEmpty()) {
- m_ui->descriptionLabel->setText(tr("Qt Creator can set up the following targets for<br>project <b>%1</b>:",
- "%1: Project name").arg(QFileInfo(m_proFilePath).baseName()));
- }
- // Force regeneration of tree widget contents:
- QList<ImportInfo> tmp = m_infos;
- setImportInfos(tmp);
-}
-
-QList<TargetSetupPage::ImportInfo> TargetSetupPage::importInfosForKnownQtVersions(const QString &proFilePath)
-{
- QList<Qt4BaseTargetFactory *> factories =
- ExtensionSystem::PluginManager::instance()->getObjects<Qt4BaseTargetFactory>();
-
- QList<BuildConfigurationInfo> bcinfos;
-
- foreach (Qt4BaseTargetFactory *fac, factories)
- bcinfos.append(fac->availableBuildConfigurations(proFilePath));
-
- QList<ImportInfo> infos;
- foreach (const BuildConfigurationInfo &info, bcinfos) {
- infos.append(ImportInfo(info));
- }
-
- if (infos.isEmpty()) {
- // Fallback to the Qt in Path version
- ImportInfo info;
- info.isExistingBuild = false;
- info.isTemporary = false;
- info.version = QtVersionManager::instance()->versions().at(0);
- info.buildConfig = info.version->defaultBuildConfig();
- infos.append(info);
- }
- return infos;
-}
-
-QList<TargetSetupPage::ImportInfo> TargetSetupPage::filterImportInfos(const QSet<QString> &validTargets,
- const QList<ImportInfo> &infos)
-{
- QList<ImportInfo> results;
- foreach (const ImportInfo &info, infos) {
- Q_ASSERT(info.version);
- foreach (const QString &target, validTargets) {
- if (info.version->supportsTargetId(target))
- results.append(info);
- }
- }
- return results;
-}
-
-QList<TargetSetupPage::ImportInfo>
-TargetSetupPage::scanDefaultProjectDirectories(Qt4ProjectManager::Qt4Project *project)
-{
- // Source directory:
- QList<ImportInfo> importVersions = TargetSetupPage::recursivelyCheckDirectoryForBuild(project->projectDirectory(),
- project->file()->fileName());
- QtVersionManager *vm = QtVersionManager::instance();
- foreach(const QString &id, vm->supportedTargetIds()) {
- Qt4BaseTargetFactory *qt4Factory = Qt4BaseTargetFactory::qt4BaseTargetFactoryForId(id);
- QString location = qt4Factory->defaultShadowBuildDirectory(project->defaultTopLevelBuildDirectory(), id);
- importVersions.append(TargetSetupPage::recursivelyCheckDirectoryForBuild(location,
- project->file()->fileName()));
- }
- return importVersions;
-}
-
-QList<TargetSetupPage::ImportInfo>
-TargetSetupPage::recursivelyCheckDirectoryForBuild(const QString &directory, const QString &proFile, int maxdepth)
-{
- QList<ImportInfo> results;
-
- if (maxdepth <= 0 || directory.isEmpty())
- return results;
-
- // Check for in-source builds first:
- QString qmakeBinary = QtVersionManager::findQMakeBinaryFromMakefile(directory + "/Makefile");
- QDir dir(directory);
-
- // Recurse into subdirectories:
- if (qmakeBinary.isNull() || !QtVersionManager::makefileIsFor(directory + "/Makefile", proFile)) {
- QStringList subDirs = dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
- foreach (QString subDir, subDirs)
- results.append(recursivelyCheckDirectoryForBuild(dir.absoluteFilePath(subDir),
- proFile, maxdepth - 1));
- return results;
- }
-
- // Shiny fresh directory with a Makefile...
- QtVersionManager * vm = QtVersionManager::instance();
- TargetSetupPage::ImportInfo info;
- info.directory = dir.absolutePath();
-
- // This also means we have a build in there
- // First get the qt version
- info.version = vm->qtVersionForQMakeBinary(qmakeBinary);
- info.isExistingBuild = true;
-
- // Okay does not yet exist, create
- if (!info.version) {
- info.version = new QtVersion(qmakeBinary);
- info.isTemporary = true;
- }
-
- QPair<QtVersion::QmakeBuildConfigs, QString> result =
- QtVersionManager::scanMakeFile(directory + "/Makefile", info.version->defaultBuildConfig());
- info.buildConfig = result.first;
- QString aa = result.second;
- QString parsedSpec = Qt4BuildConfiguration::extractSpecFromArguments(&aa, directory, info.version);
- QString versionSpec = info.version->mkspec();
-
- // Compare mkspecs and add to additional arguments
- if (parsedSpec.isEmpty() || parsedSpec == versionSpec || parsedSpec == "default") {
- // using the default spec, don't modify additional arguments
- } else {
- info.additionalArguments = "-spec " + Utils::QtcProcess::quoteArg(parsedSpec);
- }
- Utils::QtcProcess::addArgs(&info.additionalArguments, aa);
-
- results.append(info);
- return results;
-}
-
-void TargetSetupPage::addShadowBuildLocation()
-{
- QString newPath =
- QFileDialog::getExistingDirectory(this,
- tr("Choose a directory to scan for additional shadow builds"),
- m_defaultShadowBuildLocation);
-
- if (newPath.isEmpty())
- return;
-
- QFileInfo dir(QDir::fromNativeSeparators(newPath));
- if (!dir.exists() || !dir.isDir())
- return;
-
- QList<ImportInfo> tmp;
- tmp.append(recursivelyCheckDirectoryForBuild(dir.absoluteFilePath(), m_proFilePath));
- if (tmp.isEmpty()) {
- QMessageBox::warning(this, tr("No builds found"),
- tr("No builds for project file \"%1\" were found in the folder \"%2\".",
- "%1: pro-file, %2: directory that was checked.").
- arg(m_proFilePath, dir.absoluteFilePath()));
- return;
- }
- tmp.append(m_infos);
- setImportInfos(tmp);
-}
-
-void TargetSetupPage::checkAll(bool checked)
-{
- for (int i = 0; i < m_ui->versionTree->topLevelItemCount(); ++i) {
- QTreeWidgetItem *current = m_ui->versionTree->topLevelItem(i);
- for (int j = 0; j < current->childCount(); ++j)
- checkOne(checked, current->child(j));
- }
-}
-
-void TargetSetupPage::checkOne(bool checked, QTreeWidgetItem *item)
-{
- Q_ASSERT(item->parent()); // we are a version item
- item->setCheckState(0, checked ? Qt::Checked : Qt::Unchecked);
-}
-
-void TargetSetupPage::checkAllButtonClicked()
-{
- checkAll(m_toggleWillCheck);
-
- m_toggleWillCheck = !m_toggleWillCheck;
- m_ui->uncheckButton->setText(m_toggleWillCheck ? tr("Check All") : tr("Uncheck All"));
- m_ui->uncheckButton->setToolTip(m_toggleWillCheck
- ? tr("Check all Qt versions") : tr("Uncheck all Qt versions"));
-}
-
-void TargetSetupPage::checkAllTriggered()
-{
- m_toggleWillCheck = true;
- checkAllButtonClicked();
-}
-
-void TargetSetupPage::uncheckAllTriggered()
-{
- m_toggleWillCheck = false;
- checkAllButtonClicked();
-}
-
-void TargetSetupPage::checkOneTriggered()
-{
- QAction * action = qobject_cast<QAction *>(sender());
- if (!action)
- return;
- QTreeWidgetItem *item = static_cast<QTreeWidgetItem *>(action->data().value<void *>());
- if (!item || !item->parent())
- return;
-
- checkAll(false);
- checkOne(true, item);
-}
-
-void TargetSetupPage::contextMenuRequested(const QPoint &position)
-{
- m_contextMenu->clear();
-
- QTreeWidgetItem *item = m_ui->versionTree->itemAt(position);
- m_contextMenu = new QMenu(this);
- if (item && item->parent()) {
- // Qt version item
- QAction *onlyThisAction = new QAction(tr("Check only this version"), m_contextMenu);
- connect(onlyThisAction, SIGNAL(triggered()), this, SLOT(checkOneTriggered()));
- onlyThisAction->setData(QVariant::fromValue(static_cast<void *>(item)));
- m_contextMenu->addAction(onlyThisAction);
-
- QAction *checkAllAction = new QAction(tr("Check all versions"), m_contextMenu);
- connect(checkAllAction, SIGNAL(triggered()), this, SLOT(checkAllTriggered()));
- m_contextMenu->addAction(checkAllAction);
-
- QAction *uncheckAllAction = new QAction(tr("Uncheck all versions"), m_contextMenu);
- connect(uncheckAllAction, SIGNAL(triggered()), this, SLOT(uncheckAllTriggered()));
- m_contextMenu->addAction(uncheckAllAction);
- }
- if (!m_contextMenu->isEmpty())
- m_contextMenu->popup(m_ui->versionTree->mapToGlobal(position));
-}
-
-void TargetSetupPage::resetInfos()
-{
- m_ui->versionTree->clear();
- foreach (const ImportInfo &info, m_infos) {
- if (info.isTemporary)
- delete info.version;
- }
- m_infos.clear();
-}
-
-QPair<QIcon, QString> TargetSetupPage::reportIssues(Qt4ProjectManager::QtVersion *version,
- const QString &buildDir)
-{
- if (m_proFilePath.isEmpty())
- return qMakePair(QIcon(), QString());
-
- const ProjectExplorer::TaskHub *taskHub = ExtensionSystem::PluginManager::instance()
- ->getObject<ProjectExplorer::TaskHub>();
- QTC_ASSERT(taskHub, return qMakePair(QIcon(), QString()));
-
- QList<ProjectExplorer::Task> issues = version->reportIssues(m_proFilePath, buildDir);
-
- QString text;
- QIcon icon;
- foreach (const ProjectExplorer::Task &t, issues) {
- if (!text.isEmpty())
- text.append(QLatin1String("<br>"));
- // set severity:
- QString severity;
- if (t.type == ProjectExplorer::Task::Error) {
- icon = taskHub->taskTypeIcon(t.type);
- severity = tr("<b>Error:</b> ", "Severity is Task::Error");
- } else if (t.type == ProjectExplorer::Task::Warning) {
- if (icon.isNull())
- icon = taskHub->taskTypeIcon(t.type);
- severity = tr("<b>Warning:</b> ", "Severity is Task::Warning");
- }
- text.append(severity + t.description);
- }
- if (!text.isEmpty())
- text = QLatin1String("<nobr>") + text;
- return qMakePair(icon, text);
-}
-
-void TargetSetupPage::updateVersionItem(QTreeWidgetItem *versionItem, int index)
-{
- ImportInfo &info = m_infos[index];
- QPair<QIcon, QString> issues = reportIssues(info.version, info.directory);
-
- //: We are going to build debug and release
- QString buildType = tr("debug and release");
- if ((info.buildConfig & QtVersion::BuildAll) == 0) {
- if (info.buildConfig & QtVersion::DebugBuild)
- //: Debug build
- buildType = tr("debug");
- else
- //: release build
- buildType = tr("release");
- }
-
- QString toolTip = info.version->displayName();
- //: %1: qmake used (incl. full path), %2: "debug", "release" or "debug and release"
- toolTip.append(tr("<br>using %1 (%2)").
- arg(QDir::toNativeSeparators(info.version->qmakeCommand())).
- arg(buildType));
- if (!issues.second.isEmpty())
- toolTip.append(QString::fromLatin1("<br><br>%1").arg(issues.second));
-
- // Column 0:
- versionItem->setToolTip(NAME_COLUMN, toolTip);
- versionItem->setIcon(NAME_COLUMN, issues.first);
- versionItem->setText(NAME_COLUMN, info.version->displayName() + " " + buildType);
- versionItem->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable);
- versionItem->setData(NAME_COLUMN, Qt::UserRole, index);
-
- // Column 1 (status):
- const QString status = info.isExistingBuild ?
- //: Is this an import of an existing build or a new one?
- tr("Import") :
- //: Is this an import of an existing build or a new one?
- tr("New");
- versionItem->setText(STATUS_COLUMN, status);
- versionItem->setToolTip(STATUS_COLUMN, status);
-
- // Column 2 (directory):
- Q_ASSERT(versionItem->parent());
- versionItem->setText(DIRECTORY_COLUMN, QDir::toNativeSeparators(info.directory));
- versionItem->setToolTip(DIRECTORY_COLUMN, QDir::toNativeSeparators(info.directory));
-}
diff --git a/src/plugins/qt4projectmanager/wizards/targetsetuppage.h b/src/plugins/qt4projectmanager/wizards/targetsetuppage.h
index 47b9c847b832963785ac16c48d017f507d71587b..d36b8e304bcf60bd9d2c5b2f2c51cb4e6d03d90a 100644
--- a/src/plugins/qt4projectmanager/wizards/targetsetuppage.h
+++ b/src/plugins/qt4projectmanager/wizards/targetsetuppage.h
@@ -37,20 +37,18 @@
#include "qt4target.h"
#include "qtversionmanager.h"
-#include <QtCore/QList>
-#include <QtCore/QPair>
-#include <QtCore/QSet>
#include <QtCore/QString>
-
-#include <QtGui/QIcon>
#include <QtGui/QWizard>
+
QT_BEGIN_NAMESPACE
class QLabel;
class QMenu;
class QPushButton;
+class QSpacerItem;
class QTreeWidget;
class QTreeWidgetItem;
+class QVBoxLayout;
QT_END_NAMESPACE
namespace Qt4ProjectManager {
@@ -67,97 +65,48 @@ class TargetSetupPage : public QWizardPage
Q_OBJECT
public:
- struct ImportInfo {
- ImportInfo() :
- version(0),
- isTemporary(false),
- buildConfig(QtVersion::QmakeBuildConfig(0)),
- isExistingBuild(false)
- {
- if (version && version->isValid())
- buildConfig = version->defaultBuildConfig();
- }
-
- ImportInfo(const BuildConfigurationInfo &source)
- : version(source.version),
- isTemporary(false),
- buildConfig(source.buildConfig),
- additionalArguments(source.additionalArguments),
- directory(source.directory),
- isExistingBuild(false)
- {}
-
- ImportInfo(const ImportInfo &other) :
- version(other.version),
- isTemporary(other.isTemporary),
- buildConfig(other.buildConfig),
- additionalArguments(other.additionalArguments),
- directory(other.directory),
- isExistingBuild(other.isExistingBuild)
- { }
-
- QtVersion *version;
- bool isTemporary;
- QtVersion::QmakeBuildConfigs buildConfig;
- QString additionalArguments;
- QString directory;
- bool isExistingBuild;
- };
-
explicit TargetSetupPage(QWidget* parent = 0);
~TargetSetupPage();
+ /// Initializes the TargetSetupPage
+ /// \note The import information is gathered in initializePage(), make sure that the right proFilePath is set before
void initializePage();
-
- void setImportInfos(const QList<ImportInfo> &infos);
- QList<ImportInfo> importInfos() const;
-
- void setImportDirectoryBrowsingEnabled(bool browsing);
- void setImportDirectoryBrowsingLocation(const QString &directory);
+ /// Changes the default set of checked targets. For mobile Symbian, maemo5, simulator is checked
+ /// For non mobile, destkop is checked
+ /// call this before \sa initializePage()
void setPreferMobile(bool mobile);
-
- static QList<ImportInfo> importInfosForKnownQtVersions(const QString &proFilePath);
- static QList<ImportInfo> filterImportInfos(const QSet<QString> &validTargets,
- const QList<ImportInfo> &infos);
-
- static QList<ImportInfo> scanDefaultProjectDirectories(Qt4Project *project);
- static QList<ImportInfo> recursivelyCheckDirectoryForBuild(const QString &directory,
- const QString &proFile, int maxdepth = 3);
-
- bool hasSelection() const;
- bool isTargetSelected(const QString &targetid) const;
+ /// Sets the minimum qt version
+ /// calls this before \sa initializePage()
+ void setMinimumQtVersion(const QtVersionNumber &number);
+ /// Sets whether the TargetSetupPage looks on disk for builds of this project
+ /// call this before \sa initializePage()
+ void setImportSearch(bool b);
bool isComplete() const;
-
- bool setupProject(Qt4Project *project);
-
-public slots:
+ bool setupProject(Qt4ProjectManager::Qt4Project *project);
+ bool isTargetSelected(const QString &id) const;
void setProFilePath(const QString &dir);
- void checkAll(bool checked);
- void checkOne(bool, QTreeWidgetItem *);
private slots:
- void itemWasChanged();
- void checkAllButtonClicked();
- void checkAllTriggered();
- void uncheckAllTriggered();
- void checkOneTriggered();
- void addShadowBuildLocation();
- void contextMenuRequested(const QPoint & pos);
+ void newImportBuildConfiguration(const BuildConfigurationInfo &info);
private:
- void resetInfos();
- QPair<QIcon, QString> reportIssues(QtVersion *version, const QString &buildDir);
- void updateVersionItem(QTreeWidgetItem *, int);
+ void setupImportInfos();
+ void cleanupImportInfos();
+ void setupWidgets();
+ void deleteWidgets();
- QList<ImportInfo> m_infos;
bool m_preferMobile;
- bool m_toggleWillCheck;
+ bool m_importSearch;
+ QtVersionNumber m_minimumQtVersionNumber;
QString m_proFilePath;
QString m_defaultShadowBuildLocation;
+ QMap<QString, Qt4TargetSetupWidget *> m_widgets;
+ QHash<Qt4TargetSetupWidget *, Qt4BaseTargetFactory *> m_factories;
+ QVBoxLayout *m_layout;
+ QSpacerItem *m_spacer;
Ui::TargetSetupPage *m_ui;
-
- QMenu *m_contextMenu;
+ QList<BuildConfigurationInfo> m_importInfos;
};
} // namespace Internal
diff --git a/src/plugins/qt4projectmanager/wizards/targetsetuppage.ui b/src/plugins/qt4projectmanager/wizards/targetsetuppage.ui
index 4acbc47318401d91f27593917b438ead54d1d612..033c8ea4456b54a78bb541489757f36eaa8610f9 100644
--- a/src/plugins/qt4projectmanager/wizards/targetsetuppage.ui
+++ b/src/plugins/qt4projectmanager/wizards/targetsetuppage.ui
@@ -51,67 +51,26 @@
</property>
</spacer>
</item>
- <item>
- <widget class="QPushButton" name="uncheckButton">
- <property name="toolTip">
- <string>Uncheck all Qt versions</string>
- </property>
- <property name="text">
- <string>Uncheck All</string>
- </property>
- </widget>
- </item>
</layout>
</item>
<item>
- <widget class="QTreeWidget" name="versionTree">
- <property name="columnCount">
- <number>3</number>
+ <widget class="QScrollArea" name="scrollArea">
+ <property name="widgetResizable">
+ <bool>true</bool>
</property>
- <column>
- <property name="text">
- <string>Qt Version</string>
- </property>
- </column>
- <column>
- <property name="text">
- <string>Status</string>
+ <widget class="QWidget" name="scrollAreaWidgetContents">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>541</width>
+ <height>415</height>
+ </rect>
</property>
- </column>
- <column>
- <property name="text">
- <string>Build Directory</string>
- </property>
- </column>
+ <layout class="QVBoxLayout" name="verticalLayout_2"/>
+ </widget>
</widget>
</item>
- <item>
- <layout class="QHBoxLayout" name="horizontalLayout">
- <item>
- <widget class="QPushButton" name="importButton">
- <property name="text">
- <string>Import Existing Shadow Build...</string>
- </property>
- <property name="flat">
- <bool>false</bool>
- </property>
- </widget>
- </item>
- <item>
- <spacer name="horizontalSpacer">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>40</width>
- <height>0</height>
- </size>
- </property>
- </spacer>
- </item>
- </layout>
- </item>
</layout>
</widget>
<resources/>