diff --git a/src/plugins/cmakeprojectmanager/cmakebuildenvironmentwidget.cpp b/src/plugins/cmakeprojectmanager/cmakebuildenvironmentwidget.cpp
index 22daabf9de76977b5c584b99c826e29376cea702..76afbc4ac520c670a7de9be1f6a9a5fae7a1ee03 100644
--- a/src/plugins/cmakeprojectmanager/cmakebuildenvironmentwidget.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakebuildenvironmentwidget.cpp
@@ -69,16 +69,17 @@ QString CMakeBuildEnvironmentWidget::displayName() const
return tr("Build Environment");
}
-void CMakeBuildEnvironmentWidget::init(const QString &buildConfiguration)
+void CMakeBuildEnvironmentWidget::init(const QString &buildConfigurationName)
{
if (debug)
qDebug() << "Qt4BuildConfigWidget::init()";
- m_buildConfiguration = buildConfiguration;
+ m_buildConfiguration = buildConfigurationName;
- m_clearSystemEnvironmentCheckBox->setChecked(!m_pro->useSystemEnvironment(buildConfiguration));
- m_buildEnvironmentWidget->setBaseEnvironment(m_pro->baseEnvironment(buildConfiguration));
- m_buildEnvironmentWidget->setUserChanges(m_pro->userEnvironmentChanges(buildConfiguration));
+ ProjectExplorer::BuildConfiguration *bc = m_pro->buildConfiguration(buildConfigurationName);
+ m_clearSystemEnvironmentCheckBox->setChecked(!m_pro->useSystemEnvironment(bc));
+ m_buildEnvironmentWidget->setBaseEnvironment(m_pro->baseEnvironment(bc));
+ m_buildEnvironmentWidget->setUserChanges(m_pro->userEnvironmentChanges(bc));
m_buildEnvironmentWidget->updateButtons();
}
@@ -89,6 +90,7 @@ void CMakeBuildEnvironmentWidget::environmentModelUserChangesUpdated()
void CMakeBuildEnvironmentWidget::clearSystemEnvironmentCheckBoxClicked(bool checked)
{
- m_pro->setUseSystemEnvironment(m_buildConfiguration, !checked);
- m_buildEnvironmentWidget->setBaseEnvironment(m_pro->baseEnvironment(m_buildConfiguration));
+ ProjectExplorer::BuildConfiguration *bc = m_pro->buildConfiguration(m_buildConfiguration);
+ m_pro->setUseSystemEnvironment(bc, !checked);
+ m_buildEnvironmentWidget->setBaseEnvironment(m_pro->baseEnvironment(bc));
}
diff --git a/src/plugins/cmakeprojectmanager/cmakeproject.cpp b/src/plugins/cmakeprojectmanager/cmakeproject.cpp
index 88d7ab13e59c31637016c8543274339497ce0fbb..8ed13b3a6d7d282d9c236f7a7d0fe8d4616913ca 100644
--- a/src/plugins/cmakeprojectmanager/cmakeproject.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakeproject.cpp
@@ -48,9 +48,11 @@
#include <QtCore/QProcess>
#include <QtGui/QFormLayout>
#include <QtGui/QMainWindow>
+#include <QtGui/QInputDialog>
using namespace CMakeProjectManager;
using namespace CMakeProjectManager::Internal;
+using namespace ProjectExplorer;
using ProjectExplorer::Environment;
using ProjectExplorer::EnvironmentItem;
@@ -63,10 +65,77 @@ using ProjectExplorer::EnvironmentItem;
// Open Questions
// Who sets up the environment for cl.exe ? INCLUDEPATH and so on
+/*!
+ \class CMakeBuildConfigurationFactory
+*/
+CMakeBuildConfigurationFactory::CMakeBuildConfigurationFactory(CMakeProject *project)
+ : IBuildConfigurationFactory(project),
+ m_project(project)
+{
+}
+
+CMakeBuildConfigurationFactory::~CMakeBuildConfigurationFactory()
+{
+}
+
+QStringList CMakeBuildConfigurationFactory::availableCreationTypes() const
+{
+ return QStringList() << "Create";
+}
+
+QString CMakeBuildConfigurationFactory::displayNameForType(const QString &type) const
+{
+ return tr("Create");
+}
+
+QList<BuildConfiguration *> CMakeBuildConfigurationFactory::create(const QString &type) const
+{
+ QTC_ASSERT(type == "Create", return QList<BuildConfiguration*>());
+
+ //TODO configuration name should be part of the cmakeopenprojectwizard
+ bool ok;
+ QString buildConfigurationName = QInputDialog::getText(0,
+ tr("New configuration"),
+ tr("New Configuration Name:"),
+ QLineEdit::Normal,
+ QString(),
+ &ok);
+ if (!ok || buildConfigurationName.isEmpty())
+ return QList<BuildConfiguration *>();
+ BuildConfiguration *bc = new BuildConfiguration(buildConfigurationName);
+
+ // Default to all
+ //TODO the buildConfigurationName has not been made unique yet
+ if (m_project->targets().contains("all"))
+ m_project->makeStep()->setBuildTarget(buildConfigurationName, "all", true);
+
+ CMakeOpenProjectWizard copw(m_project->projectManager(),
+ m_project->sourceDirectory(),
+ m_project->buildDirectory(bc),
+ m_project->environment(bc));
+ if (copw.exec() != QDialog::Accepted) {
+ delete bc;
+ return QList<BuildConfiguration *>();
+ }
+ bc->setValue("buildDirectory", copw.buildDirectory());
+ bc->setValue("msvcVersion", copw.msvcVersion());
+ m_project->parseCMakeLists();
+ return QList<BuildConfiguration *>() << bc;
+}
+
+QList<BuildConfiguration *> CMakeBuildConfigurationFactory::createDefaultConfigurations() const
+{
+ return QList<BuildConfiguration *>() << new BuildConfiguration;
+}
+
+/*!
+ \class CMakeProject
+*/
CMakeProject::CMakeProject(CMakeManager *manager, const QString &fileName)
: m_manager(manager),
m_fileName(fileName),
+ m_buildConfigurationFactory(new CMakeBuildConfigurationFactory(this)),
m_rootNode(new CMakeProjectNode(m_fileName)),
m_toolChain(0),
m_insideFileChanged(false)
@@ -80,12 +149,18 @@ CMakeProject::~CMakeProject()
delete m_toolChain;
}
+IBuildConfigurationFactory *CMakeProject::buildConfigurationFactory() const
+{
+ return m_buildConfigurationFactory;
+}
+
void CMakeProject::slotActiveBuildConfiguration()
{
+ BuildConfiguration *activeBC = activeBuildConfiguration();
// Pop up a dialog asking the user to rerun cmake
QFileInfo sourceFileInfo(m_fileName);
- QString cbpFile = CMakeManager::findCbpFile(QDir(buildDirectory(activeBuildConfiguration())));
+ QString cbpFile = CMakeManager::findCbpFile(QDir(buildDirectory(activeBC)));
QFileInfo cbpFileFi(cbpFile);
CMakeOpenProjectWizard::Mode mode = CMakeOpenProjectWizard::Nothing;
if (!cbpFileFi.exists()) {
@@ -102,11 +177,11 @@ void CMakeProject::slotActiveBuildConfiguration()
if (mode != CMakeOpenProjectWizard::Nothing) {
CMakeOpenProjectWizard copw(m_manager,
sourceFileInfo.absolutePath(),
- buildDirectory(activeBuildConfiguration()),
+ buildDirectory(activeBC),
mode,
- environment(activeBuildConfiguration()));
+ environment(activeBC));
copw.exec();
- setValue(activeBuildConfiguration(), "msvcVersion", copw.msvcVersion());
+ activeBC->setValue("msvcVersion", copw.msvcVersion());
}
// reparse
parseCMakeLists();
@@ -133,7 +208,7 @@ void CMakeProject::updateToolChain(const QString &compiler)
newToolChain = ProjectExplorer::ToolChain::createGccToolChain("gcc");
#endif
} else if (compiler == "msvc8") {
- newToolChain = ProjectExplorer::ToolChain::createMSVCToolChain(value(activeBuildConfiguration(), "msvcVersion").toString(), false);
+ newToolChain = ProjectExplorer::ToolChain::createMSVCToolChain(activeBuildConfiguration()->value("msvcVersion").toString(), false);
} else {
// TODO other toolchains
qDebug()<<"Not implemented yet!!! Qt Creator doesn't know which toolchain to use for"<<compiler;
@@ -148,16 +223,16 @@ void CMakeProject::updateToolChain(const QString &compiler)
}
}
-ProjectExplorer::ToolChain *CMakeProject::toolChain(const QString &buildConfiguration) const
+ProjectExplorer::ToolChain *CMakeProject::toolChain(BuildConfiguration *configuration) const
{
- if (buildConfiguration != activeBuildConfiguration())
+ if (configuration != activeBuildConfiguration())
qWarning()<<"CMakeProject asked for toolchain of a not active buildconfiguration";
return m_toolChain;
}
-void CMakeProject::changeBuildDirectory(const QString &buildConfiguration, const QString &newBuildDirectory)
+void CMakeProject::changeBuildDirectory(BuildConfiguration *configuration, const QString &newBuildDirectory)
{
- setValue(buildConfiguration, "buildDirectory", newBuildDirectory);
+ configuration->setValue("buildDirectory", newBuildDirectory);
parseCMakeLists();
}
@@ -176,7 +251,7 @@ bool CMakeProject::parseCMakeLists()
CMakeCbpParser cbpparser;
// Parsing
//qDebug()<<"Parsing file "<<cbpFile;
- if (cbpparser.parseCbpFile(cbpFile)) {
+ if (cbpparser.parseCbpFile(cbpFile)) {
// ToolChain
updateToolChain(cbpparser.compilerName());
@@ -317,11 +392,11 @@ bool CMakeProject::parseCMakeLists()
return true;
}
-QString CMakeProject::buildParser(const QString &buildConfiguration) const
+QString CMakeProject::buildParser(BuildConfiguration *configuration) const
{
- Q_UNUSED(buildConfiguration)
+ Q_UNUSED(configuration)
// TODO this is actually slightly wrong, but do i care?
- // this should call toolchain(buildConfiguration)
+ // this should call toolchain(configuration)
if (!m_toolChain)
return QString::null;
if (m_toolChain->type() == ProjectExplorer::ToolChain::GCC
@@ -476,36 +551,37 @@ bool CMakeProject::isApplication() const
return true;
}
-ProjectExplorer::Environment CMakeProject::baseEnvironment(const QString &buildConfiguration) const
+ProjectExplorer::Environment CMakeProject::baseEnvironment(BuildConfiguration *configuration) const
{
- Environment env = useSystemEnvironment(buildConfiguration) ? Environment(QProcess::systemEnvironment()) : Environment();
+ Environment env = useSystemEnvironment(configuration) ? Environment(QProcess::systemEnvironment()) : Environment();
return env;
}
-ProjectExplorer::Environment CMakeProject::environment(const QString &buildConfiguration) const
+ProjectExplorer::Environment CMakeProject::environment(BuildConfiguration *configuration) const
{
- Environment env = baseEnvironment(buildConfiguration);
- env.modify(userEnvironmentChanges(buildConfiguration));
+ Environment env = baseEnvironment(configuration);
+ env.modify(userEnvironmentChanges(configuration));
return env;
}
-void CMakeProject::setUseSystemEnvironment(const QString &buildConfiguration, bool b)
+void CMakeProject::setUseSystemEnvironment(BuildConfiguration *configuration, bool b)
{
- if (b == useSystemEnvironment(buildConfiguration))
+ if (b == useSystemEnvironment(configuration))
return;
- setValue(buildConfiguration, "clearSystemEnvironment", !b);
- emit environmentChanged(buildConfiguration);
+ configuration->setValue("clearSystemEnvironment", !b);
+ emit environmentChanged(configuration->name());
}
-bool CMakeProject::useSystemEnvironment(const QString &buildConfiguration) const
+bool CMakeProject::useSystemEnvironment(BuildConfiguration *configuration) const
{
- bool b = !(value(buildConfiguration, "clearSystemEnvironment").isValid() && value(buildConfiguration, "clearSystemEnvironment").toBool());
+ bool b = !(configuration->value("clearSystemEnvironment").isValid() &&
+ configuration->value("clearSystemEnvironment").toBool());
return b;
}
-QList<ProjectExplorer::EnvironmentItem> CMakeProject::userEnvironmentChanges(const QString &buildConfig) const
+QList<ProjectExplorer::EnvironmentItem> CMakeProject::userEnvironmentChanges(BuildConfiguration *configuration) const
{
- return EnvironmentItem::fromStringList(value(buildConfig, "userEnvironmentChanges").toStringList());
+ return EnvironmentItem::fromStringList(configuration->value("userEnvironmentChanges").toStringList());
}
void CMakeProject::setUserEnvironmentChanges(const QString &buildConfig, const QList<ProjectExplorer::EnvironmentItem> &diff)
@@ -517,9 +593,9 @@ void CMakeProject::setUserEnvironmentChanges(const QString &buildConfig, const Q
emit environmentChanged(buildConfig);
}
-QString CMakeProject::buildDirectory(const QString &buildConfiguration) const
+QString CMakeProject::buildDirectory(BuildConfiguration *configuration) const
{
- QString buildDirectory = value(buildConfiguration, "buildDirectory").toString();
+ QString buildDirectory = configuration->value("buildDirectory").toString();
if (buildDirectory.isEmpty())
buildDirectory = sourceDirectory() + "/qtcreator-build";
return buildDirectory;
@@ -537,21 +613,21 @@ QList<ProjectExplorer::BuildConfigWidget*> CMakeProject::subConfigWidgets()
return list;
}
- bool CMakeProject::newBuildConfiguration(const QString &buildConfiguration)
- {
- // Default to all
- if (targets().contains("all"))
- makeStep()->setBuildTarget(buildConfiguration, "all", true);
-
- CMakeOpenProjectWizard copw(projectManager(), sourceDirectory(), buildDirectory(buildConfiguration), environment(buildConfiguration));
- if (copw.exec() == QDialog::Accepted) {
- setValue(buildConfiguration, "buildDirectory", copw.buildDirectory());
- setValue(buildConfiguration, "msvcVersion", copw.msvcVersion());
- parseCMakeLists();
- return true;
- }
- return false;
- }
+// bool CMakeProject::newBuildConfiguration(const QString &buildConfiguration)
+// {
+// // Default to all
+// if (targets().contains("all"))
+// makeStep()->setBuildTarget(buildConfiguration, "all", true);
+//
+// CMakeOpenProjectWizard copw(projectManager(), sourceDirectory(), buildDirectory(buildConfiguration), environment(buildConfiguration));
+// if (copw.exec() == QDialog::Accepted) {
+// setValue(buildConfiguration, "buildDirectory", copw.buildDirectory());
+// setValue(buildConfiguration, "msvcVersion", copw.msvcVersion());
+// parseCMakeLists();
+// return true;
+// }
+// return false;
+// }
ProjectExplorer::ProjectNode *CMakeProject::rootProjectNode() const
{
@@ -600,23 +676,25 @@ bool CMakeProject::restoreSettingsImpl(ProjectExplorer::PersistentSettingsReader
insertBuildStep(0, makeStep);
- addBuildConfiguration("all");
- setValue("all", "msvcVersion", copw.msvcVersion());
+ ProjectExplorer::BuildConfiguration *bc = new ProjectExplorer::BuildConfiguration("all");
+ addBuildConfiguration(bc);
+ setValue(bc->name(), "msvcVersion", copw.msvcVersion());
if (!copw.buildDirectory().isEmpty())
- setValue("all", "buildDirectory", copw.buildDirectory());
+ setValue(bc->name(), "buildDirectory", copw.buildDirectory());
//TODO save arguments somewhere copw.arguments()
MakeStep *cleanMakeStep = new MakeStep(this);
insertCleanStep(0, cleanMakeStep);
cleanMakeStep->setValue("clean", true);
- setActiveBuildConfiguration("all");
+ setActiveBuildConfiguration(bc);
} else {
// We have a user file, but we could still be missing the cbp file
// or simply run createXml with the saved settings
QFileInfo sourceFileInfo(m_fileName);
QStringList needToCreate;
QStringList needToUpdate;
- QString cbpFile = CMakeManager::findCbpFile(QDir(buildDirectory(activeBuildConfiguration())));
+ BuildConfiguration *activeBC = activeBuildConfiguration();
+ QString cbpFile = CMakeManager::findCbpFile(QDir(buildDirectory(activeBC)));
QFileInfo cbpFileFi(cbpFile);
CMakeOpenProjectWizard::Mode mode = CMakeOpenProjectWizard::Nothing;
@@ -628,11 +706,11 @@ bool CMakeProject::restoreSettingsImpl(ProjectExplorer::PersistentSettingsReader
if (mode != CMakeOpenProjectWizard::Nothing) {
CMakeOpenProjectWizard copw(m_manager,
sourceFileInfo.absolutePath(),
- buildDirectory(activeBuildConfiguration()),
+ buildDirectory(activeBC),
mode,
- environment(activeBuildConfiguration()));
+ environment(activeBC));
copw.exec();
- setValue(activeBuildConfiguration(), "msvcVersion", copw.msvcVersion());
+ activeBC->setValue("msvcVersion", copw.msvcVersion());
}
}
@@ -752,11 +830,12 @@ QString CMakeBuildSettingsWidget::displayName() const
return "CMake";
}
-void CMakeBuildSettingsWidget::init(const QString &buildConfiguration)
+void CMakeBuildSettingsWidget::init(const QString &buildConfigurationName)
{
- m_buildConfiguration = buildConfiguration;
- m_pathLineEdit->setText(m_project->buildDirectory(buildConfiguration));
- if (m_project->buildDirectory(buildConfiguration) == m_project->sourceDirectory())
+ m_buildConfiguration = buildConfigurationName;
+ BuildConfiguration *bc = m_project->buildConfiguration(buildConfigurationName);
+ m_pathLineEdit->setText(m_project->buildDirectory(bc));
+ if (m_project->buildDirectory(bc) == m_project->sourceDirectory())
m_changeButton->setEnabled(false);
else
m_changeButton->setEnabled(true);
@@ -764,13 +843,14 @@ void CMakeBuildSettingsWidget::init(const QString &buildConfiguration)
void CMakeBuildSettingsWidget::openChangeBuildDirectoryDialog()
{
+ BuildConfiguration *bc = m_project->buildConfiguration(m_buildConfiguration);
CMakeOpenProjectWizard copw(m_project->projectManager(),
m_project->sourceDirectory(),
- m_project->buildDirectory(m_buildConfiguration),
- m_project->environment(m_buildConfiguration));
+ m_project->buildDirectory(bc),
+ m_project->environment(bc));
if (copw.exec() == QDialog::Accepted) {
- m_project->changeBuildDirectory(m_buildConfiguration, copw.buildDirectory());
- m_pathLineEdit->setText(m_project->buildDirectory(m_buildConfiguration));
+ m_project->changeBuildDirectory(bc, copw.buildDirectory());
+ m_pathLineEdit->setText(m_project->buildDirectory(bc));
}
}
diff --git a/src/plugins/cmakeprojectmanager/cmakeproject.h b/src/plugins/cmakeprojectmanager/cmakeproject.h
index c9bbbfb903e5c175ffaf45650b5bf50a6e09b9f2..79b405e9f5f85c65f3e34208a262f3f04ec9bbb5 100644
--- a/src/plugins/cmakeprojectmanager/cmakeproject.h
+++ b/src/plugins/cmakeprojectmanager/cmakeproject.h
@@ -39,6 +39,7 @@
#include <projectexplorer/buildstep.h>
#include <projectexplorer/toolchain.h>
#include <projectexplorer/filewatcher.h>
+#include <projectexplorer/buildconfiguration.h>
#include <coreplugin/ifile.h>
#include <QtCore/QXmlStreamReader>
@@ -49,6 +50,7 @@ namespace CMakeProjectManager {
namespace Internal {
class CMakeFile;
+class CMakeBuildSettingsWidget;
struct CMakeTarget
{
@@ -60,7 +62,23 @@ struct CMakeTarget
void clear();
};
-class CMakeBuildSettingsWidget;
+class CMakeBuildConfigurationFactory : public ProjectExplorer::IBuildConfigurationFactory
+{
+ Q_OBJECT
+
+public:
+ CMakeBuildConfigurationFactory(CMakeProject *project);
+ ~CMakeBuildConfigurationFactory();
+
+ QStringList availableCreationTypes() const;
+ QString displayNameForType(const QString &type) const;
+
+ QList<ProjectExplorer::BuildConfiguration *> create(const QString &type) const;
+ QList<ProjectExplorer::BuildConfiguration *> createDefaultConfigurations() const;
+
+private:
+ CMakeProject *m_project;
+};
class CMakeProject : public ProjectExplorer::Project
{
@@ -73,6 +91,7 @@ public:
virtual QString name() const;
virtual Core::IFile *file() const;
+ virtual ProjectExplorer::IBuildConfigurationFactory *buildConfigurationFactory() const;
virtual CMakeManager *projectManager() const;
virtual QList<ProjectExplorer::Project *> dependsOn(); //NBS TODO implement dependsOn
@@ -80,47 +99,43 @@ public:
virtual bool isApplication() const;
//building environment
- ProjectExplorer::Environment environment(const QString &buildConfiguration) const;
- ProjectExplorer::Environment baseEnvironment(const QString &buildConfiguration) const;
+ ProjectExplorer::Environment environment(ProjectExplorer::BuildConfiguration *configuration) const;
+ ProjectExplorer::Environment baseEnvironment(ProjectExplorer::BuildConfiguration *configuration) const;
void setUserEnvironmentChanges(const QString &buildConfig, const QList<ProjectExplorer::EnvironmentItem> &diff);
- QList<ProjectExplorer::EnvironmentItem> userEnvironmentChanges(const QString &buildConfig) const;
- bool useSystemEnvironment(const QString &buildConfiguration) const;
- void setUseSystemEnvironment(const QString &buildConfiguration, bool b);
+ QList<ProjectExplorer::EnvironmentItem> userEnvironmentChanges(ProjectExplorer::BuildConfiguration *configuration) const;
+ bool useSystemEnvironment(ProjectExplorer::BuildConfiguration *configuration) const;
+ void setUseSystemEnvironment(ProjectExplorer::BuildConfiguration *configuration, bool b);
- virtual QString buildDirectory(const QString &buildConfiguration) const;
+ virtual QString buildDirectory(ProjectExplorer::BuildConfiguration *configuration) const;
virtual ProjectExplorer::BuildConfigWidget *createConfigWidget();
virtual QList<ProjectExplorer::BuildConfigWidget*> subConfigWidgets();
- // This method is called for new build configurations
- // You should probably set some default values in this method
- virtual bool newBuildConfiguration(const QString &buildConfiguration);
-
virtual ProjectExplorer::ProjectNode *rootProjectNode() const;
virtual QStringList files(FilesMode fileMode) const;
MakeStep *makeStep() const;
QStringList targets() const;
- QString buildParser(const QString &buildConfiguration) const;
+ QString buildParser(ProjectExplorer::BuildConfiguration *configuration) const;
CMakeTarget targetForTitle(const QString &title);
QString sourceDirectory() const;
ProjectExplorer::ToolChain::ToolChainType toolChainType() const;
- ProjectExplorer::ToolChain *toolChain(const QString &buildConfiguration) const;
+ ProjectExplorer::ToolChain *toolChain(ProjectExplorer::BuildConfiguration *configuration) const;
+ bool parseCMakeLists();
protected:
virtual void saveSettingsImpl(ProjectExplorer::PersistentSettingsWriter &writer);
virtual bool restoreSettingsImpl(ProjectExplorer::PersistentSettingsReader &reader);
// called by CMakeBuildSettingsWidget
- void changeBuildDirectory(const QString &buildConfiguration, const QString &newBuildDirectory);
+ void changeBuildDirectory(ProjectExplorer::BuildConfiguration *configuration, const QString &newBuildDirectory);
private slots:
void fileChanged(const QString &fileName);
void slotActiveBuildConfiguration();
private:
- bool parseCMakeLists();
void updateToolChain(const QString &compiler);
void buildTree(CMakeProjectNode *rootNode, QList<ProjectExplorer::FileNode *> list);
@@ -131,6 +146,7 @@ private:
QString m_fileName;
CMakeFile *m_file;
QString m_projectName;
+ CMakeBuildConfigurationFactory *m_buildConfigurationFactory;
// TODO probably need a CMake specific node structure
CMakeProjectNode *m_rootNode;
diff --git a/src/plugins/cmakeprojectmanager/cmakerunconfiguration.cpp b/src/plugins/cmakeprojectmanager/cmakerunconfiguration.cpp
index 39b0b07e754460df06a7b9d84c2087c8a9608ba7..b3ea45a742fc160b32ad9f72a662b3d63b7eecf1 100644
--- a/src/plugins/cmakeprojectmanager/cmakerunconfiguration.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakerunconfiguration.cpp
@@ -187,7 +187,6 @@ ProjectExplorer::Environment CMakeRunConfiguration::baseEnvironment() const
} else if (m_baseEnvironmentBase == CMakeRunConfiguration::SystemEnvironmentBase) {
env = ProjectExplorer::Environment::systemEnvironment();
} else if (m_baseEnvironmentBase == CMakeRunConfiguration::BuildEnvironmentBase) {
- QString config = project()->activeBuildConfiguration();
env = project()->environment(project()->activeBuildConfiguration());
}
return env;
diff --git a/src/plugins/cmakeprojectmanager/makestep.cpp b/src/plugins/cmakeprojectmanager/makestep.cpp
index 8db7559329a8c1d5cb08505ca8d3192079bafa63..1d88b4cddac5c9619c2298271031762163e38f5e 100644
--- a/src/plugins/cmakeprojectmanager/makestep.cpp
+++ b/src/plugins/cmakeprojectmanager/makestep.cpp
@@ -54,12 +54,13 @@ MakeStep::~MakeStep()
bool MakeStep::init(const QString &buildConfiguration)
{
- setBuildParser(m_pro->buildParser(buildConfiguration));
+ ProjectExplorer::BuildConfiguration *bc = m_pro->buildConfiguration(buildConfiguration);
+ setBuildParser(m_pro->buildParser(bc));
setEnabled(buildConfiguration, true);
- setWorkingDirectory(buildConfiguration, m_pro->buildDirectory(buildConfiguration));
+ setWorkingDirectory(buildConfiguration, m_pro->buildDirectory(bc));
- setCommand(buildConfiguration, m_pro->toolChain(buildConfiguration)->makeCommand());
+ setCommand(buildConfiguration, m_pro->toolChain(bc)->makeCommand());
if (!value(buildConfiguration, "cleanConfig").isValid() &&value("clean").isValid() && value("clean").toBool()) {
// Import old settings
@@ -70,7 +71,7 @@ bool MakeStep::init(const QString &buildConfiguration)
QStringList arguments = value(buildConfiguration, "buildTargets").toStringList();
arguments << additionalArguments(buildConfiguration);
setArguments(buildConfiguration, arguments); // TODO
- setEnvironment(buildConfiguration, m_pro->environment(buildConfiguration));
+ setEnvironment(buildConfiguration, m_pro->environment(bc));
setIgnoreReturnValue(buildConfiguration, value(buildConfiguration, "cleanConfig").isValid());
return AbstractMakeStep::init(buildConfiguration);
@@ -225,7 +226,9 @@ void MakeStepConfigWidget::updateDetails()
QStringList arguments = m_makeStep->value(m_buildConfiguration, "buildTargets").toStringList();
arguments << m_makeStep->additionalArguments(m_buildConfiguration);
m_summaryText = tr("<b>Make:</b> %1 %2")
- .arg(m_makeStep->project()->toolChain(m_buildConfiguration)->makeCommand(),
+ .arg(m_makeStep->project()->toolChain(
+ m_makeStep->project()->buildConfiguration(m_buildConfiguration))
+ ->makeCommand(),
arguments.join(" "));
emit updateSummary();
}
diff --git a/src/plugins/genericprojectmanager/genericmakestep.cpp b/src/plugins/genericprojectmanager/genericmakestep.cpp
index 9bc4320ff3377028b61dc7658a3676d55329e2ee..0ce416f2f5a71e5cdbea0fe51454616b18c50080 100644
--- a/src/plugins/genericprojectmanager/genericmakestep.cpp
+++ b/src/plugins/genericprojectmanager/genericmakestep.cpp
@@ -56,23 +56,24 @@ GenericMakeStep::~GenericMakeStep()
{
}
-bool GenericMakeStep::init(const QString &buildConfiguration)
+bool GenericMakeStep::init(const QString &buildConfigurationName)
{
- const QString buildParser = m_pro->buildParser(buildConfiguration);
+ ProjectExplorer::BuildConfiguration *bc = m_pro->buildConfiguration(buildConfigurationName);
+ const QString buildParser = m_pro->buildParser(bc);
setBuildParser(buildParser);
qDebug() << "*** build parser:" << buildParser;
- setEnabled(buildConfiguration, true);
+ setEnabled(buildConfigurationName, true);
Core::VariableManager *vm = Core::VariableManager::instance();
- const QString rawBuildDir = m_pro->buildDirectory(buildConfiguration);
+ const QString rawBuildDir = m_pro->buildDirectory(bc);
const QString buildDir = vm->resolve(rawBuildDir);
- setWorkingDirectory(buildConfiguration, buildDir);
+ setWorkingDirectory(buildConfigurationName, buildDir);
- setCommand(buildConfiguration, makeCommand(buildConfiguration));
- setArguments(buildConfiguration, replacedArguments(buildConfiguration));
+ setCommand(buildConfigurationName, makeCommand(buildConfigurationName));
+ setArguments(buildConfigurationName, replacedArguments(buildConfigurationName));
- setEnvironment(buildConfiguration, m_pro->environment(buildConfiguration));
- return AbstractMakeStep::init(buildConfiguration);
+ setEnvironment(buildConfigurationName, m_pro->environment(bc));
+ return AbstractMakeStep::init(buildConfigurationName);
}
QStringList GenericMakeStep::replacedArguments(const QString &buildConfiguration) const
diff --git a/src/plugins/genericprojectmanager/genericproject.cpp b/src/plugins/genericprojectmanager/genericproject.cpp
index 3b75a3f09c86e19fef3489cc3b0a61ab73125c39..2f9beb4b13583b3c74026951ff971d360cdcd89b 100644
--- a/src/plugins/genericprojectmanager/genericproject.cpp
+++ b/src/plugins/genericprojectmanager/genericproject.cpp
@@ -55,6 +55,7 @@
using namespace GenericProjectManager;
using namespace GenericProjectManager::Internal;
+using namespace ProjectExplorer;
namespace {
@@ -105,6 +106,40 @@ public:
} // end of anonymous namespace
+/*!
+ \class GenericBuildConfigurationFactory
+*/
+
+GenericBuildConfigurationFactory::GenericBuildConfigurationFactory(GenericProject *project)
+ : IBuildConfigurationFactory(project),
+ m_project(project)
+{
+}
+
+GenericBuildConfigurationFactory::~GenericBuildConfigurationFactory()
+{
+}
+
+QStringList GenericBuildConfigurationFactory::availableCreationTypes() const
+{
+ return QStringList() << "Create";
+}
+
+QString GenericBuildConfigurationFactory::displayNameForType(const QString &type) const
+{
+ return tr("Create");
+}
+
+QList<BuildConfiguration *> GenericBuildConfigurationFactory::create(const QString &type) const
+{
+ return QList<BuildConfiguration *>() << new BuildConfiguration;
+}
+
+QList<BuildConfiguration *> GenericBuildConfigurationFactory::createDefaultConfigurations() const
+{
+ return QList<BuildConfiguration *>() << new BuildConfiguration;
+}
+
////////////////////////////////////////////////////////////////////////////////////
// GenericProject
////////////////////////////////////////////////////////////////////////////////////
@@ -112,6 +147,7 @@ public:
GenericProject::GenericProject(Manager *manager, const QString &fileName)
: m_manager(manager),
m_fileName(fileName),
+ m_buildConfigurationFactory(new GenericBuildConfigurationFactory(this)),
m_toolChain(0)
{
QFileInfo fileInfo(m_fileName);
@@ -136,6 +172,11 @@ GenericProject::~GenericProject()
delete m_toolChain;
}
+IBuildConfigurationFactory *GenericProject::buildConfigurationFactory() const
+{
+ return m_buildConfigurationFactory;
+}
+
QString GenericProject::filesFileName() const
{ return m_filesFileName; }
@@ -355,9 +396,9 @@ void GenericProject::setToolChainType(ProjectExplorer::ToolChain::ToolChainType
}
}
-QString GenericProject::buildParser(const QString &buildConfiguration) const
+QString GenericProject::buildParser(BuildConfiguration *configuration) const
{
- Q_UNUSED(buildConfiguration)
+ Q_UNUSED(configuration)
if (m_toolChain) {
switch (m_toolChain->type()) {
case ProjectExplorer::ToolChain::GCC:
@@ -410,14 +451,15 @@ bool GenericProject::isApplication() const
return true;
}
-ProjectExplorer::Environment GenericProject::environment(const QString &) const
+ProjectExplorer::Environment GenericProject::environment(BuildConfiguration *configuration) const
{
+ Q_UNUSED(configuration)
return ProjectExplorer::Environment::systemEnvironment();
}
-QString GenericProject::buildDirectory(const QString &buildConfiguration) const
+QString GenericProject::buildDirectory(BuildConfiguration *configuration) const
{
- QString buildDirectory = value(buildConfiguration, "buildDirectory").toString();
+ QString buildDirectory = configuration->value("buildDirectory").toString();
if (buildDirectory.isEmpty()) {
QFileInfo fileInfo(m_fileName);
@@ -438,11 +480,11 @@ QList<ProjectExplorer::BuildConfigWidget*> GenericProject::subConfigWidgets()
return QList<ProjectExplorer::BuildConfigWidget*>();
}
- bool GenericProject::newBuildConfiguration(const QString &buildConfiguration)
- {
- makeStep()->setBuildTarget(buildConfiguration, "all", true);
- return true;
- }
+// bool GenericProject::newBuildConfiguration(const QString &buildConfiguration)
+// {
+// makeStep()->setBuildTarget(buildConfiguration, "all", true);
+// return true;
+// }
GenericProjectNode *GenericProject::rootProjectNode() const
{
@@ -482,14 +524,15 @@ bool GenericProject::restoreSettingsImpl(ProjectExplorer::PersistentSettingsRead
const QLatin1String all("all");
- addBuildConfiguration(all);
- setActiveBuildConfiguration(all);
+ ProjectExplorer::BuildConfiguration *bc = new BuildConfiguration(all);
+ addBuildConfiguration(bc);
+ setActiveBuildConfiguration(bc);
makeStep->setBuildTarget(all, all, /* on = */ true);
const QLatin1String buildDirectory("buildDirectory");
const QFileInfo fileInfo(file()->fileName());
- setValue(all, buildDirectory, fileInfo.absolutePath());
+ bc->setValue(buildDirectory, fileInfo.absolutePath());
}
using namespace ProjectExplorer;
@@ -568,10 +611,10 @@ GenericBuildSettingsWidget::~GenericBuildSettingsWidget()
QString GenericBuildSettingsWidget::displayName() const
{ return tr("Generic Manager"); }
-void GenericBuildSettingsWidget::init(const QString &buildConfiguration)
+void GenericBuildSettingsWidget::init(const QString &buildConfigurationName)
{
- m_buildConfiguration = buildConfiguration;
- m_pathChooser->setPath(m_project->buildDirectory(buildConfiguration));
+ m_buildConfiguration = buildConfigurationName;
+ m_pathChooser->setPath(m_project->buildDirectory(m_project->buildConfiguration(buildConfigurationName)));
}
void GenericBuildSettingsWidget::buildDirectoryChanged()
diff --git a/src/plugins/genericprojectmanager/genericproject.h b/src/plugins/genericprojectmanager/genericproject.h
index 8ca62c83c5b76b80ed02f929b1d3ff231571055d..d5c0e8347bc9b5b101f1ca583ccf09c4d543aa2c 100644
--- a/src/plugins/genericprojectmanager/genericproject.h
+++ b/src/plugins/genericprojectmanager/genericproject.h
@@ -37,6 +37,7 @@
#include <projectexplorer/projectnodes.h>
#include <projectexplorer/buildstep.h>
#include <projectexplorer/toolchain.h>
+#include <projectexplorer/buildconfiguration.h>
#include <coreplugin/ifile.h>
QT_BEGIN_NAMESPACE
@@ -52,10 +53,28 @@ class PathChooser;
namespace GenericProjectManager {
namespace Internal {
-
+class GenericProject;
class GenericMakeStep;
class GenericProjectFile;
+class GenericBuildConfigurationFactory : public ProjectExplorer::IBuildConfigurationFactory
+{
+ Q_OBJECT
+
+public:
+ GenericBuildConfigurationFactory(GenericProject *project);
+ ~GenericBuildConfigurationFactory();
+
+ QStringList availableCreationTypes() const;
+ QString displayNameForType(const QString &type) const;
+
+ QList<ProjectExplorer::BuildConfiguration *> create(const QString &type) const;
+ QList<ProjectExplorer::BuildConfiguration *> createDefaultConfigurations() const;
+
+private:
+ GenericProject *m_project;
+};
+
class GenericProject : public ProjectExplorer::Project
{
Q_OBJECT
@@ -70,25 +89,25 @@ public:
virtual QString name() const;
virtual Core::IFile *file() const;
+ virtual ProjectExplorer::IBuildConfigurationFactory *buildConfigurationFactory() const;
virtual ProjectExplorer::IProjectManager *projectManager() const;
virtual QList<ProjectExplorer::Project *> dependsOn();
virtual bool isApplication() const;
- virtual ProjectExplorer::Environment environment(const QString &buildConfiguration) const;
- virtual QString buildDirectory(const QString &buildConfiguration) const;
+ virtual ProjectExplorer::Environment environment(ProjectExplorer::BuildConfiguration *configuration) const;
+ virtual QString buildDirectory(ProjectExplorer::BuildConfiguration *configuration) const;
virtual ProjectExplorer::BuildConfigWidget *createConfigWidget();
virtual QList<ProjectExplorer::BuildConfigWidget*> subConfigWidgets();
- virtual bool newBuildConfiguration(const QString &buildConfiguration);
virtual GenericProjectNode *rootProjectNode() const;
virtual QStringList files(FilesMode fileMode) const;
QStringList targets() const;
GenericMakeStep *makeStep() const;
- QString buildParser(const QString &buildConfiguration) const;
+ QString buildParser(ProjectExplorer::BuildConfiguration *configuration) const;
ProjectExplorer::ToolChain *toolChain() const;
bool setFiles(const QStringList &filePaths);
@@ -110,7 +129,7 @@ public:
QStringList allIncludePaths() const;
QStringList projectIncludePaths() const;
QStringList files() const;
- QStringList generated() const;
+ QStringList generated() const;
ProjectExplorer::ToolChain::ToolChainType toolChainType() const;
void setToolChainType(ProjectExplorer::ToolChain::ToolChainType type);
@@ -129,6 +148,7 @@ private:
QString m_configFileName;
GenericProjectFile *m_file;
QString m_projectName;
+ GenericBuildConfigurationFactory *m_buildConfigurationFactory;
QStringList m_files;
QStringList m_generated;
diff --git a/src/plugins/projectexplorer/buildconfiguration.cpp b/src/plugins/projectexplorer/buildconfiguration.cpp
index 832bb81c96a65d88c0764a01a3aaefb21b2bd760..237198e72b88142b36b457cda3f91f0f5539657f 100644
--- a/src/plugins/projectexplorer/buildconfiguration.cpp
+++ b/src/plugins/projectexplorer/buildconfiguration.cpp
@@ -29,6 +29,8 @@
#include "buildconfiguration.h"
+#include <utils/qtcassert.h>
+
using namespace ProjectExplorer;
BuildConfiguration::BuildConfiguration()
@@ -46,20 +48,21 @@ BuildConfiguration::BuildConfiguration(const QString &name, BuildConfiguration *
{
}
+void BuildConfiguration::setName(const QString &name)
+{
+ m_name = name;
+}
+
QString BuildConfiguration::name() const
{
return m_name;
}
-QString BuildConfiguration::displayName()
+QString BuildConfiguration::displayName() const
{
QVariant v = value("ProjectExplorer.BuildConfiguration.DisplayName");
- if (v.isValid()) {
- return v.toString();
- } else {
- setDisplayName(m_name);
- return m_name;
- }
+ QTC_ASSERT(v.isValid(), return QString());
+ return v.toString();
}
void BuildConfiguration::setDisplayName(const QString &name)
@@ -98,3 +101,14 @@ QMap<QString, QVariant> BuildConfiguration::toMap() const
result.insert(it.key(), it.value());
return result;
}
+
+
+IBuildConfigurationFactory::IBuildConfigurationFactory(QObject *parent)
+ : QObject(parent)
+{
+}
+
+IBuildConfigurationFactory::~IBuildConfigurationFactory()
+{
+
+}
diff --git a/src/plugins/projectexplorer/buildconfiguration.h b/src/plugins/projectexplorer/buildconfiguration.h
index 257c2d9421af9a758f64675391b53e8aa31ee6f1..a38664c49c62cd857c1598394a6ab1125de3c265 100644
--- a/src/plugins/projectexplorer/buildconfiguration.h
+++ b/src/plugins/projectexplorer/buildconfiguration.h
@@ -35,6 +35,7 @@
#include <QtCore/QHash>
#include <QtCore/QString>
#include <QtCore/QStringList>
+#include <QtCore/QList>
#include <QtCore/QObject>
#include <QtCore/QVariant>
@@ -48,13 +49,13 @@ public:
explicit BuildConfiguration();
BuildConfiguration(const QString &name);
BuildConfiguration(const QString &name, BuildConfiguration *source);
+ void setName(const QString &name);
QString name() const;
- QVariant value(const QString &key) const;
- void setValue(const QString &key, QVariant value);
-
- QString displayName();
+ QString displayName() const;
void setDisplayName(const QString &name);
+ QVariant value(const QString &key) const;
+ void setValue(const QString &key, QVariant value);
QMap<QString, QVariant> toMap() const;
void setValuesFromMap(QMap<QString, QVariant> map);
@@ -63,6 +64,25 @@ private:
QString m_name;
};
+class PROJECTEXPLORER_EXPORT IBuildConfigurationFactory : public QObject
+{
+ Q_OBJECT
+
+public:
+ IBuildConfigurationFactory(QObject *parent = 0);
+ virtual ~IBuildConfigurationFactory();
+
+ // used to show the list of possible additons to a project, returns a list of types
+ virtual QStringList availableCreationTypes() const = 0;
+ // used to translate the types to names to display to the user
+ virtual QString displayNameForType(const QString &type) const = 0;
+
+ virtual QList<BuildConfiguration *> create(const QString &type) const = 0;
+// restore
+// clone
+ virtual QList<BuildConfiguration *> createDefaultConfigurations() const = 0;
+};
+
} // namespace ProjectExplorer
#endif // BUILDCONFIGURATION_H
diff --git a/src/plugins/projectexplorer/buildmanager.h b/src/plugins/projectexplorer/buildmanager.h
index 3278064e57779273e9b3d5a81bbc3f7d319f7afb..f201015e58e3cf924b268868ceeaa6a970de4a54 100644
--- a/src/plugins/projectexplorer/buildmanager.h
+++ b/src/plugins/projectexplorer/buildmanager.h
@@ -69,6 +69,7 @@ public:
//shows with focus
void gotoTaskWindow();
+ //TODO these should take buildconfiguration object
void buildProject(Project *p, const QString &configuration);
void buildProjects(const QList<Project *> &projects, const QList<QString> &configurations);
void cleanProject(Project *p, const QString &configuration);
diff --git a/src/plugins/projectexplorer/buildsettingspropertiespage.cpp b/src/plugins/projectexplorer/buildsettingspropertiespage.cpp
index 3fa72afca65913c9a476f6b1284b69cd2b1d0899..35967d4159f992104bc43024d40192f5efc318fb 100644
--- a/src/plugins/projectexplorer/buildsettingspropertiespage.cpp
+++ b/src/plugins/projectexplorer/buildsettingspropertiespage.cpp
@@ -171,7 +171,7 @@ BuildSettingsWidget::BuildSettingsWidget(Project *project)
this, SLOT(cloneConfiguration()));
m_addButton->setMenu(addButtonMenu);
- m_buildConfiguration = m_project->activeBuildConfiguration();
+ m_buildConfiguration = m_project->activeBuildConfiguration()->name();
connect(m_buildConfigurationComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(currentIndexChanged(int)));
@@ -220,9 +220,9 @@ void BuildSettingsWidget::updateBuildSettings()
m_subWidgets->addWidget(subConfigWidget->displayName(), subConfigWidget);
// Add tree items
- foreach (const QString &buildConfiguration, m_project->buildConfigurations()) {
- m_buildConfigurationComboBox->addItem(m_project->buildConfiguration(buildConfiguration)->displayName(), buildConfiguration);
- if (buildConfiguration == m_buildConfiguration)
+ foreach (const BuildConfiguration *bc, m_project->buildConfigurations()) {
+ m_buildConfigurationComboBox->addItem(bc->displayName(), bc->name());
+ if (bc->name() == m_buildConfiguration)
m_buildConfigurationComboBox->setCurrentIndex(m_buildConfigurationComboBox->count() - 1);
}
@@ -256,40 +256,40 @@ void BuildSettingsWidget::activeBuildConfigurationChanged()
void BuildSettingsWidget::createConfiguration()
{
- bool ok;
- QString newBuildConfiguration = QInputDialog::getText(this, tr("New configuration"), tr("New Configuration Name:"), QLineEdit::Normal, QString(), &ok);
- if (!ok || newBuildConfiguration.isEmpty())
- return;
-
- QString newDisplayName = newBuildConfiguration;
- // Check that the internal name is not taken and use a different one otherwise
- const QStringList &buildConfigurations = m_project->buildConfigurations();
- if (buildConfigurations.contains(newBuildConfiguration)) {
- int i = 2;
- while (buildConfigurations.contains(newBuildConfiguration + QString::number(i)))
- ++i;
- newBuildConfiguration += QString::number(i);
- }
-
- // Check that we don't have a configuration with the same displayName
- QStringList displayNames;
- foreach (const QString &bc, buildConfigurations)
- displayNames << m_project->buildConfiguration(bc)->displayName();
-
- if (displayNames.contains(newDisplayName)) {
- int i = 2;
- while (displayNames.contains(newDisplayName + QString::number(i)))
- ++i;
- newDisplayName += QString::number(i);
- }
-
- if (m_project->newBuildConfiguration(newBuildConfiguration)) {
- m_project->addBuildConfiguration(newBuildConfiguration);
- m_project->setDisplayNameFor(newBuildConfiguration, newDisplayName);
- m_buildConfiguration = newBuildConfiguration;
-
- updateBuildSettings();
- }
+// bool ok;
+// QString newBuildConfiguration = QInputDialog::getText(this, tr("New configuration"), tr("New Configuration Name:"), QLineEdit::Normal, QString(), &ok);
+// if (!ok || newBuildConfiguration.isEmpty())
+// return;
+//
+// QString newDisplayName = newBuildConfiguration;
+// // Check that the internal name is not taken and use a different one otherwise
+// const QStringList &buildConfigurations = m_project->buildConfigurations();
+// if (buildConfigurations.contains(newBuildConfiguration)) {
+// int i = 2;
+// while (buildConfigurations.contains(newBuildConfiguration + QString::number(i)))
+// ++i;
+// newBuildConfiguration += QString::number(i);
+// }
+//
+// // Check that we don't have a configuration with the same displayName
+// QStringList displayNames;
+// foreach (const QString &bc, buildConfigurations)
+// displayNames << m_project->buildConfiguration(bc)->displayName();
+//
+// if (displayNames.contains(newDisplayName)) {
+// int i = 2;
+// while (displayNames.contains(newDisplayName + QString::number(i)))
+// ++i;
+// newDisplayName += QString::number(i);
+// }
+//
+// if (m_project->newBuildConfiguration(newBuildConfiguration)) {
+// m_project->addBuildConfiguration(newBuildConfiguration);
+// m_project->setDisplayNameFor(newBuildConfiguration, newDisplayName);
+// m_buildConfiguration = newBuildConfiguration;
+//
+// updateBuildSettings();
+// }
}
void BuildSettingsWidget::cloneConfiguration()
@@ -315,18 +315,17 @@ void BuildSettingsWidget::cloneConfiguration(const QString &sourceConfiguration)
QString newDisplayName = newBuildConfiguration;
// Check that the internal name is not taken and use a different one otherwise
- const QStringList &buildConfigurations = m_project->buildConfigurations();
- if (buildConfigurations.contains(newBuildConfiguration)) {
+ if (m_project->buildConfiguration(newBuildConfiguration)) {
int i = 2;
- while (buildConfigurations.contains(newBuildConfiguration + QString::number(i)))
+ while (m_project->buildConfiguration(newBuildConfiguration + QString::number(i)))
++i;
newBuildConfiguration += QString::number(i);
}
// Check that we don't have a configuration with the same displayName
QStringList displayNames;
- foreach (const QString &bc, buildConfigurations)
- displayNames << m_project->buildConfiguration(bc)->displayName();
+ foreach (const BuildConfiguration *bc, m_project->buildConfigurations())
+ displayNames << bc->displayName();
if (displayNames.contains(newDisplayName)) {
int i = 2;
@@ -347,25 +346,25 @@ void BuildSettingsWidget::deleteConfiguration(const QString &deleteConfiguration
if (deleteConfiguration.isEmpty() || m_project->buildConfigurations().size() <= 1)
return;
- if (m_project->activeBuildConfiguration() == deleteConfiguration) {
- foreach (const QString &otherConfiguration, m_project->buildConfigurations()) {
- if (otherConfiguration != deleteConfiguration) {
- m_project->setActiveBuildConfiguration(otherConfiguration);
+ if (m_project->activeBuildConfiguration()->name() == deleteConfiguration) {
+ foreach (BuildConfiguration *bc, m_project->buildConfigurations()) {
+ if (bc->name() != deleteConfiguration) {
+ m_project->setActiveBuildConfiguration(bc);
break;
}
}
}
if (m_buildConfiguration == deleteConfiguration) {
- foreach (const QString &otherConfiguration, m_project->buildConfigurations()) {
- if (otherConfiguration != deleteConfiguration) {
- m_buildConfiguration = otherConfiguration;
+ foreach (const BuildConfiguration *bc, m_project->buildConfigurations()) {
+ if (bc->name() != deleteConfiguration) {
+ m_buildConfiguration = bc->name();
break;
}
}
}
- m_project->removeBuildConfiguration(deleteConfiguration);
+ m_project->removeBuildConfiguration(m_project->buildConfiguration(deleteConfiguration));
updateBuildSettings();
}
diff --git a/src/plugins/projectexplorer/customexecutablerunconfiguration.cpp b/src/plugins/projectexplorer/customexecutablerunconfiguration.cpp
index c1bf25b3dcbe2d9bf07775e0c7d9ac9f7b00d869..16d737f2ff2f6d88ed01815e89bebb0253ab1b52 100644
--- a/src/plugins/projectexplorer/customexecutablerunconfiguration.cpp
+++ b/src/plugins/projectexplorer/customexecutablerunconfiguration.cpp
@@ -142,7 +142,7 @@ CustomExecutableConfigurationWidget::CustomExecutableConfigurationWidget(CustomE
vbox->addWidget(m_environmentWidget);
changed();
-
+
connect(m_userName, SIGNAL(textEdited(QString)),
this, SLOT(setUserName(QString)));
connect(m_executableChooser, SIGNAL(changed(QString)),
@@ -314,7 +314,7 @@ QString CustomExecutableRunConfiguration::executable() const
QString oldExecutable = m_executable;
QString oldWorkingDirectory = m_workingDirectory;
QStringList oldCmdArguments = m_cmdArguments;
-
+
if (dialog.exec()) {
return executable();
} else {
@@ -359,7 +359,6 @@ ProjectExplorer::Environment CustomExecutableRunConfiguration::baseEnvironment()
} else if (m_baseEnvironmentBase == CustomExecutableRunConfiguration::SystemEnvironmentBase) {
env = ProjectExplorer::Environment::systemEnvironment();
} else if (m_baseEnvironmentBase == CustomExecutableRunConfiguration::BuildEnvironmentBase) {
- QString config = project()->activeBuildConfiguration();
env = project()->environment(project()->activeBuildConfiguration());
}
return env;
diff --git a/src/plugins/projectexplorer/processstep.cpp b/src/plugins/projectexplorer/processstep.cpp
index 08acdbf8ebbc7ade7c29c54a5f25085813a5925a..7e1f5afb827d24c4b8f091da9dd85daa04b0b07c 100644
--- a/src/plugins/projectexplorer/processstep.cpp
+++ b/src/plugins/projectexplorer/processstep.cpp
@@ -45,17 +45,18 @@ ProcessStep::ProcessStep(Project *pro)
}
-bool ProcessStep::init(const QString &buildConfiguration)
+bool ProcessStep::init(const QString &buildConfigurationName)
{
- setEnvironment(buildConfiguration, project()->environment(buildConfiguration));
- QVariant wd = value(buildConfiguration, "workingDirectory").toString();
+ BuildConfiguration *bc = project()->buildConfiguration(buildConfigurationName);
+ setEnvironment(buildConfigurationName, project()->environment(bc));
+ QVariant wd = value(buildConfigurationName, "workingDirectory").toString();
QString workingDirectory;
if (!wd.isValid() || wd.toString().isEmpty())
workingDirectory = "$BUILDDIR";
else
workingDirectory = wd.toString();
- setWorkingDirectory(buildConfiguration, workingDirectory.replace("$BUILDDIR", project()->buildDirectory(buildConfiguration)));
- return AbstractProcessStep::init(buildConfiguration);
+ setWorkingDirectory(buildConfigurationName, workingDirectory.replace("$BUILDDIR", project()->buildDirectory(bc)));
+ return AbstractProcessStep::init(buildConfigurationName);
}
void ProcessStep::run(QFutureInterface<bool> & fi)
diff --git a/src/plugins/projectexplorer/project.cpp b/src/plugins/projectexplorer/project.cpp
index 3cf7932814904c2c6127293a1fc3f9817e2277c2..26e06b50cc786da69861c9dc617a4d1b5f0b5846 100644
--- a/src/plugins/projectexplorer/project.cpp
+++ b/src/plugins/projectexplorer/project.cpp
@@ -66,9 +66,9 @@ void Project::insertBuildStep(int position, BuildStep *step)
{
m_buildSteps.insert(position, step);
// check that the step has all the configurations
- foreach (const QString &name, buildConfigurations())
- if (!step->getBuildConfiguration(name))
- step->addBuildConfiguration(name);
+ foreach (const BuildConfiguration *bc, buildConfigurations())
+ if (!step->getBuildConfiguration(bc->name()))
+ step->addBuildConfiguration(bc->name());
}
void Project::removeBuildStep(int position)
@@ -87,9 +87,9 @@ void Project::insertCleanStep(int position, BuildStep *step)
{
m_cleanSteps.insert(position, step);
// check that the step has all the configurations
- foreach (const QString &name, buildConfigurations())
- if (!step->getBuildConfiguration(name))
- step->addBuildConfiguration(name);
+ foreach (const BuildConfiguration *bc, buildConfigurations())
+ if (!step->getBuildConfiguration(bc->name()))
+ step->addBuildConfiguration(bc->name());
}
void Project::removeCleanStep(int position)
@@ -104,49 +104,75 @@ void Project::moveCleanStepUp(int position)
m_cleanSteps.insert(position - 1, bs);
}
-void Project::addBuildConfiguration(const QString &name)
+void Project::addBuildConfiguration(BuildConfiguration *configuration)
{
- if (buildConfigurations().contains(name) )
- return;
+ QStringList buildConfigurationNames;
+ foreach (const BuildConfiguration *bc, buildConfigurations())
+ buildConfigurationNames << bc->name();
- m_buildConfigurationValues.push_back(new BuildConfiguration(name));
+ // Check that the internal name is not taken and use a different one otherwise
+ QString configurationName = configuration->name();
+ if (buildConfigurationNames.contains(configurationName)) {
+ int i = 2;
+ while (buildConfigurationNames.contains(configurationName + QString::number(i)))
+ ++i;
+ configurationName += QString::number(i);
+ }
+ configuration->setName(configurationName);
- for (int i = 0; i != m_buildSteps.size(); ++i)
- m_buildSteps.at(i)->addBuildConfiguration(name);
+ // Check that we don't have a configuration with the same displayName
+ QString configurationDisplayName = configuration->displayName();
+ QStringList displayNames;
+ foreach (const BuildConfiguration *bc, m_buildConfigurationValues)
+ displayNames << bc->displayName();
+ if (displayNames.contains(configurationDisplayName)) {
+ int i = 2;
+ while (displayNames.contains(configurationDisplayName + QString::number(i)))
+ ++i;
+ configurationDisplayName += QString::number(i);
+ }
+ configuration->setDisplayName(configurationDisplayName);
+
+ // add it
+ m_buildConfigurationValues.push_back(configuration);
+ // update build steps
+ for (int i = 0; i != m_buildSteps.size(); ++i)
+ m_buildSteps.at(i)->addBuildConfiguration(configuration->name());
for (int i = 0; i != m_cleanSteps.size(); ++i)
- m_cleanSteps.at(i)->addBuildConfiguration(name);
- emit addedBuildConfiguration(this, name);
+ m_cleanSteps.at(i)->addBuildConfiguration(configuration->name());
+
+ emit addedBuildConfiguration(this, configuration->name());
}
-void Project::removeBuildConfiguration(const QString &name)
+void Project::removeBuildConfiguration(BuildConfiguration *configuration)
{
- if (!buildConfigurations().contains(name))
+ //todo: this might be error prone
+ if (!buildConfigurations().contains(configuration))
return;
for (int i = 0; i != m_buildConfigurationValues.size(); ++i)
- if (m_buildConfigurationValues.at(i)->name() == name) {
+ if (m_buildConfigurationValues.at(i)->name() == configuration->name()) {
delete m_buildConfigurationValues.at(i);
m_buildConfigurationValues.removeAt(i);
break;
}
for (int i = 0; i != m_buildSteps.size(); ++i)
- m_buildSteps.at(i)->removeBuildConfiguration(name);
+ m_buildSteps.at(i)->removeBuildConfiguration(configuration->name());
for (int i = 0; i != m_cleanSteps.size(); ++i)
- m_cleanSteps.at(i)->removeBuildConfiguration(name);
+ m_cleanSteps.at(i)->removeBuildConfiguration(configuration->name());
- emit removedBuildConfiguration(this, name);
+ emit removedBuildConfiguration(this, configuration->name());
}
void Project::copyBuildConfiguration(const QString &source, const QString &dest)
{
- if (!buildConfigurations().contains(source))
+ BuildConfiguration *sourceConfiguration = buildConfiguration(source);
+ if (!sourceConfiguration)
return;
- for (int i = 0; i != m_buildConfigurationValues.size(); ++i)
- if (m_buildConfigurationValues.at(i)->name() == source)
- m_buildConfigurationValues.push_back(new BuildConfiguration(dest, m_buildConfigurationValues.at(i)));
+ m_buildConfigurationValues.push_back(new BuildConfiguration(dest, sourceConfiguration));
for (int i = 0; i != m_buildSteps.size(); ++i)
m_buildSteps.at(i)->copyBuildConfiguration(source, dest);
@@ -156,12 +182,9 @@ void Project::copyBuildConfiguration(const QString &source, const QString &dest)
emit addedBuildConfiguration(this, dest);
}
-QStringList Project::buildConfigurations() const
+QList<BuildConfiguration *> Project::buildConfigurations() const
{
- QStringList result;
- foreach (BuildConfiguration *bc, m_buildConfigurationValues)
- result << bc->name();
- return result;
+ return m_buildConfigurationValues;
}
bool Project::hasBuildSettings() const
@@ -194,7 +217,7 @@ bool Project::restoreSettings()
return false;
if (m_activeBuildConfiguration.isEmpty() && !m_buildConfigurations.isEmpty())
- setActiveBuildConfiguration(m_buildConfigurations.at(0));
+ setActiveBuildConfiguration(m_buildConfigurationValues.at(0));
if (!m_activeRunConfiguration && !m_runConfigurations.isEmpty())
setActiveRunConfiguration(m_runConfigurations.at(0));
@@ -213,10 +236,11 @@ void Project::saveSettingsImpl(PersistentSettingsWriter &writer)
writer.saveValue("project", m_values);
//save buildsettings
- foreach (const QString &buildConfigurationName, buildConfigurations()) {
- QMap<QString, QVariant> temp =
- buildConfiguration(buildConfigurationName)->toMap();
- writer.saveValue("buildConfiguration-" + buildConfigurationName, temp);
+ QStringList buildConfigurationNames;
+ foreach (const BuildConfiguration *bc, buildConfigurations()) {
+ QMap<QString, QVariant> temp = bc->toMap();
+ writer.saveValue("buildConfiguration-" + bc->name(), temp);
+ buildConfigurationNames << bc->name();
}
QStringList buildStepNames;
@@ -228,7 +252,6 @@ void Project::saveSettingsImpl(PersistentSettingsWriter &writer)
foreach (BuildStep *cleanStep, cleanSteps())
cleanStepNames << cleanStep->name();
writer.saveValue("cleansteps", cleanStepNames);
- QStringList buildConfigurationNames = buildConfigurations();
writer.saveValue("buildconfigurations", buildConfigurationNames );
//save buildstep configuration
@@ -294,10 +317,11 @@ bool Project::restoreSettingsImpl(PersistentSettingsReader &reader)
// restoring BuldConfigurations from settings
const QStringList buildConfigurationNames = reader.restoreValue("buildconfigurations").toStringList();
foreach (const QString &buildConfigurationName, buildConfigurationNames) {
- addBuildConfiguration(buildConfigurationName);
+ BuildConfiguration *bc = new BuildConfiguration(buildConfigurationName);
+ addBuildConfiguration(bc);
QMap<QString, QVariant> temp =
reader.restoreValue("buildConfiguration-" + buildConfigurationName).toMap();
- buildConfiguration(buildConfigurationName)->setValuesFromMap(temp);
+ bc->setValuesFromMap(temp);
}
const QList<IBuildStepFactory *> buildStepFactories =
@@ -434,20 +458,19 @@ QVariant Project::value(const QString &buildConfigurationName, const QString &na
return QVariant();
}
-QString Project::activeBuildConfiguration() const
+BuildConfiguration *Project::activeBuildConfiguration() const
{
- return m_activeBuildConfiguration;
+ return buildConfiguration(m_activeBuildConfiguration); //TODO
}
-void Project::setActiveBuildConfiguration(const QString &config)
+void Project::setActiveBuildConfiguration(BuildConfiguration *configuration)
{
- if (m_activeBuildConfiguration != config && buildConfigurations().contains(config)) {
- m_activeBuildConfiguration = config;
+ if (m_activeBuildConfiguration != configuration->name() && m_buildConfigurationValues.contains(configuration)) {
+ m_activeBuildConfiguration = configuration->name();
emit activeBuildConfigurationChanged();
}
}
-
QList<QSharedPointer<RunConfiguration> > Project::runConfigurations() const
{
return m_runConfigurations;
@@ -468,7 +491,7 @@ void Project::removeRunConfiguration(QSharedPointer<RunConfiguration> runConfigu
if(!m_runConfigurations.contains(runConfiguration)) {
qWarning()<<"Not removing runConfiguration"<<runConfiguration->name()<<"becasue it doesn't exist";
return;
- }
+ }
if (m_activeRunConfiguration == runConfiguration) {
if (m_runConfigurations.size() <= 1)
diff --git a/src/plugins/projectexplorer/project.h b/src/plugins/projectexplorer/project.h
index d81867feb975bc1e85605928051286a7c605c5ce..19b2aa0ff69968037b69bcfad21de85522af203d 100644
--- a/src/plugins/projectexplorer/project.h
+++ b/src/plugins/projectexplorer/project.h
@@ -57,6 +57,7 @@ class ProjectNode;
class PersistentSettingsWriter;
class PersistentSettingsReader;
class BuildConfiguration;
+class IBuildConfigurationFactory;
class PROJECTEXPLORER_EXPORT Project
: public QObject
@@ -95,22 +96,22 @@ public:
void moveCleanStepUp(int position);
// Build configuration
- void addBuildConfiguration(const QString &name);
- void removeBuildConfiguration(const QString &name);
+ void addBuildConfiguration(BuildConfiguration *configuration);
+ void removeBuildConfiguration(BuildConfiguration *configuration);
void copyBuildConfiguration(const QString &source, const QString &dest);
BuildConfiguration *buildConfiguration(const QString & name) const;
- QStringList buildConfigurations() const;
+ QList<BuildConfiguration *> buildConfigurations() const;
void setDisplayNameFor(const QString &buildConfiguration, const QString &displayName);
+ BuildConfiguration *activeBuildConfiguration() const;
+ void setActiveBuildConfiguration(BuildConfiguration *configuration);
+ void setValue(const QString &buildConfiguration, const QString &name, const QVariant &value);
+ QVariant value(const QString &buildConfiguration, const QString &name) const;
- QString activeBuildConfiguration() const;
- void setActiveBuildConfiguration(const QString& config);
+ virtual IBuildConfigurationFactory *buildConfigurationFactory() const = 0;
void setValue(const QString &name, const QVariant &value);
QVariant value(const QString &name) const;
- void setValue(const QString &buildConfiguration, const QString &name, const QVariant &value);
- QVariant value(const QString &buildConfiguration, const QString &name) const;
-
// Running
QList<QSharedPointer<RunConfiguration> > runConfigurations() const;
void addRunConfiguration(QSharedPointer<RunConfiguration> runConfiguration);
@@ -121,8 +122,8 @@ public:
EditorConfiguration *editorConfiguration() const;
- virtual Environment environment(const QString &buildConfiguration) const = 0;
- virtual QString buildDirectory(const QString &buildConfiguration) const = 0;
+ virtual Environment environment(BuildConfiguration *configuration) const = 0;
+ virtual QString buildDirectory(BuildConfiguration *configuration) const = 0;
void saveSettings();
bool restoreSettings();
@@ -130,11 +131,6 @@ public:
virtual BuildConfigWidget *createConfigWidget() = 0;
virtual QList<BuildConfigWidget*> subConfigWidgets();
- /* This method is called for new build configurations. You should probably
- * set some default values in this method.
- */
- virtual bool newBuildConfiguration(const QString &buildConfiguration) = 0;
-
virtual ProjectNode *rootProjectNode() const = 0;
enum FilesMode { AllFiles, ExcludeGeneratedFiles };
diff --git a/src/plugins/projectexplorer/projectexplorer.cpp b/src/plugins/projectexplorer/projectexplorer.cpp
index 0fe7d8c3d26d7173d4fb18d5747bc159a29f4d85..f5ba13661dbadaa5b76b3f0e78e6e13047b952f1 100644
--- a/src/plugins/projectexplorer/projectexplorer.cpp
+++ b/src/plugins/projectexplorer/projectexplorer.cpp
@@ -1415,14 +1415,14 @@ void ProjectExplorerPlugin::buildProjectOnly()
qDebug() << "ProjectExplorerPlugin::buildProjectOnly";
if (saveModifiedFiles())
- buildManager()->buildProject(d->m_currentProject, d->m_currentProject->activeBuildConfiguration());
+ buildManager()->buildProject(d->m_currentProject, d->m_currentProject->activeBuildConfiguration()->name());
}
static QStringList configurations(const QList<Project *> &projects)
{
QStringList result;
foreach (const Project * pro, projects)
- result << pro->activeBuildConfiguration();
+ result << pro->activeBuildConfiguration()->name();
return result;
}
@@ -1454,8 +1454,8 @@ void ProjectExplorerPlugin::rebuildProjectOnly()
qDebug() << "ProjectExplorerPlugin::rebuildProjectOnly";
if (saveModifiedFiles()) {
- d->m_buildManager->cleanProject(d->m_currentProject, d->m_currentProject->activeBuildConfiguration());
- d->m_buildManager->buildProject(d->m_currentProject, d->m_currentProject->activeBuildConfiguration());
+ d->m_buildManager->cleanProject(d->m_currentProject, d->m_currentProject->activeBuildConfiguration()->name());
+ d->m_buildManager->buildProject(d->m_currentProject, d->m_currentProject->activeBuildConfiguration()->name());
}
}
@@ -1493,7 +1493,7 @@ void ProjectExplorerPlugin::cleanProjectOnly()
qDebug() << "ProjectExplorerPlugin::cleanProjectOnly";
if (saveModifiedFiles())
- d->m_buildManager->cleanProject(d->m_currentProject, d->m_currentProject->activeBuildConfiguration());
+ d->m_buildManager->cleanProject(d->m_currentProject, d->m_currentProject->activeBuildConfiguration()->name());
}
void ProjectExplorerPlugin::cleanProject()
@@ -1915,15 +1915,15 @@ void ProjectExplorerPlugin::populateBuildConfigurationMenu()
d->m_buildConfigurationActionGroup = new QActionGroup(d->m_buildConfigurationMenu);
d->m_buildConfigurationMenu->clear();
if (Project *pro = d->m_currentProject) {
- const QString &activeBuildConfiguration = pro->activeBuildConfiguration();
- foreach (const QString &buildConfiguration, pro->buildConfigurations()) {
- QString displayName = pro->buildConfiguration(buildConfiguration)->displayName();
+ const BuildConfiguration *activeBC = pro->activeBuildConfiguration();
+ foreach (const BuildConfiguration *bc, pro->buildConfigurations()) {
+ QString displayName = bc->displayName();
QAction *act = new QAction(displayName, d->m_buildConfigurationActionGroup);
if (debug)
- qDebug() << "BuildConfiguration " << buildConfiguration << "active: " << activeBuildConfiguration;
+ qDebug() << "BuildConfiguration " << bc->name() << "active: " << activeBC->name();
act->setCheckable(true);
- act->setChecked(buildConfiguration == activeBuildConfiguration);
- act->setData(buildConfiguration);
+ act->setChecked(bc == activeBC);
+ act->setData(bc->name());
d->m_buildConfigurationMenu->addAction(act);
}
d->m_buildConfigurationMenu->setEnabled(true);
@@ -1937,7 +1937,8 @@ void ProjectExplorerPlugin::buildConfigurationMenuTriggered(QAction *action)
if (debug)
qDebug() << "ProjectExplorerPlugin::buildConfigurationMenuTriggered";
- d->m_currentProject->setActiveBuildConfiguration(action->data().toString());
+ d->m_currentProject->setActiveBuildConfiguration(d->m_currentProject->buildConfiguration(
+ action->data().toString()));
}
void ProjectExplorerPlugin::populateRunConfigurationMenu()
diff --git a/src/plugins/projectexplorer/projectwindow.cpp b/src/plugins/projectexplorer/projectwindow.cpp
index 04ba236a100467a183497f14effdce8200ecc826..633e75c0a5e07768bddfa9bcf0b5f773823ace1c 100644
--- a/src/plugins/projectexplorer/projectwindow.cpp
+++ b/src/plugins/projectexplorer/projectwindow.cpp
@@ -322,7 +322,7 @@ void RunConfigurationComboBox::activeRunConfigurationChanged()
Project *startupProject = session->startupProject();
if (startupProject) {
int projectIndex = session->projects().indexOf(startupProject);
- int runConfigurationIndex = startupProject->runConfigurations().indexOf(startupProject->activeRunConfiguration());
+ int runConfigurationIndex = startupProject->runConfigurations().indexOf(startupProject->activeRunConfiguration());
setCurrentIndex(convertTreeIndexToInt(projectIndex, runConfigurationIndex));
} else {
setCurrentIndex(-1);
@@ -401,7 +401,7 @@ void RunConfigurationComboBox::rebuildTree()
{
m_ignoreChange = true;
clear();
-
+
SessionManager *session = ProjectExplorer::ProjectExplorerPlugin::instance()->session();
Project *startupProject = session->startupProject();
foreach(Project *p, session->projects()) {
@@ -435,10 +435,9 @@ BuildConfigurationComboBox::BuildConfigurationComboBox(Project *p, QWidget *pare
addWidget(m_label);
//m_comboBox->setSizeAdjustPolicy(QComboBox::AdjustToContents);
- QStringList buildConfigurations = p->buildConfigurations();
- foreach(const QString &buildConfiguration, buildConfigurations)
- m_comboBox->addItem(p->buildConfiguration(buildConfiguration)->displayName(), buildConfiguration);
- if (buildConfigurations.count() == 1) {
+ foreach(const BuildConfiguration *buildConfiguration, p->buildConfigurations())
+ m_comboBox->addItem(buildConfiguration->displayName(), buildConfiguration->name());
+ if (p->buildConfigurations().count() == 1) {
m_label->setText(m_comboBox->itemText(0));
setCurrentWidget(m_label);
}
@@ -485,7 +484,7 @@ int BuildConfigurationComboBox::nameToIndex(const QString &buildConfiguration)
void BuildConfigurationComboBox::activeConfigurationChanged()
{
- int index = nameToIndex(m_project->activeBuildConfiguration());
+ int index = nameToIndex(m_project->activeBuildConfiguration()->name());
if (index == -1)
return;
ignoreIndexChange = true;
@@ -519,7 +518,8 @@ void BuildConfigurationComboBox::changedIndex(int newIndex)
{
if (newIndex == -1)
return;
- m_project->setActiveBuildConfiguration(m_comboBox->itemData(newIndex).toString());
+ m_project->setActiveBuildConfiguration(
+ m_project->buildConfiguration(m_comboBox->itemData(newIndex).toString()));
}
///
diff --git a/src/plugins/qmlprojectmanager/qmlproject.cpp b/src/plugins/qmlprojectmanager/qmlproject.cpp
index 2e1133a16693a3b8e9979449535bf7fd6119a479..c237698667f12c84ccd584488ca902ed3a02b9fc 100644
--- a/src/plugins/qmlprojectmanager/qmlproject.cpp
+++ b/src/plugins/qmlprojectmanager/qmlproject.cpp
@@ -59,6 +59,7 @@
using namespace QmlProjectManager;
using namespace QmlProjectManager::Internal;
+using namespace ProjectExplorer;
////////////////////////////////////////////////////////////////////////////////////
// QmlProject
@@ -161,8 +162,9 @@ QStringList QmlProject::convertToAbsoluteFiles(const QStringList &paths) const
QStringList QmlProject::files() const
{ return m_files; }
-QString QmlProject::buildParser(const QString &) const
+QString QmlProject::buildParser(BuildConfiguration *configuration) const
{
+ Q_UNUSED(configuration)
return QString();
}
@@ -196,13 +198,15 @@ bool QmlProject::hasBuildSettings() const
return false;
}
-ProjectExplorer::Environment QmlProject::environment(const QString &) const
+ProjectExplorer::Environment QmlProject::environment(BuildConfiguration *configuration) const
{
+ Q_UNUSED(configuration)
return ProjectExplorer::Environment::systemEnvironment();
}
-QString QmlProject::buildDirectory(const QString &) const
+QString QmlProject::buildDirectory(BuildConfiguration *configuration) const
{
+ Q_UNUSED(configuration)
return QString();
}
@@ -216,9 +220,9 @@ QList<ProjectExplorer::BuildConfigWidget*> QmlProject::subConfigWidgets()
return QList<ProjectExplorer::BuildConfigWidget*>();
}
-bool QmlProject::newBuildConfiguration(const QString &)
+ProjectExplorer::IBuildConfigurationFactory *QmlProject::buildConfigurationFactory() const
{
- return true;
+ return 0;
}
QmlProjectNode *QmlProject::rootProjectNode() const
diff --git a/src/plugins/qmlprojectmanager/qmlproject.h b/src/plugins/qmlprojectmanager/qmlproject.h
index 08ac9aab71fabf78417b1a656400b751741051da..9e81a04d1eee3c18dedf3bc3f9b8f00fa1fe1302 100644
--- a/src/plugins/qmlprojectmanager/qmlproject.h
+++ b/src/plugins/qmlprojectmanager/qmlproject.h
@@ -64,25 +64,25 @@ public:
virtual QString name() const;
virtual Core::IFile *file() const;
virtual Manager *projectManager() const;
+ virtual ProjectExplorer::IBuildConfigurationFactory *buildConfigurationFactory() const;
virtual QList<ProjectExplorer::Project *> dependsOn();
virtual bool isApplication() const;
virtual bool hasBuildSettings() const;
- virtual ProjectExplorer::Environment environment(const QString &buildConfiguration) const;
- virtual QString buildDirectory(const QString &buildConfiguration) const;
+ virtual ProjectExplorer::Environment environment(ProjectExplorer::BuildConfiguration *configuration) const;
+ virtual QString buildDirectory(ProjectExplorer::BuildConfiguration *configuration) const;
virtual ProjectExplorer::BuildConfigWidget *createConfigWidget();
virtual QList<ProjectExplorer::BuildConfigWidget*> subConfigWidgets();
- virtual bool newBuildConfiguration(const QString &buildConfiguration);
virtual QmlProjectNode *rootProjectNode() const;
virtual QStringList files(FilesMode fileMode) const;
QStringList targets() const;
QmlMakeStep *makeStep() const;
- QString buildParser(const QString &buildConfiguration) const;
+ QString buildParser(ProjectExplorer::BuildConfiguration *configuration) const;
enum RefreshOptions {
Files = 0x01,
diff --git a/src/plugins/qt4projectmanager/deployhelper.cpp b/src/plugins/qt4projectmanager/deployhelper.cpp
index 1d635ce7ce3f8ae3b5ee43f8146cc0d6b77ce0ef..0e87844ba913a7387dbcf2d59ba73ba93ec55b03 100644
--- a/src/plugins/qt4projectmanager/deployhelper.cpp
+++ b/src/plugins/qt4projectmanager/deployhelper.cpp
@@ -50,8 +50,7 @@ DeployHelperRunStep::DeployHelperRunStep(Qt4Project *pro)
bool DeployHelperRunStep::init(const QString &configuration)
{
- Q_UNUSED(configuration)
- m_qtdir = m_pro->qtDir(configuration);
+ m_qtdir = m_pro->qtDir(m_pro->buildConfiguration(configuration));
QFileInfo fi(m_pro->file()->fileName());
m_appdir = fi.absolutePath();
//find target
diff --git a/src/plugins/qt4projectmanager/makestep.cpp b/src/plugins/qt4projectmanager/makestep.cpp
index acc1db3a8fcb832e3d4f18cc1b1e87b7361af911..13f9d7c1e0fe8704eb13c1f27f7108db5d229743 100644
--- a/src/plugins/qt4projectmanager/makestep.cpp
+++ b/src/plugins/qt4projectmanager/makestep.cpp
@@ -58,18 +58,19 @@ MakeStep::~MakeStep()
bool MakeStep::init(const QString &name)
{
m_buildConfiguration = name;
- Environment environment = project()->environment(name);
+ ProjectExplorer::BuildConfiguration *bc = project()->buildConfiguration(name);
+ Environment environment = project()->environment(bc);
setEnvironment(name, environment);
QString workingDirectory;
- if (project()->value(name, "useShadowBuild").toBool())
- workingDirectory = project()->value(name, "buildDirectory").toString();
+ if (bc->value("useShadowBuild").toBool())
+ workingDirectory = bc->value("buildDirectory").toString();
if (workingDirectory.isEmpty())
workingDirectory = QFileInfo(project()->file()->fileName()).absolutePath();
setWorkingDirectory(name, workingDirectory);
Qt4Project *qt4project = qobject_cast<Qt4Project *>(project());
- QString makeCmd = qt4project->makeCommand(name);
+ QString makeCmd = qt4project->makeCommand(bc);
if (!value(name, "makeCmd").toString().isEmpty())
makeCmd = value(name, "makeCmd").toString();
if (!QFileInfo(makeCmd).isAbsolute()) {
@@ -95,15 +96,15 @@ bool MakeStep::init(const QString &name)
setIgnoreReturnValue(name, value(name, "cleanConfig").isValid());
QStringList args = value(name, "makeargs").toStringList();
if (!value(name, "cleanConfig").isValid()) {
- if (!qt4project->defaultMakeTarget(name).isEmpty())
- args << qt4project->defaultMakeTarget(name);
+ if (!qt4project->defaultMakeTarget(bc).isEmpty())
+ args << qt4project->defaultMakeTarget(bc);
}
// -w option enables "Enter"/"Leaving directory" messages, which we need for detecting the
// absolute file path
// FIXME doing this without the user having a way to override this is rather bad
// so we only do it for unix and if the user didn't override the make command
// but for now this is the least invasive change
- ProjectExplorer::ToolChain *toolchain = qobject_cast<Qt4Project *>(project())->toolChain(name);
+ ProjectExplorer::ToolChain *toolchain = qt4project->toolChain(bc);
ProjectExplorer::ToolChain::ToolChainType t = ProjectExplorer::ToolChain::UNKNOWN;
if (toolchain)
@@ -116,7 +117,7 @@ bool MakeStep::init(const QString &name)
setEnabled(name, true);
setArguments(name, args);
- ProjectExplorer::ToolChain::ToolChainType type = qobject_cast<Qt4Project *>(project())->toolChain(name)->type();
+ ProjectExplorer::ToolChain::ToolChainType type = qt4project->toolChain(bc)->type();
if ( type == ProjectExplorer::ToolChain::MSVC || type == ProjectExplorer::ToolChain::WINCE)
setBuildParser(ProjectExplorer::Constants::BUILD_PARSER_MSVC);
else
@@ -186,7 +187,9 @@ MakeStepConfigWidget::MakeStepConfigWidget(MakeStep *makeStep)
void MakeStepConfigWidget::updateMakeOverrideLabel()
{
- m_ui.makeLabel->setText(tr("Override %1:").arg(static_cast<Qt4Project *>(m_makeStep->project())->makeCommand(m_buildConfiguration)));
+ Qt4Project *qt4project = qobject_cast<Qt4Project *>(m_makeStep->project());
+ m_ui.makeLabel->setText(tr("Override %1:").arg(qt4project->
+ makeCommand(qt4project->buildConfiguration(m_buildConfiguration))));
}
void MakeStepConfigWidget::updateDetails()
@@ -194,17 +197,17 @@ void MakeStepConfigWidget::updateDetails()
// TODO reduce heavy code duplication
QString workingDirectory;
Qt4Project *pro = static_cast<Qt4Project *>(m_makeStep->project());
- if (pro->value(m_buildConfiguration, "useShadowBuild").toBool())
- workingDirectory = pro->value(m_buildConfiguration, "buildDirectory").toString();
+ ProjectExplorer::BuildConfiguration *bc = pro->buildConfiguration(m_buildConfiguration);
+ if (bc->value("useShadowBuild").toBool())
+ workingDirectory = bc->value("buildDirectory").toString();
if (workingDirectory.isEmpty())
workingDirectory = QFileInfo(pro->file()->fileName()).absolutePath();
- Qt4Project *qt4project = qobject_cast<Qt4Project *>(pro);
- QString makeCmd = qt4project->makeCommand(m_buildConfiguration);
+ QString makeCmd = pro->makeCommand(bc);
if (!m_makeStep->value(m_buildConfiguration, "makeCmd").toString().isEmpty())
makeCmd = m_makeStep->value(m_buildConfiguration, "makeCmd").toString();
if (!QFileInfo(makeCmd).isAbsolute()) {
- Environment environment = pro->environment(m_buildConfiguration);
+ Environment environment = pro->environment(bc);
// Try to detect command in environment
QString tmp = environment.searchInPath(makeCmd);
if (tmp == QString::null) {
@@ -221,7 +224,7 @@ void MakeStepConfigWidget::updateDetails()
// but for now this is the least invasive change
QStringList args = m_makeStep->value(m_buildConfiguration, "makeargs").toStringList();
ProjectExplorer::ToolChain::ToolChainType t = ProjectExplorer::ToolChain::UNKNOWN;
- ProjectExplorer::ToolChain *toolChain = qobject_cast<Qt4Project *>(pro)->toolChain(m_buildConfiguration);
+ ProjectExplorer::ToolChain *toolChain = pro->toolChain(bc);
if (toolChain)
t = toolChain->type();
if (t != ProjectExplorer::ToolChain::MSVC && t != ProjectExplorer::ToolChain::WINCE) {
diff --git a/src/plugins/qt4projectmanager/projectloadwizard.cpp b/src/plugins/qt4projectmanager/projectloadwizard.cpp
index 74125f4a6ab19c31f887cc5e038cb5c1907c3dc4..7bcb6ea849ef789a80fb1ad3cfa3d33169677a4d 100644
--- a/src/plugins/qt4projectmanager/projectloadwizard.cpp
+++ b/src/plugins/qt4projectmanager/projectloadwizard.cpp
@@ -118,30 +118,25 @@ void ProjectLoadWizard::addBuildConfiguration(QString buildConfigurationName, Qt
MakeStep *makeStep = m_project->makeStep();
bool debug = qmakeBuildConfiguration & QtVersion::DebugBuild;
- // Check that bc.name is not already in use
- if (m_project->buildConfigurations().contains(buildConfigurationName)) {
- int i =1;
- do {
- ++i;
- } while (m_project->buildConfigurations().contains(buildConfigurationName + " " + QString::number(i)));
- buildConfigurationName.append(" " + QString::number(i));
- }
// Add the buildconfiguration
- m_project->addBuildConfiguration(buildConfigurationName);
- qmakeStep->setValue(buildConfigurationName, "qmakeArgs", additionalArguments);
+ ProjectExplorer::BuildConfiguration *bc = new ProjectExplorer::BuildConfiguration(buildConfigurationName);
+ m_project->addBuildConfiguration(bc);
+ const QString &finalBuildConfigurationName = bc->name();
+ qmakeStep->setValue(finalBuildConfigurationName, "qmakeArgs", additionalArguments);
+
// set some options for qmake and make
if (qmakeBuildConfiguration & QtVersion::BuildAll) // debug_and_release => explicit targets
- makeStep->setValue(buildConfigurationName, "makeargs", QStringList() << (debug ? "debug" : "release"));
+ makeStep->setValue(finalBuildConfigurationName, "makeargs", QStringList() << (debug ? "debug" : "release"));
- m_project->setValue(buildConfigurationName, "buildConfiguration", int(qmakeBuildConfiguration));
+ bc->setValue("buildConfiguration", int(qmakeBuildConfiguration));
// Finally set the qt version
bool defaultQtVersion = (qtversion == 0);
if (defaultQtVersion)
- m_project->setQtVersion(buildConfigurationName, 0);
+ m_project->setQtVersion(bc, 0);
else
- m_project->setQtVersion(buildConfigurationName, qtversion->uniqueId());
+ m_project->setQtVersion(bc, qtversion->uniqueId());
}
void ProjectLoadWizard::done(int result)
@@ -176,7 +171,7 @@ void ProjectLoadWizard::done(int result)
// Not importing
if (m_temporaryVersion)
delete m_importVersion;
- // Create default
+ // Create default
bool buildAll = false;
QtVersion *defaultVersion = vm->version(0);
if (defaultVersion && defaultVersion->isValid() && (defaultVersion->defaultBuildConfig() & QtVersion::BuildAll))
diff --git a/src/plugins/qt4projectmanager/qmakestep.cpp b/src/plugins/qt4projectmanager/qmakestep.cpp
index 8ef04206e3ce45e084fe98dab5a767a595335df8..93ddd014699b6166dabecae993c230c548755c23 100644
--- a/src/plugins/qt4projectmanager/qmakestep.cpp
+++ b/src/plugins/qt4projectmanager/qmakestep.cpp
@@ -59,18 +59,19 @@ QMakeStep::~QMakeStep()
QStringList QMakeStep::arguments(const QString &buildConfiguration)
{
QStringList additonalArguments = value(buildConfiguration, "qmakeArgs").toStringList();
+ ProjectExplorer::BuildConfiguration *bc = m_pro->buildConfiguration(buildConfiguration);
QStringList arguments;
arguments << project()->file()->fileName();
if (!additonalArguments.contains("-spec")) {
- arguments << "-spec" << m_pro->qtVersion(buildConfiguration)->mkspec();
+ arguments << "-spec" << m_pro->qtVersion(bc)->mkspec();
}
arguments << "-r";
- if (project()->value(buildConfiguration, "buildConfiguration").isValid()) {
+ if (bc->value("buildConfiguration").isValid()) {
QStringList configarguments;
- QtVersion::QmakeBuildConfig defaultBuildConfiguration = m_pro->qtVersion(buildConfiguration)->defaultBuildConfig();
- QtVersion::QmakeBuildConfig projectBuildConfiguration = QtVersion::QmakeBuildConfig(project()->value(buildConfiguration, "buildConfiguration").toInt());
+ QtVersion::QmakeBuildConfig defaultBuildConfiguration = m_pro->qtVersion(bc)->defaultBuildConfig();
+ QtVersion::QmakeBuildConfig projectBuildConfiguration = QtVersion::QmakeBuildConfig(bc->value("buildConfiguration").toInt());
if ((defaultBuildConfiguration & QtVersion::BuildAll) && !(projectBuildConfiguration & QtVersion::BuildAll))
configarguments << "CONFIG-=debug_and_release";
if (!(defaultBuildConfiguration & QtVersion::BuildAll) && (projectBuildConfiguration & QtVersion::BuildAll))
@@ -94,7 +95,8 @@ QStringList QMakeStep::arguments(const QString &buildConfiguration)
bool QMakeStep::init(const QString &name)
{
m_buildConfiguration = name;
- const QtVersion *qtVersion = m_pro->qtVersion(name);
+ ProjectExplorer::BuildConfiguration *bc = m_pro->buildConfiguration(name);
+ const QtVersion *qtVersion = m_pro->qtVersion(bc);
if (!qtVersion->isValid()) {
@@ -107,7 +109,7 @@ bool QMakeStep::init(const QString &name)
}
QStringList args = arguments(name);
- QString workingDirectory = m_pro->buildDirectory(name);
+ QString workingDirectory = m_pro->buildDirectory(bc);
QString program = qtVersion->qmakeCommand();
@@ -116,7 +118,7 @@ bool QMakeStep::init(const QString &name)
if (QDir(workingDirectory).exists(QLatin1String("Makefile"))) {
QString qmakePath = QtVersionManager::findQMakeBinaryFromMakefile(workingDirectory);
if (qtVersion->qmakeCommand() == qmakePath) {
- needToRunQMake = !m_pro->compareBuildConfigurationToImportFrom(name, workingDirectory);
+ needToRunQMake = !m_pro->compareBuildConfigurationToImportFrom(bc, workingDirectory);
}
}
@@ -129,7 +131,7 @@ bool QMakeStep::init(const QString &name)
setWorkingDirectory(name, workingDirectory);
setCommand(name, program);
setArguments(name, args);
- setEnvironment(name, m_pro->environment(name));
+ setEnvironment(name, m_pro->environment(bc));
return AbstractProcessStep::init(name);
}
@@ -139,7 +141,7 @@ void QMakeStep::run(QFutureInterface<bool> &fi)
fi.reportResult(true);
return;
}
-
+
if (!enabled(m_buildConfiguration)) {
emit addToOutputWindow(tr("<font color=\"#0000ff\">Configuration unchanged, skipping QMake step.</font>"));
fi.reportResult(true);
@@ -216,7 +218,8 @@ QString QMakeStepConfigWidget::summaryText() const
void QMakeStepConfigWidget::updateTitleLabel()
{
- const QtVersion *qtVersion = static_cast<Qt4Project *>(m_step->project())->qtVersion(m_buildConfiguration);
+ Qt4Project *qt4project = qobject_cast<Qt4Project *>(m_step->project());
+ const QtVersion *qtVersion = qt4project->qtVersion(qt4project->buildConfiguration(m_buildConfiguration));
if (!qtVersion) {
m_summaryText = tr("<b>QMake:</b> No Qt version set. QMake can not be run.");
emit updateSummary();
@@ -284,7 +287,8 @@ void QMakeStepConfigWidget::init(const QString &buildConfiguration)
void QMakeStepConfigWidget::updateEffectiveQMakeCall()
{
- const QtVersion *qtVersion = static_cast<Qt4Project *>(m_step->project())->qtVersion(m_buildConfiguration);
+ Qt4Project *qt4project = qobject_cast<Qt4Project *>(m_step->project());
+ const QtVersion *qtVersion = qt4project->qtVersion(qt4project->buildConfiguration(m_buildConfiguration));
if (qtVersion) {
QString program = QFileInfo(qtVersion->qmakeCommand()).fileName();
m_ui.qmakeArgumentsEdit->setPlainText(program + QLatin1Char(' ') + ProjectExplorer::Environment::joinArgumentList(m_step->arguments(m_buildConfiguration)));
diff --git a/src/plugins/qt4projectmanager/qt4buildenvironmentwidget.cpp b/src/plugins/qt4projectmanager/qt4buildenvironmentwidget.cpp
index be348ef350291429e66e6d233b39cb474a5d005d..2d1b9fca335ef1e033d98fb8a5b7fa78fb12a3be 100644
--- a/src/plugins/qt4projectmanager/qt4buildenvironmentwidget.cpp
+++ b/src/plugins/qt4projectmanager/qt4buildenvironmentwidget.cpp
@@ -79,20 +79,22 @@ void Qt4BuildEnvironmentWidget::init(const QString &buildConfiguration)
qDebug() << "Qt4BuildConfigWidget::init()";
m_buildConfiguration = buildConfiguration;
-
- m_clearSystemEnvironmentCheckBox->setChecked(!m_pro->useSystemEnvironment(buildConfiguration));
- m_buildEnvironmentWidget->setBaseEnvironment(m_pro->baseEnvironment(buildConfiguration));
- m_buildEnvironmentWidget->setUserChanges(m_pro->userEnvironmentChanges(buildConfiguration));
+ ProjectExplorer::BuildConfiguration *bc = m_pro->buildConfiguration(buildConfiguration);
+ m_clearSystemEnvironmentCheckBox->setChecked(!m_pro->useSystemEnvironment(bc));
+ m_buildEnvironmentWidget->setBaseEnvironment(m_pro->baseEnvironment(bc));
+ m_buildEnvironmentWidget->setUserChanges(m_pro->userEnvironmentChanges(bc));
m_buildEnvironmentWidget->updateButtons();
}
void Qt4BuildEnvironmentWidget::environmentModelUserChangesUpdated()
{
- m_pro->setUserEnvironmentChanges(m_buildConfiguration, m_buildEnvironmentWidget->userChanges());
+ m_pro->setUserEnvironmentChanges(m_pro->buildConfiguration(m_buildConfiguration),
+ m_buildEnvironmentWidget->userChanges());
}
void Qt4BuildEnvironmentWidget::clearSystemEnvironmentCheckBoxClicked(bool checked)
{
- m_pro->setUseSystemEnvironment(m_buildConfiguration, !checked);
- m_buildEnvironmentWidget->setBaseEnvironment(m_pro->baseEnvironment(m_buildConfiguration));
+ ProjectExplorer::BuildConfiguration *bc = m_pro->buildConfiguration(m_buildConfiguration);
+ m_pro->setUseSystemEnvironment(bc, !checked);
+ m_buildEnvironmentWidget->setBaseEnvironment(m_pro->baseEnvironment(bc));
}
diff --git a/src/plugins/qt4projectmanager/qt4project.cpp b/src/plugins/qt4projectmanager/qt4project.cpp
index 601de6f52612ae627f06aee1b031438847351088..72ee7ab034559646ff7a76d8ac0fbe9fb5d00fcf 100644
--- a/src/plugins/qt4projectmanager/qt4project.cpp
+++ b/src/plugins/qt4projectmanager/qt4project.cpp
@@ -55,10 +55,12 @@
#include <projectexplorer/nodesvisitor.h>
#include <projectexplorer/project.h>
#include <projectexplorer/customexecutablerunconfiguration.h>
+#include <utils/qtcassert.h>
#include <QtCore/QDebug>
#include <QtCore/QDir>
#include <QtGui/QFileDialog>
+#include <QtGui/QInputDialog>
using namespace Qt4ProjectManager;
using namespace Qt4ProjectManager::Internal;
@@ -223,6 +225,52 @@ void Qt4ProjectFile::modified(Core::IFile::ReloadBehavior *)
{
}
+
+/*!
+ \class Qt4BuildConfigurationFactory
+*/
+
+Qt4BuildConfigurationFactory::Qt4BuildConfigurationFactory(Qt4Project *project)
+ : IBuildConfigurationFactory(project),
+ m_project(project)
+{
+}
+
+Qt4BuildConfigurationFactory::~Qt4BuildConfigurationFactory()
+{
+}
+
+QStringList Qt4BuildConfigurationFactory::availableCreationTypes() const
+{
+ return QStringList() << "Create";
+}
+
+QString Qt4BuildConfigurationFactory::displayNameForType(const QString &type) const
+{
+ return tr("Create");
+}
+
+QList<BuildConfiguration *> Qt4BuildConfigurationFactory::create(const QString &type) const
+{
+ QTC_ASSERT(type == "Create", return QList<BuildConfiguration*>());
+ bool ok;
+ QString buildConfigurationName = QInputDialog::getText(0,
+ tr("New configuration"),
+ tr("New Configuration Name:"),
+ QLineEdit::Normal,
+ QString(),
+ &ok);
+ if (!ok || buildConfigurationName.isEmpty())
+ return QList<BuildConfiguration *>();
+ BuildConfiguration *bc = new BuildConfiguration(buildConfigurationName);
+ return QList<BuildConfiguration *>() << bc;
+}
+
+QList<BuildConfiguration *> Qt4BuildConfigurationFactory::createDefaultConfigurations() const
+{
+ return QList<BuildConfiguration *>() << new BuildConfiguration;
+}
+
/*!
\class Qt4Project
@@ -233,6 +281,7 @@ Qt4Project::Qt4Project(Qt4Manager *manager, const QString& fileName) :
m_manager(manager),
m_rootProjectNode(0),
m_nodesWatcher(new Internal::Qt4NodesWatcher(this)),
+ m_buildConfigurationFactory(new Qt4BuildConfigurationFactory(this)),
m_fileInfo(new Qt4ProjectFile(this, fileName, this)),
m_isApplication(true),
m_projectFiles(new Qt4ProjectFiles),
@@ -261,7 +310,7 @@ void Qt4Project::defaultQtVersionChanged()
void Qt4Project::qtVersionsChanged()
{
QtVersionManager *vm = QtVersionManager::instance();
- foreach (QString bc, buildConfigurations()) {
+ foreach (BuildConfiguration *bc, buildConfigurations()) {
if (!vm->version(qtVersionId(bc))->isValid()) {
setQtVersion(bc, 0);
if (bc == activeBuildConfiguration())
@@ -290,7 +339,7 @@ bool Qt4Project::restoreSettingsImpl(PersistentSettingsReader &settingsReader)
// Ensure that the qt version and tool chain in each build configuration is valid
// or if not, is reset to the default
- foreach (const QString &bc, buildConfigurations()) {
+ foreach (BuildConfiguration *bc, buildConfigurations()) {
qtVersionId(bc);
toolChainType(bc);
}
@@ -357,6 +406,11 @@ void Qt4Project::saveSettingsImpl(ProjectExplorer::PersistentSettingsWriter &wri
Project::saveSettingsImpl(writer);
}
+ProjectExplorer::IBuildConfigurationFactory *Qt4Project::buildConfigurationFactory() const
+{
+ return m_buildConfigurationFactory;
+}
+
namespace {
class FindQt4ProFiles: protected ProjectExplorer::NodesVisitor {
QList<Qt4ProFileNode *> m_proFiles;
@@ -384,10 +438,10 @@ void Qt4Project::scheduleUpdateCodeModel(Qt4ProjectManager::Internal::Qt4ProFile
m_proFilesForCodeModelUpdate.append(pro);
}
-ProjectExplorer::ToolChain *Qt4Project::toolChain(const QString &buildConfiguration) const
+ProjectExplorer::ToolChain *Qt4Project::toolChain(BuildConfiguration *configuration) const
{
ProjectExplorer::ToolChain *tempToolChain;
- tempToolChain = qtVersion(buildConfiguration)->createToolChain(toolChainType(buildConfiguration));
+ tempToolChain = qtVersion(configuration)->createToolChain(toolChainType(configuration));
if (!ProjectExplorer::ToolChain::equals(m_toolChain, tempToolChain)) {
if (m_toolChain)
delete m_toolChain;
@@ -399,13 +453,13 @@ ProjectExplorer::ToolChain *Qt4Project::toolChain(const QString &buildConfigurat
return m_toolChain;
}
-QString Qt4Project::makeCommand(const QString &buildConfiguration) const
+QString Qt4Project::makeCommand(BuildConfiguration *configuration) const
{
- ToolChain *tc = toolChain(buildConfiguration);
+ ToolChain *tc = toolChain(configuration);
return tc ? tc->makeCommand() : "make";
}
-QString Qt4Project::defaultMakeTarget(const QString &buildConfiguration) const
+QString Qt4Project::defaultMakeTarget(BuildConfiguration *configuration) const
{
#ifdef QTCREATOR_WITH_S60
ToolChain *tc = toolChain(buildConfiguration);
@@ -425,7 +479,7 @@ QString Qt4Project::defaultMakeTarget(const QString &buildConfiguration) const
return (buildConfig & QtVersion::DebugBuild ? "debug-" : "release-") + QLatin1String("armv6");
}
#else
- Q_UNUSED(buildConfiguration);
+ Q_UNUSED(configuration);
#endif
return QString::null;
}
@@ -731,33 +785,27 @@ void Qt4Project::addDefaultBuild()
} else {
// Migrate settings
QMakeStep *qs = qmakeStep();
- foreach (const QString &buildConfiguration, buildConfigurations()) {
- QVariant v = qs ? qs->value(buildConfiguration, "buildConfiguration") : QVariant();
+ foreach (BuildConfiguration *bc, buildConfigurations()) {
+ QVariant v = qs ? qs->value(bc->name(), "buildConfiguration") : QVariant();
if (v.isValid()) {
- qs->setValue(buildConfiguration, "buildConfiguration", QVariant());
- setValue(buildConfiguration, "buildConfiguration", v);
- } else if (!value(buildConfiguration, "buildConfiguration").isValid()) {
- if (QtVersion *version = qtVersion(buildConfiguration))
- setValue(buildConfiguration, "buildConfiguration", version->defaultBuildConfig());
+ qs->setValue(bc->name(), "buildConfiguration", QVariant());
+ bc->setValue("buildConfiguration", v);
+ } else if (!bc->value("buildConfiguration").isValid()) {
+ if (QtVersion *version = qtVersion(bc))
+ bc->setValue("buildConfiguration", version->defaultBuildConfig());
else
- setValue(buildConfiguration, "buildConfiguration", int(QtVersion::BuildAll & QtVersion::DebugBuild));
+ bc->setValue("buildConfiguration", int(QtVersion::BuildAll & QtVersion::DebugBuild));
}
}
// Restoring configuration
- foreach(const QString &bc, buildConfigurations()) {
- setValue(bc, "addQDumper", QVariant());
+ foreach(BuildConfiguration *bc, buildConfigurations()) {
+ bc->setValue("addQDumper", QVariant());
}
}
}
-bool Qt4Project::newBuildConfiguration(const QString &buildConfiguration)
-{
- Q_UNUSED(buildConfiguration)
- return true;
-}
-
void Qt4Project::proFileParseError(const QString &errorMessage)
{
Core::ICore::instance()->messageManager()->printToOutputPane(errorMessage);
@@ -768,92 +816,93 @@ Qt4ProFileNode *Qt4Project::rootProjectNode() const
return m_rootProjectNode;
}
-QString Qt4Project::buildDirectory(const QString &buildConfiguration) const
+QString Qt4Project::buildDirectory(BuildConfiguration *configuration) const
{
QString workingDirectory;
- if (value(buildConfiguration, "useShadowBuild").toBool())
- workingDirectory = value(buildConfiguration, "buildDirectory").toString();
+ if (configuration->value("useShadowBuild").toBool())
+ workingDirectory = configuration->value("buildDirectory").toString();
if (workingDirectory.isEmpty())
workingDirectory = QFileInfo(file()->fileName()).absolutePath();
return workingDirectory;
}
-ProjectExplorer::Environment Qt4Project::baseEnvironment(const QString &buildConfiguration) const
+ProjectExplorer::Environment Qt4Project::baseEnvironment(BuildConfiguration *configuration) const
{
- Environment env = useSystemEnvironment(buildConfiguration) ? Environment::systemEnvironment() : Environment();
- qtVersion(buildConfiguration)->addToEnvironment(env);
- ToolChain *tc = toolChain(buildConfiguration);
+ Environment env = useSystemEnvironment(configuration) ? Environment::systemEnvironment() : Environment();
+ qtVersion(configuration)->addToEnvironment(env);
+ ToolChain *tc = toolChain(configuration);
if (tc)
tc->addToEnvironment(env);
return env;
}
-ProjectExplorer::Environment Qt4Project::environment(const QString &buildConfiguration) const
+ProjectExplorer::Environment Qt4Project::environment(BuildConfiguration *configuration) const
{
- Environment env = baseEnvironment(buildConfiguration);
- env.modify(userEnvironmentChanges(buildConfiguration));
+ Environment env = baseEnvironment(configuration);
+ env.modify(userEnvironmentChanges(configuration));
return env;
}
-void Qt4Project::setUseSystemEnvironment(const QString &buildConfiguration, bool b)
+void Qt4Project::setUseSystemEnvironment(BuildConfiguration *configuration, bool b)
{
- if (useSystemEnvironment(buildConfiguration) == b)
+ if (useSystemEnvironment(configuration) == b)
return;
- setValue(buildConfiguration, "clearSystemEnvironment", !b);
- emit environmentChanged(buildConfiguration);
+ configuration->setValue("clearSystemEnvironment", !b);
+ emit environmentChanged(configuration->name());
}
-bool Qt4Project::useSystemEnvironment(const QString &buildConfiguration) const
+bool Qt4Project::useSystemEnvironment(BuildConfiguration *configuration) const
{
- bool b = !(value(buildConfiguration, "clearSystemEnvironment").isValid() && value(buildConfiguration, "clearSystemEnvironment").toBool());
+ bool b = !(configuration->value("clearSystemEnvironment").isValid()
+ && configuration->value("clearSystemEnvironment").toBool());
return b;
}
-QList<ProjectExplorer::EnvironmentItem> Qt4Project::userEnvironmentChanges(const QString &buildConfig) const
+QList<ProjectExplorer::EnvironmentItem> Qt4Project::userEnvironmentChanges(BuildConfiguration *configuration) const
{
- return EnvironmentItem::fromStringList(value(buildConfig, "userEnvironmentChanges").toStringList());
+ return EnvironmentItem::fromStringList(configuration->value("userEnvironmentChanges").toStringList());
}
-void Qt4Project::setUserEnvironmentChanges(const QString &buildConfig, const QList<ProjectExplorer::EnvironmentItem> &diff)
+void Qt4Project::setUserEnvironmentChanges(BuildConfiguration *configuration, const QList<ProjectExplorer::EnvironmentItem> &diff)
{
QStringList list = EnvironmentItem::toStringList(diff);
- if (list == value(buildConfig, "userEnvironmentChanges").toStringList())
+ if (list == configuration->value("userEnvironmentChanges").toStringList())
return;
- setValue(buildConfig, "userEnvironmentChanges", list);
- emit environmentChanged(buildConfig);
+ configuration->setValue("userEnvironmentChanges", list);
+ emit environmentChanged(configuration->name());
}
-QString Qt4Project::qtDir(const QString &buildConfiguration) const
+QString Qt4Project::qtDir(BuildConfiguration *configuration) const
{
- QtVersion *version = qtVersion(buildConfiguration);
+ QtVersion *version = qtVersion(configuration);
if (version)
return version->versionInfo().value("QT_INSTALL_DATA");
return QString::null;
}
-QtVersion *Qt4Project::qtVersion(const QString &buildConfiguration) const
+QtVersion *Qt4Project::qtVersion(BuildConfiguration *configuration) const
{
- return QtVersionManager::instance()->version(qtVersionId(buildConfiguration));
+ return QtVersionManager::instance()->version(qtVersionId(configuration));
}
-int Qt4Project::qtVersionId(const QString &buildConfiguration) const
+int Qt4Project::qtVersionId(BuildConfiguration *configuration) const
{
QtVersionManager *vm = QtVersionManager::instance();
if (debug)
- qDebug()<<"Looking for qtVersion ID of "<<buildConfiguration;
+ qDebug()<<"Looking for qtVersion ID of "<<configuration->name();
int id = 0;
- QVariant vid = value(buildConfiguration, "QtVersionId");
+ QVariant vid = configuration->value("QtVersionId");
if (vid.isValid()) {
id = vid.toInt();
if (vm->version(id)->isValid()) {
return id;
} else {
- const_cast<Qt4Project *>(this)->setValue(buildConfiguration, "QtVersionId", 0);
+ configuration->setValue("QtVersionId", 0);
return 0;
}
} else {
// Backward compatibilty, we might have just the name:
- QString vname = value(buildConfiguration, "QtVersion").toString();
+ QString vname = configuration->value("QtVersion").toString();
if (debug)
qDebug()<<" Backward compatibility reading QtVersion"<<vname;
if (!vname.isEmpty()) {
@@ -862,7 +911,7 @@ int Qt4Project::qtVersionId(const QString &buildConfiguration) const
if (version->name() == vname) {
if (debug)
qDebug()<<"found name in versions";
- const_cast<Qt4Project *>(this)->setValue(buildConfiguration, "QtVersionId", version->uniqueId());
+ configuration->setValue("QtVersionId", version->uniqueId());
return version->uniqueId();
}
}
@@ -871,19 +920,19 @@ int Qt4Project::qtVersionId(const QString &buildConfiguration) const
if (debug)
qDebug()<<" using qtversion with id ="<<id;
// Nothing found, reset to default
- const_cast<Qt4Project *>(this)->setValue(buildConfiguration, "QtVersionId", id);
+ configuration->setValue("QtVersionId", id);
return id;
}
-void Qt4Project::setQtVersion(const QString &buildConfiguration, int id)
+void Qt4Project::setQtVersion(BuildConfiguration *configuration, int id)
{
- setValue(buildConfiguration, "QtVersionId", id);
+ configuration->setValue("QtVersionId", id);
updateActiveRunConfiguration();
}
-void Qt4Project::setToolChainType(const QString &buildConfiguration, ProjectExplorer::ToolChain::ToolChainType type)
+void Qt4Project::setToolChainType(BuildConfiguration *configuration, ProjectExplorer::ToolChain::ToolChainType type)
{
- setValue(buildConfiguration, "ToolChain", (int)type);
+ configuration->setValue("ToolChain", (int)type);
updateActiveRunConfiguration();
}
@@ -902,16 +951,16 @@ void Qt4Project::updateActiveRunConfiguration()
emit invalidateCachedTargetInformation();
}
-ProjectExplorer::ToolChain::ToolChainType Qt4Project::toolChainType(const QString &buildConfiguration) const
+ProjectExplorer::ToolChain::ToolChainType Qt4Project::toolChainType(BuildConfiguration *configuration) const
{
const ProjectExplorer::ToolChain::ToolChainType originalType =
- (ProjectExplorer::ToolChain::ToolChainType)value(buildConfiguration, "ToolChain").toInt();
+ (ProjectExplorer::ToolChain::ToolChainType)configuration->value("ToolChain").toInt();
ProjectExplorer::ToolChain::ToolChainType type = originalType;
- const QtVersion *version = qtVersion(buildConfiguration);
+ const QtVersion *version = qtVersion(configuration);
if (!version->possibleToolChainTypes().contains(type)) // use default tool chain
type = version->defaultToolchainType();
if (type != originalType)
- const_cast<Qt4Project *>(this)->setToolChainType(buildConfiguration, type);
+ const_cast<Qt4Project *>(this)->setToolChainType(configuration, type);
return type;
}
@@ -1142,22 +1191,22 @@ QString Qt4Project::extractSpecFromArgumentList(const QStringList &list)
}
// returns true if both are equal
-bool Qt4Project::compareBuildConfigurationToImportFrom(const QString &buildConfiguration, const QString &workingDirectory)
+bool Qt4Project::compareBuildConfigurationToImportFrom(BuildConfiguration *configuration, const QString &workingDirectory)
{
QMakeStep *qs = qmakeStep();
if (QDir(workingDirectory).exists(QLatin1String("Makefile")) && qs) {
QString qmakePath = QtVersionManager::findQMakeBinaryFromMakefile(workingDirectory);
- QtVersion *version = qtVersion(buildConfiguration);
+ QtVersion *version = qtVersion(configuration);
if (version->qmakeCommand() == qmakePath) {
// same qtversion
QPair<QtVersion::QmakeBuildConfig, QStringList> result =
QtVersionManager::scanMakeFile(workingDirectory, version->defaultBuildConfig());
- if (QtVersion::QmakeBuildConfig(value(buildConfiguration, "buildConfiguration").toInt()) == result.first) {
+ if (QtVersion::QmakeBuildConfig(configuration->value("buildConfiguration").toInt()) == result.first) {
// The QMake Build Configuration are the same,
// now compare arguments lists
// we have to compare without the spec/platform cmd argument
// and compare that on its own
- QString actualSpec = extractSpecFromArgumentList(qs->value(buildConfiguration, "qmakeArgs").toStringList());
+ QString actualSpec = extractSpecFromArgumentList(qs->value(configuration->name(), "qmakeArgs").toStringList());
if (actualSpec.isEmpty())
actualSpec = version->mkspec();
@@ -1186,7 +1235,7 @@ bool Qt4Project::compareBuildConfigurationToImportFrom(const QString &buildConfi
if (QFileInfo(parsedSpec).isRelative())
parsedSpec = QDir::cleanPath(workingDirectory + "/" + parsedSpec);
- QStringList actualArgs = removeSpecFromArgumentList(qs->value(buildConfiguration, "qmakeArgs").toStringList());
+ QStringList actualArgs = removeSpecFromArgumentList(qs->value(configuration->name(), "qmakeArgs").toStringList());
QStringList parsedArgs = removeSpecFromArgumentList(result.second);
#ifdef Q_OS_WIN
diff --git a/src/plugins/qt4projectmanager/qt4project.h b/src/plugins/qt4projectmanager/qt4project.h
index c9f4ae0f3034af685323fdb322182882b3b332f3..2d63fcc037153c6af0de81a514e2bab347e812b4 100644
--- a/src/plugins/qt4projectmanager/qt4project.h
+++ b/src/plugins/qt4projectmanager/qt4project.h
@@ -39,6 +39,7 @@
#include <projectexplorer/applicationrunconfiguration.h>
#include <projectexplorer/projectnodes.h>
#include <projectexplorer/toolchain.h>
+#include <projectexplorer/buildconfiguration.h>
#include <cpptools/cppmodelmanagerinterface.h>
#include <QtCore/QObject>
@@ -116,6 +117,24 @@ private:
QString m_filePath;
};
+class Qt4BuildConfigurationFactory : public ProjectExplorer::IBuildConfigurationFactory
+{
+ Q_OBJECT
+
+public:
+ Qt4BuildConfigurationFactory(Qt4Project *project);
+ ~Qt4BuildConfigurationFactory();
+
+ QStringList availableCreationTypes() const;
+ QString displayNameForType(const QString &type) const;
+
+ QList<ProjectExplorer::BuildConfiguration *> create(const QString &type) const;
+ QList<ProjectExplorer::BuildConfiguration *> createDefaultConfigurations() const;
+
+private:
+ Qt4Project *m_project;
+};
+
class Qt4Project : public ProjectExplorer::Project
{
Q_OBJECT
@@ -128,6 +147,7 @@ public:
Core::IFile *file() const;
ProjectExplorer::IProjectManager *projectManager() const;
Qt4Manager *qt4ProjectManager() const;
+ ProjectExplorer::IBuildConfigurationFactory *buildConfigurationFactory() const;
QList<Core::IFile *> dependencies(); //NBS remove
QList<ProjectExplorer::Project *>dependsOn();
@@ -139,38 +159,37 @@ public:
virtual QStringList files(FilesMode fileMode) const;
//building environment
- ProjectExplorer::Environment environment(const QString &buildConfiguration) const;
- ProjectExplorer::Environment baseEnvironment(const QString &buildConfiguration) const;
- void setUserEnvironmentChanges(const QString &buildConfig, const QList<ProjectExplorer::EnvironmentItem> &diff);
- QList<ProjectExplorer::EnvironmentItem> userEnvironmentChanges(const QString &buildConfig) const;
- bool useSystemEnvironment(const QString &buildConfiguration) const;
- void setUseSystemEnvironment(const QString &buildConfiguration, bool b);
-
- virtual QString buildDirectory(const QString &buildConfiguration) const;
+ ProjectExplorer::Environment environment(ProjectExplorer::BuildConfiguration *configuration) const;
+ ProjectExplorer::Environment baseEnvironment(ProjectExplorer::BuildConfiguration *configuration) const;
+ void setUserEnvironmentChanges(ProjectExplorer::BuildConfiguration *configuration, const QList<ProjectExplorer::EnvironmentItem> &diff);
+ QList<ProjectExplorer::EnvironmentItem> userEnvironmentChanges(ProjectExplorer::BuildConfiguration *configuration) const;
+ bool useSystemEnvironment(ProjectExplorer::BuildConfiguration *configuration) const;
+ void setUseSystemEnvironment(ProjectExplorer::BuildConfiguration *configuration, bool b);
+
+ virtual QString buildDirectory(ProjectExplorer::BuildConfiguration *configuration) const;
// returns the CONFIG variable from the .pro file
QStringList qmakeConfig() const;
// returns the qtdir (depends on the current QtVersion)
- QString qtDir(const QString &buildConfiguration) const;
+ QString qtDir(ProjectExplorer::BuildConfiguration *configuration) const;
//returns the qtVersion, if the project is set to use the default qt version, then
// that is returned
// to check wheter the project uses the default qt version use qtVersionId
- QtVersion *qtVersion(const QString &buildConfiguration) const;
+ QtVersion *qtVersion(ProjectExplorer::BuildConfiguration *configuration) const;
// returns the id of the qt version, if the project is using the default qt version
// this function returns 0
- int qtVersionId(const QString &buildConfiguration) const;
+ int qtVersionId(ProjectExplorer::BuildConfiguration *configuration) const;
//returns the name of the qt version, might be QString::Null, which means default qt version
// qtVersion is in general the better method to use
- QString qtVersionName(const QString &buildConfiguration) const;
- ProjectExplorer::ToolChain *toolChain(const QString &buildConfiguration) const;
- void setToolChainType(const QString &buildConfiguration, ProjectExplorer::ToolChain::ToolChainType type);
- ProjectExplorer::ToolChain::ToolChainType toolChainType(const QString &buildConfiguration) const;
+ QString qtVersionName(ProjectExplorer::BuildConfiguration *configuration) const;
+ ProjectExplorer::ToolChain *toolChain(ProjectExplorer::BuildConfiguration *configuration) const;
+ void setToolChainType(ProjectExplorer::BuildConfiguration *configuration, ProjectExplorer::ToolChain::ToolChainType type);
+ ProjectExplorer::ToolChain::ToolChainType toolChainType(ProjectExplorer::BuildConfiguration *configuration) const;
ProjectExplorer::BuildConfigWidget *createConfigWidget();
QList<ProjectExplorer::BuildConfigWidget*> subConfigWidgets();
- void setQtVersion(const QString &buildConfiguration, int id);
- virtual bool newBuildConfiguration(const QString &buildConfiguration);
+ void setQtVersion(ProjectExplorer::BuildConfiguration *configuration, int id);
QList<Internal::Qt4ProFileNode *> applicationProFiles() const;
@@ -184,8 +203,8 @@ public:
void notifyChanged(const QString &name);
- QString makeCommand(const QString &buildConfiguration) const;
- QString defaultMakeTarget(const QString &buildConfiguration) const;
+ QString makeCommand(ProjectExplorer::BuildConfiguration *configuration) const;
+ QString defaultMakeTarget(ProjectExplorer::BuildConfiguration *configuration) const;
// Is called by qmakestep qt4configurationwidget if the settings change
// Informs all Qt4RunConfigurations that their cached values are now invalid
@@ -196,7 +215,7 @@ public:
virtual QStringList includePaths(const QString &fileName) const;
virtual QStringList frameworkPaths(const QString &fileName) const;
- bool compareBuildConfigurationToImportFrom(const QString &buildConfiguration, const QString &workingDirectory);
+ bool compareBuildConfigurationToImportFrom(ProjectExplorer::BuildConfiguration *configuration, const QString &workingDirectory);
static QStringList removeSpecFromArgumentList(const QStringList &old);
static QString extractSpecFromArgumentList(const QStringList &list);
@@ -242,6 +261,7 @@ private:
Qt4Manager *m_manager;
Internal::Qt4ProFileNode *m_rootProjectNode;
Internal::Qt4NodesWatcher *m_nodesWatcher;
+ Qt4BuildConfigurationFactory *m_buildConfigurationFactory;
Qt4ProjectFile *m_fileInfo;
bool m_isApplication;
diff --git a/src/plugins/qt4projectmanager/qt4projectconfigwidget.cpp b/src/plugins/qt4projectmanager/qt4projectconfigwidget.cpp
index 2105f0499638c0dcc33c1177b996b21f37f3ad5b..539cfd105bf6ca89b9cc5297e3656ac6a3d15d03 100644
--- a/src/plugins/qt4projectmanager/qt4projectconfigwidget.cpp
+++ b/src/plugins/qt4projectmanager/qt4projectconfigwidget.cpp
@@ -136,9 +136,10 @@ void Qt4ProjectConfigWidget::toggleDetails()
void Qt4ProjectConfigWidget::updateDetails()
{
- QtVersion *version = m_pro->qtVersion(m_buildConfiguration);
+ ProjectExplorer::BuildConfiguration *bc = m_pro->buildConfiguration(m_buildConfiguration);
+ QtVersion *version = m_pro->qtVersion(bc);
QString versionString;
- if (m_pro->qtVersionId(m_buildConfiguration) == 0) {
+ if (m_pro->qtVersionId(bc) == 0) {
versionString = tr("Default Qt Version (%1)").arg(version->name());
} else if(version){
versionString = version->name();
@@ -150,8 +151,8 @@ void Qt4ProjectConfigWidget::updateDetails()
"with tool chain <b>%2</b><br>"
"building in <b>%3</b>")
.arg(versionString,
- ProjectExplorer::ToolChain::toolChainName(m_pro->toolChainType(m_buildConfiguration)),
- QDir::toNativeSeparators(m_pro->buildDirectory(m_buildConfiguration))));
+ ProjectExplorer::ToolChain::toolChainName(m_pro->toolChainType(bc)),
+ QDir::toNativeSeparators(m_pro->buildDirectory(bc))));
}
void Qt4ProjectConfigWidget::manageQtVersions()
@@ -172,16 +173,16 @@ void Qt4ProjectConfigWidget::init(const QString &buildConfiguration)
qDebug() << "Qt4ProjectConfigWidget::init()";
m_buildConfiguration = buildConfiguration;
-
- m_ui->nameLineEdit->setText(m_pro->buildConfiguration(m_buildConfiguration)->displayName());
+ ProjectExplorer::BuildConfiguration *bc = m_pro->buildConfiguration(buildConfiguration);
+ m_ui->nameLineEdit->setText(bc->displayName());
setupQtVersionsComboBox();
- bool shadowBuild = m_pro->value(buildConfiguration, "useShadowBuild").toBool();
+ bool shadowBuild = bc->value("useShadowBuild").toBool();
m_ui->shadowBuildCheckBox->setChecked(shadowBuild);
m_ui->shadowBuildDirEdit->setEnabled(shadowBuild);
m_browseButton->setEnabled(shadowBuild);
- m_ui->shadowBuildDirEdit->setPath(m_pro->buildDirectory(buildConfiguration));
+ m_ui->shadowBuildDirEdit->setPath(m_pro->buildDirectory(bc));
updateImportLabel();
updateToolChainCombo();
updateDetails();
@@ -205,7 +206,8 @@ void Qt4ProjectConfigWidget::setupQtVersionsComboBox()
m_ui->qtVersionComboBox->clear();
m_ui->qtVersionComboBox->addItem(tr("Default Qt Version (%1)").arg(vm->defaultVersion()->name()), 0);
- if (m_pro->qtVersionId(m_buildConfiguration) == 0) {
+ int qtVersionId = m_pro->qtVersionId(m_pro->buildConfiguration(m_buildConfiguration));
+ if (qtVersionId == 0) {
m_ui->qtVersionComboBox->setCurrentIndex(0);
m_ui->invalidQtWarningLabel->setVisible(false);
}
@@ -214,7 +216,7 @@ void Qt4ProjectConfigWidget::setupQtVersionsComboBox()
for (int i = 0; i < versions.size(); ++i) {
m_ui->qtVersionComboBox->addItem(versions.at(i)->name(), versions.at(i)->uniqueId());
- if (versions.at(i)->uniqueId() == m_pro->qtVersionId(m_buildConfiguration)) {
+ if (versions.at(i)->uniqueId() == qtVersionId) {
m_ui->qtVersionComboBox->setCurrentIndex(i + 1);
m_ui->invalidQtWarningLabel->setVisible(!versions.at(i)->isValid());
}
@@ -251,8 +253,9 @@ void Qt4ProjectConfigWidget::updateImportLabel()
// we only show if we actually have a qmake and makestep
if (m_pro->qmakeStep() && m_pro->makeStep()) {
- QString qmakePath = QtVersionManager::findQMakeBinaryFromMakefile(m_pro->buildDirectory(m_buildConfiguration));
- QtVersion *version = m_pro->qtVersion(m_buildConfiguration);
+ ProjectExplorer::BuildConfiguration *bc = m_pro->buildConfiguration(m_buildConfiguration);
+ QString qmakePath = QtVersionManager::findQMakeBinaryFromMakefile(m_pro->buildDirectory(bc));
+ QtVersion *version = m_pro->qtVersion(bc);
// check that there's a makefile
if (!qmakePath.isEmpty()) {
// and that the qmake path is different from the current version
@@ -261,7 +264,7 @@ void Qt4ProjectConfigWidget::updateImportLabel()
visible = true;
} else {
// check that the qmake flags, arguments match
- visible = !m_pro->compareBuildConfigurationToImportFrom(m_buildConfiguration, m_pro->buildDirectory(m_buildConfiguration));
+ visible = !m_pro->compareBuildConfigurationToImportFrom(bc, m_pro->buildDirectory(bc));
}
} else {
visible = false;
@@ -289,7 +292,8 @@ void Qt4ProjectConfigWidget::importLabelClicked()
{
if (!m_pro->qmakeStep() || !m_pro->makeStep())
return;
- QString directory = m_pro->buildDirectory(m_buildConfiguration);
+ ProjectExplorer::BuildConfiguration *bc = m_pro->buildConfiguration(m_buildConfiguration);
+ QString directory = m_pro->buildDirectory(bc);
if (!directory.isEmpty()) {
QString qmakePath = QtVersionManager::findQMakeBinaryFromMakefile(directory);
if (!qmakePath.isEmpty()) {
@@ -317,14 +321,14 @@ void Qt4ProjectConfigWidget::importLabelClicked()
}
// So we got all the information now apply it...
- m_pro->setQtVersion(m_buildConfiguration, version->uniqueId());
+ m_pro->setQtVersion(bc, version->uniqueId());
// Combo box will be updated at the end
QMakeStep *qmakeStep = m_pro->qmakeStep();
qmakeStep->setQMakeArguments(m_buildConfiguration, additionalArguments);
MakeStep *makeStep = m_pro->makeStep();
- m_pro->setValue(m_buildConfiguration, "buildConfiguration", int(qmakeBuildConfig));
+ bc->setValue("buildConfiguration", int(qmakeBuildConfig));
// Adjust command line arguments, this is ugly as hell
// If we are switching to BuildAll we want "release" in there and no "debug"
// or "debug" in there and no "release"
@@ -358,8 +362,8 @@ void Qt4ProjectConfigWidget::qtVersionComboBoxCurrentIndexChanged(const QString
QtVersionManager *vm = QtVersionManager::instance();
bool isValid = vm->version(newQtVersion)->isValid();
m_ui->invalidQtWarningLabel->setVisible(!isValid);
- if (newQtVersion != m_pro->qtVersionId(m_buildConfiguration)) {
- m_pro->setQtVersion(m_buildConfiguration, newQtVersion);
+ if (newQtVersion != m_pro->qtVersionId(m_pro->buildConfiguration(m_buildConfiguration))) {
+ m_pro->setQtVersion(m_pro->buildConfiguration(m_buildConfiguration), newQtVersion);
updateToolChainCombo();
m_pro->update();
}
@@ -369,13 +373,14 @@ void Qt4ProjectConfigWidget::qtVersionComboBoxCurrentIndexChanged(const QString
void Qt4ProjectConfigWidget::updateToolChainCombo()
{
m_ui->toolChainComboBox->clear();
- QList<ProjectExplorer::ToolChain::ToolChainType> toolchains = m_pro->qtVersion(m_buildConfiguration)->possibleToolChainTypes();
+ ProjectExplorer::BuildConfiguration *bc = m_pro->buildConfiguration(m_buildConfiguration);
+ QList<ProjectExplorer::ToolChain::ToolChainType> toolchains = m_pro->qtVersion(bc)->possibleToolChainTypes();
using namespace ProjectExplorer;
foreach (ToolChain::ToolChainType toolchain, toolchains) {
m_ui->toolChainComboBox->addItem(ToolChain::toolChainName(toolchain), qVariantFromValue(toolchain));
}
m_ui->toolChainComboBox->setEnabled(toolchains.size() > 1);
- setToolChain(toolchains.indexOf(m_pro->toolChainType(m_buildConfiguration)));
+ setToolChain(toolchains.indexOf(m_pro->toolChainType(bc)));
}
void Qt4ProjectConfigWidget::selectToolChain(int index)
@@ -389,7 +394,7 @@ void Qt4ProjectConfigWidget::setToolChain(int index)
ProjectExplorer::ToolChain::ToolChainType selectedToolChainType =
m_ui->toolChainComboBox->itemData(index,
Qt::UserRole).value<ProjectExplorer::ToolChain::ToolChainType>();
- m_pro->setToolChainType(m_buildConfiguration, selectedToolChainType);
+ m_pro->setToolChainType(m_pro->buildConfiguration(m_buildConfiguration), selectedToolChainType);
if (m_ui->toolChainComboBox->currentIndex() != index)
m_ui->toolChainComboBox->setCurrentIndex(index);
updateDetails();
diff --git a/src/plugins/qt4projectmanager/qt4projectmanager.cpp b/src/plugins/qt4projectmanager/qt4projectmanager.cpp
index f0e9c56a0b6269227720917a5d1ab77402e8c323..04d32a826baa7892d4e59c172f8ead1d5d844ec0 100644
--- a/src/plugins/qt4projectmanager/qt4projectmanager.cpp
+++ b/src/plugins/qt4projectmanager/qt4projectmanager.cpp
@@ -262,8 +262,7 @@ void Qt4Manager::runQMake(ProjectExplorer::Project *p)
return;
//found qmakeStep, now use it
qs->setForced(true);
- const QString &config = p->activeBuildConfiguration();
- m_projectExplorer->buildManager()->appendStep(qs, config);
+ m_projectExplorer->buildManager()->appendStep(qs, p->activeBuildConfiguration()->name());
}
QString Qt4Manager::fileTypeId(ProjectExplorer::FileType type)
diff --git a/src/plugins/qt4projectmanager/qt4runconfiguration.cpp b/src/plugins/qt4projectmanager/qt4runconfiguration.cpp
index 249386e2eb096d5635dd372348cc8bcef755b89d..cd5e80664cc8965eea5c7ce17fb9f7a76bf8d058 100644
--- a/src/plugins/qt4projectmanager/qt4runconfiguration.cpp
+++ b/src/plugins/qt4projectmanager/qt4runconfiguration.cpp
@@ -491,7 +491,6 @@ ProjectExplorer::Environment Qt4RunConfiguration::baseEnvironment() const
} else if (m_baseEnvironmentBase == Qt4RunConfiguration::SystemEnvironmentBase) {
env = ProjectExplorer::Environment::systemEnvironment();
} else if (m_baseEnvironmentBase == Qt4RunConfiguration::BuildEnvironmentBase) {
- QString config = project()->activeBuildConfiguration();
env = project()->environment(project()->activeBuildConfiguration());
}
if (m_isUsingDyldImageSuffix) {
@@ -582,7 +581,7 @@ void Qt4RunConfiguration::updateTarget()
// Find out what flags we pass on to qmake, this code is duplicated in the qmake step
QtVersion::QmakeBuildConfig defaultBuildConfiguration = pro->qtVersion(pro->activeBuildConfiguration())->defaultBuildConfig();
- QtVersion::QmakeBuildConfig projectBuildConfiguration = QtVersion::QmakeBuildConfig(pro->value(pro->activeBuildConfiguration(), "buildConfiguration").toInt());
+ QtVersion::QmakeBuildConfig projectBuildConfiguration = QtVersion::QmakeBuildConfig(pro->activeBuildConfiguration()->value("buildConfiguration").toInt());
QStringList addedUserConfigArguments;
QStringList removedUserConfigArguments;
if ((defaultBuildConfiguration & QtVersion::BuildAll) && !(projectBuildConfiguration & QtVersion::BuildAll))