feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Changing string based api to BuildConfiguration based api.

Browse Source 
Builds, but I'm pretty sure it doesn't *work* :)
This commit is contained in:
con
2009-09-24 16:02:02 +02:00
parent 30362e1050
commit acbd4513e3
30 changed files with 737 additions and 440 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/plugins/cmakeprojectmanager/cmakebuildenvironmentwidget.cpp
+9 -7
View File
@@ -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));
}
src/plugins/cmakeprojectmanager/cmakeproject.cpp
+139 -59
View File
@@ -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));
}
}
src/plugins/cmakeprojectmanager/cmakeproject.h
+31 -15
View File
@@ -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;
src/plugins/cmakeprojectmanager/cmakerunconfiguration.cpp
-1
View File
@@ -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;
src/plugins/cmakeprojectmanager/makestep.cpp
+8 -5
View File
@@ -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();
}
src/plugins/genericprojectmanager/genericmakestep.cpp
+10 -9
View File
@@ -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
src/plugins/genericprojectmanager/genericproject.cpp
+59 -16
View File
@@ -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()
src/plugins/genericprojectmanager/genericproject.h
+26 -6
View File
@@ -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;
src/plugins/projectexplorer/buildconfiguration.cpp
+21 -7
View File
@@ -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()
{
}
src/plugins/projectexplorer/buildconfiguration.h
+24 -4
View File
@@ -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
src/plugins/projectexplorer/buildmanager.h
+1
View File
@@ -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);
src/plugins/projectexplorer/buildsettingspropertiespage.cpp
+50 -51
View File
@@ -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();
}
src/plugins/projectexplorer/customexecutablerunconfiguration.cpp
+2 -3
View File
@@ -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;
src/plugins/projectexplorer/processstep.cpp
+6 -5
View File
@@ -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)
src/plugins/projectexplorer/project.cpp
+67 -44
View File
@@ -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);
// 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(name);
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)
src/plugins/projectexplorer/project.h
+11 -15
View File
@@ -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 };
src/plugins/projectexplorer/projectexplorer.cpp
+13 -12
View File
@@ -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()
src/plugins/projectexplorer/projectwindow.cpp
+8 -8
View File
@@ -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()));
}
///
src/plugins/qmlprojectmanager/qmlproject.cpp
+9 -5
View File
@@ -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
src/plugins/qmlprojectmanager/qmlproject.h
+4 -4
View File
@@ -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,
src/plugins/qt4projectmanager/deployhelper.cpp
+1 -2
View File
@@ -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
src/plugins/qt4projectmanager/makestep.cpp
+18 -15
View File
@@ -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) {
src/plugins/qt4projectmanager/projectloadwizard.cpp
+10 -15
View File
@@ -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))
src/plugins/qt4projectmanager/qmakestep.cpp
+15 -11
View File
@@ -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)));
src/plugins/qt4projectmanager/qt4buildenvironmentwidget.cpp
+9 -7
View File
@@ -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));
}
src/plugins/qt4projectmanager/qt4project.cpp
+119 -70
View File
@@ -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
src/plugins/qt4projectmanager/qt4project.h
+39 -19
View File
@@ -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);
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(const QString &buildConfiguration) const;
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;
src/plugins/qt4projectmanager/qt4projectconfigwidget.cpp
+26 -21
View File
@@ -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();
src/plugins/qt4projectmanager/qt4projectmanager.cpp
+1 -2
View File
@@ -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)
src/plugins/qt4projectmanager/qt4runconfiguration.cpp
+1 -2
View File
@@ -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))