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

Remove value(name) and setValue(name, value) from BuildStep

Browse Source
This commit is contained in:
dt
2009-10-15 19:06:51 +02:00
parent 0fa60aa3d8
commit 72fe54db77
19 changed files with 621 additions and 380 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/plugins/cmakeprojectmanager/cmakeproject.cpp
View File

@@ -667,7 +667,7 @@ bool CMakeProject::restoreSettingsImpl(ProjectExplorer::PersistentSettingsReader
MakeStep *cleanMakeStep = new MakeStep(this);
insertCleanStep(0, cleanMakeStep);
cleanMakeStep->setValue("clean", true);
cleanMakeStep->setClean(true);
setActiveBuildConfiguration(bc);
} else {
// We have a user file, but we could still be missing the cbp file

92
src/plugins/cmakeprojectmanager/makestep.cpp
View File

@@ -42,7 +42,7 @@ using namespace CMakeProjectManager;
using namespace CMakeProjectManager::Internal;
MakeStep::MakeStep(CMakeProject *pro)
: AbstractMakeStep(pro), m_pro(pro)
: AbstractMakeStep(pro), m_pro(pro), m_clean(false)
{
m_percentProgress = QRegExp("^\\[\\s*(\\d*)%\\]");
}
@@ -52,27 +52,70 @@ MakeStep::~MakeStep()
}
void MakeStep::setClean(bool clean)
{
m_clean = clean;
}
void MakeStep::restoreFromMap(const QMap<QString, QVariant> &map)
{
if (map.value("clean").isValid() && map.value("clean").toBool())
m_clean = true;
ProjectExplorer::AbstractMakeStep::restoreFromMap(map);
}
void MakeStep::storeIntoMap(QMap<QString, QVariant> &map)
{
if (m_clean)
map["clean"] = true;
ProjectExplorer::AbstractMakeStep::storeIntoMap(map);
}
void MakeStep::restoreFromMap(const QString &buildConfiguration, const QMap<QString, QVariant> &map)
{
m_values[buildConfiguration].buildTargets = map["buildTargets"].toStringList();
m_values[buildConfiguration].additionalArguments = map["additionalArguments"].toStringList();
ProjectExplorer::AbstractMakeStep::restoreFromMap(buildConfiguration, map);
}
void MakeStep::storeIntoMap(const QString &buildConfiguration, QMap<QString, QVariant> &map)
{
map["buildTargets"] = m_values.value(buildConfiguration).buildTargets;
map["additionalArguments"] = m_values.value(buildConfiguration).additionalArguments;
ProjectExplorer::AbstractMakeStep::storeIntoMap(buildConfiguration, map);
}
void MakeStep::addBuildConfiguration(const QString & name)
{
m_values.insert(name, MakeStepSettings());
}
void MakeStep::removeBuildConfiguration(const QString & name)
{
m_values.remove(name);
}
void MakeStep::copyBuildConfiguration(const QString &source, const QString &dest)
{
m_values.insert(dest, m_values.value(source));
}
bool MakeStep::init(const QString &buildConfiguration)
{
ProjectExplorer::BuildConfiguration *bc = m_pro->buildConfiguration(buildConfiguration);
setBuildParser(m_pro->buildParser(bc));
setEnabled(buildConfiguration, true);
setWorkingDirectory(buildConfiguration, m_pro->buildDirectory(bc));
setEnabled(true);
setWorkingDirectory(m_pro->buildDirectory(bc));
setCommand(buildConfiguration, m_pro->toolChain(bc)->makeCommand());
setCommand(m_pro->toolChain(bc)->makeCommand());
if (!value(buildConfiguration, "cleanConfig").isValid() &&value("clean").isValid() && value("clean").toBool()) {
// Import old settings
setValue(buildConfiguration, "cleanConfig", true);
setAdditionalArguments(buildConfiguration, QStringList() << "clean");
}
QStringList arguments = value(buildConfiguration, "buildTargets").toStringList();
QStringList arguments = m_values.value(buildConfiguration).buildTargets;
arguments << additionalArguments(buildConfiguration);
setArguments(buildConfiguration, arguments); // TODO
setEnvironment(buildConfiguration, m_pro->environment(bc));
setIgnoreReturnValue(buildConfiguration, value(buildConfiguration, "cleanConfig").isValid());
setArguments(arguments); // TODO
setEnvironment(m_pro->environment(bc));
setIgnoreReturnValue(m_clean);
return AbstractMakeStep::init(buildConfiguration);
}
@@ -125,28 +168,27 @@ CMakeProject *MakeStep::project() const
bool MakeStep::buildsTarget(const QString &buildConfiguration, const QString &target) const
{
return value(buildConfiguration, "buildTargets").toStringList().contains(target);
return m_values.value(buildConfiguration).buildTargets.contains(target);
}
void MakeStep::setBuildTarget(const QString &buildConfiguration, const QString &target, bool on)
{
QStringList old = value(buildConfiguration, "buildTargets").toStringList();
QStringList old = m_values.value(buildConfiguration).buildTargets;
if (on && !old.contains(target))
old.append(target);
old << target;
else if(!on && old.contains(target))
old.removeOne(target);
setValue(buildConfiguration, "buildTargets", old);
m_values[buildConfiguration].buildTargets = old;
}
QStringList MakeStep::additionalArguments(const QString &buildConfiguration) const
{
return value(buildConfiguration, "additionalArguments").toStringList();
return m_values.value(buildConfiguration).additionalArguments;
}
void MakeStep::setAdditionalArguments(const QString &buildConfiguration, const QStringList &list)
{
setValue(buildConfiguration, "additionalArguments", list);
m_values[buildConfiguration].additionalArguments = list;
}
//
@@ -202,12 +244,6 @@ QString MakeStepConfigWidget::displayName() const
void MakeStepConfigWidget::init(const QString &buildConfiguration)
{
if (!m_makeStep->value(buildConfiguration, "cleanConfig").isValid() && m_makeStep->value("clean").isValid() && m_makeStep->value("clean").toBool()) {
// Import old settings
m_makeStep->setValue(buildConfiguration, "cleanConfig", true);
m_makeStep->setAdditionalArguments(buildConfiguration, QStringList() << "clean");
}
// disconnect to make the changes to the items
disconnect(m_targetsList, SIGNAL(itemChanged(QListWidgetItem*)), this, SLOT(itemChanged(QListWidgetItem*)));
m_buildConfiguration = buildConfiguration;
@@ -225,7 +261,7 @@ void MakeStepConfigWidget::init(const QString &buildConfiguration)
void MakeStepConfigWidget::updateDetails()
{
QStringList arguments = m_makeStep->value(m_buildConfiguration, "buildTargets").toStringList();
QStringList arguments = m_makeStep->m_values.value(m_buildConfiguration).buildTargets;
arguments << m_makeStep->additionalArguments(m_buildConfiguration);
m_summaryText = tr("<b>Make:</b> %1 %2")
.arg(m_makeStep->project()->toolChain(

22
src/plugins/cmakeprojectmanager/makestep.h
View File

@@ -43,9 +43,17 @@ namespace Internal {
class CMakeProject;
struct MakeStepSettings
{
QStringList buildTargets;
QStringList additionalArguments;
};
class MakeStep : public ProjectExplorer::AbstractMakeStep
{
Q_OBJECT
friend class MakeStepConfigWidget; // TODO remove
// This is for modifying m_values
public:
MakeStep(CMakeProject *pro);
~MakeStep();
@@ -62,13 +70,27 @@ public:
void setBuildTarget(const QString &buildConfiguration, const QString &target, bool on);
QStringList additionalArguments(const QString &buildConfiguration) const;
void setAdditionalArguments(const QString &buildConfiguration, const QStringList &list);
virtual void restoreFromMap(const QMap<QString, QVariant> &map);
virtual void storeIntoMap(QMap<QString, QVariant> &map);
void setClean(bool clean);
virtual void restoreFromMap(const QString &buildConfiguration, const QMap<QString, QVariant> &map);
virtual void storeIntoMap(const QString &buildConfiguration, QMap<QString, QVariant> &map);
virtual void addBuildConfiguration(const QString & name);
virtual void removeBuildConfiguration(const QString & name);
virtual void copyBuildConfiguration(const QString &source, const QString &dest);
protected:
// For parsing [ 76%]
virtual void stdOut(const QString &line);
private:
CMakeProject *m_pro;
bool m_clean;
QRegExp m_percentProgress;
QFutureInterface<bool> *m_futureInterface;
QMap<QString, MakeStepSettings> m_values;
};
class MakeStepConfigWidget :public ProjectExplorer::BuildStepConfigWidget

66
src/plugins/genericprojectmanager/genericmakestep.cpp
View File

@@ -63,24 +63,56 @@ bool GenericMakeStep::init(const QString &buildConfigurationName)
setBuildParser(buildParser);
qDebug() << "*** build parser:" << buildParser;
setEnabled(buildConfigurationName, true);
setEnabled(true);
Core::VariableManager *vm = Core::VariableManager::instance();
const QString rawBuildDir = m_pro->buildDirectory(bc);
const QString buildDir = vm->resolve(rawBuildDir);
setWorkingDirectory(buildConfigurationName, buildDir);
setWorkingDirectory(buildDir);
setCommand(buildConfigurationName, makeCommand(buildConfigurationName));
setArguments(buildConfigurationName, replacedArguments(buildConfigurationName));
setCommand(makeCommand(buildConfigurationName));
setArguments(replacedArguments(buildConfigurationName));
setEnvironment(buildConfigurationName, m_pro->environment(bc));
setEnvironment(m_pro->environment(bc));
return AbstractMakeStep::init(buildConfigurationName);
}
void GenericMakeStep::restoreFromMap(const QString &buildConfiguration, const QMap<QString, QVariant> &map)
{
m_values[buildConfiguration].buildTargets = map.value("buildTargets").toStringList();
m_values[buildConfiguration].makeArguments = map.value("makeArguments").toStringList();
m_values[buildConfiguration].makeCommand = map.value("makeCommand").toString();
ProjectExplorer::AbstractMakeStep::restoreFromMap(buildConfiguration, map);
}
void GenericMakeStep::storeIntoMap(const QString &buildConfiguration, QMap<QString, QVariant> &map)
{
map["buildTargets"] = m_values.value(buildConfiguration).buildTargets;
map["makeArguments"] = m_values.value(buildConfiguration).makeArguments;
map["makeCommand"] = m_values.value(buildConfiguration).makeCommand;
ProjectExplorer::AbstractMakeStep::storeIntoMap(buildConfiguration, map);
}
void GenericMakeStep::addBuildConfiguration(const QString & name)
{
m_values.insert(name, GenericMakeStepSettings());
}
void GenericMakeStep::removeBuildConfiguration(const QString & name)
{
m_values.remove(name);
}
void GenericMakeStep::copyBuildConfiguration(const QString &source, const QString &dest)
{
m_values.insert(dest, m_values.value(source));
}
QStringList GenericMakeStep::replacedArguments(const QString &buildConfiguration) const
{
Core::VariableManager *vm = Core::VariableManager::instance();
const QStringList targets = value(buildConfiguration, "buildTargets").toStringList();
QStringList arguments = value(buildConfiguration, "makeArguments").toStringList();
const QStringList targets = m_values.value(buildConfiguration).buildTargets;
QStringList arguments = m_values.value(buildConfiguration).makeArguments;
QStringList replacedArguments;
foreach (const QString &arg, arguments) {
replacedArguments.append(vm->resolve(arg));
@@ -93,7 +125,7 @@ QStringList GenericMakeStep::replacedArguments(const QString &buildConfiguration
QString GenericMakeStep::makeCommand(const QString &buildConfiguration) const
{
QString command = value(buildConfiguration, "makeCommand").toString();
QString command = m_values.value(buildConfiguration).makeCommand;
if (command.isEmpty()) {
if (ProjectExplorer::ToolChain *toolChain = m_pro->toolChain())
command = toolChain->makeCommand();
@@ -135,17 +167,18 @@ GenericProject *GenericMakeStep::project() const
bool GenericMakeStep::buildsTarget(const QString &buildConfiguration, const QString &target) const
{
return value(buildConfiguration, "buildTargets").toStringList().contains(target);
return m_values.value(buildConfiguration).buildTargets.contains(target);
}
void GenericMakeStep::setBuildTarget(const QString &buildConfiguration, const QString &target, bool on)
{
QStringList old = value(buildConfiguration, "buildTargets").toStringList();
QStringList old = m_values.value(buildConfiguration).buildTargets;
if (on && !old.contains(target))
old << target;
else if(!on && old.contains(target))
old.removeOne(target);
setValue(buildConfiguration, "buildTargets", old);
m_values[buildConfiguration].buildTargets = old;
}
//
@@ -196,11 +229,10 @@ void GenericMakeStepConfigWidget::init(const QString &buildConfiguration)
updateMakeOverrrideLabel();
QString makeCommand = m_makeStep->value(buildConfiguration, "makeCommand").toString();
QString makeCommand = m_makeStep->m_values.value(buildConfiguration).makeCommand;
m_ui->makeLineEdit->setText(makeCommand);
const QStringList &makeArguments =
m_makeStep->value(buildConfiguration, "makeArguments").toStringList();
const QStringList &makeArguments = m_makeStep->m_values.value(buildConfiguration).makeArguments;
m_ui->makeArgumentsLineEdit->setText(ProjectExplorer::Environment::joinArgumentList(makeArguments));
// Disconnect to make the changes to the items
@@ -240,15 +272,15 @@ void GenericMakeStepConfigWidget::itemChanged(QListWidgetItem *item)
void GenericMakeStepConfigWidget::makeLineEditTextEdited()
{
QTC_ASSERT(!m_buildConfiguration.isNull(), return);
m_makeStep->setValue(m_buildConfiguration, "makeCommand", m_ui->makeLineEdit->text());
m_makeStep->m_values[m_buildConfiguration].makeCommand = m_ui->makeLineEdit->text();
updateDetails();
}
void GenericMakeStepConfigWidget::makeArgumentsLineEditTextEdited()
{
QTC_ASSERT(!m_buildConfiguration.isNull(), return);
m_makeStep->setValue(m_buildConfiguration, "makeArguments",
ProjectExplorer::Environment::parseCombinedArgString(m_ui->makeArgumentsLineEdit->text()));
m_makeStep->m_values[m_buildConfiguration].makeArguments =
ProjectExplorer::Environment::parseCombinedArgString(m_ui->makeArgumentsLineEdit->text());
updateDetails();
}

18
src/plugins/genericprojectmanager/genericmakestep.h
View File

@@ -44,10 +44,20 @@ namespace GenericProjectManager {
namespace Internal {
class GenericProject;
class GenericMakeStepConfigWidget;
struct GenericMakeStepSettings
{
QStringList buildTargets;
QStringList makeArguments;
QString makeCommand;
};
class GenericMakeStep : public ProjectExplorer::AbstractMakeStep
{
Q_OBJECT
friend class GenericMakeStepConfigWidget; // TODO remove again?
// Currently the ConfigWidget accesses the m_values directly
public:
GenericMakeStep(GenericProject *pro);
~GenericMakeStep();
@@ -64,8 +74,16 @@ public:
void setBuildTarget(const QString &buildConfiguration, const QString &target, bool on);
QStringList replacedArguments(const QString &buildConfiguration) const;
QString makeCommand(const QString &buildConfiguration) const;
virtual void restoreFromMap(const QString &buildConfiguration, const QMap<QString, QVariant> &map);
virtual void storeIntoMap(const QString &buildConfiguration, QMap<QString, QVariant> &map);
virtual void addBuildConfiguration(const QString & name);
virtual void removeBuildConfiguration(const QString & name);
virtual void copyBuildConfiguration(const QString &source, const QString &dest);
private:
GenericProject *m_pro;
QMap<QString, GenericMakeStepSettings> m_values;
};
class GenericMakeStepConfigWidget :public ProjectExplorer::BuildStepConfigWidget

2
src/plugins/projectexplorer/abstractmakestep.cpp
View File

@@ -64,7 +64,7 @@ bool AbstractMakeStep::init(const QString &buildConfiguration)
m_buildConfiguration = buildConfiguration;
m_openDirectories.clear();
addDirectory(workingDirectory(buildConfiguration));
addDirectory(workingDirectory());
return AbstractProcessStep::init(buildConfiguration);
}

112
src/plugins/projectexplorer/abstractprocessstep.cpp
View File

@@ -39,92 +39,54 @@
using namespace ProjectExplorer;
static const char * const PROCESS_COMMAND = "abstractProcess.command";
static const char * const PROCESS_WORKINGDIRECTORY = "abstractProcess.workingDirectory";
static const char * const PROCESS_ARGUMENTS = "abstractProcess.arguments";
static const char * const PROCESS_ENABLED = "abstractProcess.enabled";
static const char * const PROCESS_ENVIRONMENT = "abstractProcess.Environment";
static const char * const PROCESS_IGNORE_RETURN_VALUE = "abstractProcess.IgnoreReturnValue";
AbstractProcessStep::AbstractProcessStep(Project *pro)
: BuildStep(pro)
{
}
void AbstractProcessStep::setCommand(const QString &buildConfiguration, const QString &cmd)
void AbstractProcessStep::setCommand(const QString &cmd)
{
setValue(buildConfiguration, PROCESS_COMMAND, cmd);
m_command = cmd;
}
QString AbstractProcessStep::command(const QString &buildConfiguration) const
QString AbstractProcessStep::workingDirectory() const
{
QString result = value(buildConfiguration, PROCESS_COMMAND).toString();
if (QFileInfo(result).isRelative()) {
QString searchInPath = environment(buildConfiguration).searchInPath(result);
return m_workingDirectory;
}
void AbstractProcessStep::setWorkingDirectory(const QString &workingDirectory)
{
m_workingDirectory = workingDirectory;
}
void AbstractProcessStep::setArguments(const QStringList &arguments)
{
m_arguments = arguments;
}
void AbstractProcessStep::setEnabled(bool b)
{
m_enabled = b;
}
void AbstractProcessStep::setIgnoreReturnValue(bool b)
{
m_ignoreReturnValue = b;
}
void AbstractProcessStep::setEnvironment(Environment env)
{
m_environment = env;
}
bool AbstractProcessStep::init(const QString &buildConfiguration)
{
Q_UNUSED(buildConfiguration)
if (QFileInfo(m_command).isRelative()) {
QString searchInPath = m_environment.searchInPath(m_command);
if (!searchInPath.isEmpty())
result = searchInPath;
m_command = searchInPath;
}
return result;
}
void AbstractProcessStep::setWorkingDirectory(const QString &buildConfiguration, const QString &workingDirectory)
{
setValue(buildConfiguration, PROCESS_WORKINGDIRECTORY, workingDirectory);
}
QString AbstractProcessStep::workingDirectory(const QString &buildConfiguration) const
{
return value(buildConfiguration, PROCESS_WORKINGDIRECTORY).toString();
}
void AbstractProcessStep::setArguments(const QString &buildConfiguration, const QStringList &arguments)
{
setValue(buildConfiguration, PROCESS_ARGUMENTS, arguments);
}
QStringList AbstractProcessStep::arguments(const QString &buildConfiguration) const
{
return value(buildConfiguration, PROCESS_ARGUMENTS).toStringList();
}
void AbstractProcessStep::setEnabled(const QString &buildConfiguration, bool b)
{
setValue(buildConfiguration, PROCESS_ENABLED, b);
}
bool AbstractProcessStep::enabled(const QString &buildConfiguration) const
{
return value(buildConfiguration, PROCESS_ENABLED).toBool();
}
void AbstractProcessStep::setIgnoreReturnValue(const QString &buildConfiguration, bool b)
{
setValue(buildConfiguration, PROCESS_IGNORE_RETURN_VALUE, b);
}
bool AbstractProcessStep::ignoreReturnValue(const QString &buildConfiguration) const
{
return value(buildConfiguration, PROCESS_IGNORE_RETURN_VALUE).toBool();
}
void AbstractProcessStep::setEnvironment(const QString &buildConfiguration, Environment env)
{
setValue(buildConfiguration, PROCESS_ENVIRONMENT, env.toStringList());
}
Environment AbstractProcessStep::environment(const QString &buildConfiguration) const
{
return Environment(value(buildConfiguration, PROCESS_ENVIRONMENT).toStringList());
}
bool AbstractProcessStep::init(const QString &name)
{
m_command = command(name);
m_arguments = arguments(name);
m_enabled = enabled(name);
m_workingDirectory = workingDirectory(name);
m_environment = environment(name);
m_ignoreReturnValue = ignoreReturnValue(name);
return true;
}

47
src/plugins/projectexplorer/abstractprocessstep.h
View File

@@ -80,39 +80,34 @@ public:
virtual bool immutable() const = 0;
/// setCommand() sets the executable to run in the \p buildConfiguration
void setCommand(const QString &buildConfiguration, const QString &cmd);
/// returns the executable that is run for the \p buildConfiguration
QString command(const QString &buildConfiguration) const;
/// should be called from init()
void setCommand(const QString &cmd);
/// sets the workingDirectory for the process for a buildConfiguration
/// if no workingDirectory is set, it falls back to the projects workingDirectory TODO remove that magic, thats bad
void setWorkingDirectory(const QString &buildConfiguration, const QString &workingDirectory);
/// returns the workingDirectory for a \p buildConfiguration
QString workingDirectory(const QString &buildConfiguration) const;
/// should be called from init()
void setWorkingDirectory(const QString &workingDirectory);
/// sets the command line arguments used by the process for a \p buildConfiguration
void setArguments(const QString &buildConfiguration, const QStringList &arguments);
/// returns the arguments used in the \p buildCOnfiguration
QStringList arguments(const QString &buildConfiguration) const;
/// should be called from init()
void setArguments(const QStringList &arguments);
/// enables or disables a BuildStep
/// Disabled BuildSteps immediately return true from their run method
void setEnabled(const QString &buildConfiguration, bool b);
/// returns wheter the BuildStep is disabled
bool enabled(const QString &buildConfiguration) const;
/// should be called from init()
void setEnabled(bool b);
/*! If ignoreReturnValue is set to true, then the abstractprocess step will
return sucess even if the return value indicates otherwise
*/
void setIgnoreReturnValue(const QString &buildConfiguration,bool b);
/*! returns ignoreReturnValue
*/
bool ignoreReturnValue(const QString &buildConfiguration) const;
void setEnvironment(const QString &buildConfiguration, Environment env);
Environment environment(const QString &buildConfiguration) const;
/// If ignoreReturnValue is set to true, then the abstractprocess step will
/// return sucess even if the return value indicates otherwise
/// should be called from init
void setIgnoreReturnValue(bool b);
/// Set the Environment for running the command
/// should be called from init()
void setEnvironment(Environment env);
// TODO can I remove this?
QString workingDirectory() const;
protected:
/// Called after the process is started
/// the default implementation adds a process started message to the output message
virtual void processStarted();
@@ -122,7 +117,13 @@ protected:
/// Called if the process could not be started,
/// by default adds a message to the output window
virtual void processStartupFailed();
/// Called for each line of output on stdOut()
/// the default implementation adds the line to the
/// application output window
virtual void stdOut(const QString &line);
/// Called for each line of output on StdErrror()
/// the default implementation adds the line to the
/// application output window
virtual void stdError(const QString &line);
private slots:
void processReadyReadStdOutput();

95
src/plugins/projectexplorer/buildstep.cpp
View File

@@ -39,13 +39,34 @@ using namespace ProjectExplorer;
BuildStep::BuildStep(Project * pro)
: m_project(pro)
{
m_configuration = new BuildConfiguration("");
}
BuildStep::~BuildStep()
{
qDeleteAll(m_buildConfigurations);
delete m_configuration;
}
void BuildStep::restoreFromMap(const QMap<QString, QVariant> &map)
{
Q_UNUSED(map)
}
void BuildStep::storeIntoMap(QMap<QString, QVariant> &map)
{
Q_UNUSED(map)
}
void BuildStep::restoreFromMap(const QString &buildConfiguration, const QMap<QString, QVariant> &map)
{
Q_UNUSED(buildConfiguration)
Q_UNUSED(map)
}
void BuildStep::storeIntoMap(const QString &buildConfiguration, QMap<QString, QVariant> &map)
{
Q_UNUSED(buildConfiguration)
Q_UNUSED(map)
}
Project * BuildStep::project() const
@@ -55,78 +76,18 @@ Project * BuildStep::project() const
void BuildStep::addBuildConfiguration(const QString &name)
{
m_buildConfigurations.push_back(new BuildConfiguration(name));
Q_UNUSED(name)
}
void BuildStep::removeBuildConfiguration(const QString &name)
{
for (int i = 0; i != m_buildConfigurations.size(); ++i)
if (m_buildConfigurations.at(i)->name() == name) {
delete m_buildConfigurations.at(i);
m_buildConfigurations.removeAt(i);
break;
}
Q_UNUSED(name)
}
void BuildStep::copyBuildConfiguration(const QString &source, const QString &dest)
{
for (int i = 0; i != m_buildConfigurations.size(); ++i)
if (m_buildConfigurations.at(i)->name() == source)
m_buildConfigurations.push_back(new BuildConfiguration(dest, m_buildConfigurations.at(i)));
}
void BuildStep::setValue(const QString &buildConfiguration, const QString &name, const QVariant &value)
{
BuildConfiguration *bc = getBuildConfiguration(buildConfiguration);
Q_ASSERT(bc);
bc->setValue(name, value);
}
void BuildStep::setValue(const QString &name, const QVariant &value)
{
m_configuration->setValue(name, value);
}
QVariant BuildStep::value(const QString &buildConfiguration, const QString &name) const
{
BuildConfiguration *bc = getBuildConfiguration(buildConfiguration);
if (bc)
return bc->value(name);
else
return QVariant();
}
QVariant BuildStep::value(const QString &name) const
{
return m_configuration->value(name);
}
void BuildStep::setValuesFromMap(const QMap<QString, QVariant> & values)
{
m_configuration->setValuesFromMap(values);
}
void BuildStep::setValuesFromMap(const QString & buildConfiguration, const QMap<QString, QVariant> & values)
{
getBuildConfiguration(buildConfiguration)->setValuesFromMap(values);
}
QMap<QString, QVariant> BuildStep::valuesToMap()
{
return m_configuration->toMap();
}
QMap<QString, QVariant> BuildStep::valuesToMap(const QString & buildConfiguration)
{
return getBuildConfiguration(buildConfiguration)->toMap();
}
BuildConfiguration * BuildStep::getBuildConfiguration(const QString & name) const
{
for (int i = 0; i != m_buildConfigurations.size(); ++i)
if (m_buildConfigurations.at(i)->name() == name)
return m_buildConfigurations.at(i);
return 0;
Q_UNUSED(source)
Q_UNUSED(dest)
}
bool BuildStep::immutable() const

39
src/plugins/projectexplorer/buildstep.h
View File

@@ -92,17 +92,6 @@ public:
// The name shown to the user
virtual QString displayName() = 0;
// sets a value, which can be retrieved with value()
// these values are automatically saved and restored when qt creator is quit and restarted
void setValue(const QString &name, const QVariant &value);
// sets a value specific to a buildConfiguration
void setValue(const QString &buildConfiguration, const QString &name, const QVariant &value);
// retrieves a value
QVariant value(const QString &name) const;
// retrieves a value specific to a buildConfiguration
QVariant value(const QString &buildConfiguration, const QString & name) const;
// the Widget shown in the project settings dialog for this buildStep
// ownership is transfered to the caller
virtual BuildStepConfigWidget *createConfigWidget() = 0;
@@ -112,19 +101,18 @@ public:
// the default implementation returns false
virtual bool immutable() const;
virtual void restoreFromMap(const QMap<QString, QVariant> &map);
virtual void storeIntoMap(QMap<QString, QVariant> &map);
virtual void restoreFromMap(const QString &buildConfiguration, const QMap<QString, QVariant> &map);
virtual void storeIntoMap(const QString &buildConfiguration, QMap<QString, QVariant> &map);
virtual void addBuildConfiguration(const QString & name);
virtual void removeBuildConfiguration(const QString & name);
virtual void copyBuildConfiguration(const QString &source, const QString &dest);
Project *project() const;
protected:
// internal function for restoring the configuration
void setValuesFromMap(const QMap<QString, QVariant> &values);
// internal function for restoring the configuration
void setValuesFromMap(const QString &buildConfiguration, const QMap<QString, QVariant> &values);
// internal function for storing the configuration
QMap<QString, QVariant> valuesToMap();
// internal function for storing the configuration
QMap<QString, QVariant> valuesToMap(const QString & buildConfiguration);
Q_SIGNALS:
void addToTaskWindow(const ProjectExplorer::TaskWindow::Task &task);
// The string is added to the output window
@@ -132,13 +120,6 @@ Q_SIGNALS:
void addToOutputWindow(const QString &string);
private:
void addBuildConfiguration(const QString & name);
void removeBuildConfiguration(const QString & name);
BuildConfiguration *getBuildConfiguration(const QString & name) const;
void copyBuildConfiguration(const QString &source, const QString &dest);
QList<BuildConfiguration *> m_buildConfigurations;
BuildConfiguration *m_configuration;
Project *m_project;
};

145
src/plugins/projectexplorer/processstep.cpp
View File

@@ -32,6 +32,7 @@
#include "project.h"
#include <coreplugin/ifile.h>
#include <utils/qtcassert.h>
#include <QtCore/QDebug>
#include <QtGui/QFileDialog>
@@ -39,6 +40,11 @@
using namespace ProjectExplorer;
using namespace ProjectExplorer::Internal;
static const char * const PROCESS_COMMAND = "abstractProcess.command";
static const char * const PROCESS_WORKINGDIRECTORY = "abstractProcess.workingDirectory";
static const char * const PROCESS_ARGUMENTS = "abstractProcess.arguments";
static const char * const PROCESS_ENABLED = "abstractProcess.enabled";
ProcessStep::ProcessStep(Project *pro)
: AbstractProcessStep(pro)
{
@@ -48,14 +54,12 @@ ProcessStep::ProcessStep(Project *pro)
bool ProcessStep::init(const QString &buildConfigurationName)
{
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(buildConfigurationName, workingDirectory.replace("$BUILDDIR", project()->buildDirectory(bc)));
setEnvironment(project()->environment(bc));
QString wd = workingDirectory(buildConfigurationName);
if (wd.isEmpty())
wd = "$BUILDDIR";
AbstractProcessStep::setWorkingDirectory(wd.replace("$BUILDDIR", project()->buildDirectory(bc)));
return AbstractProcessStep::init(buildConfigurationName);
}
@@ -69,19 +73,52 @@ QString ProcessStep::name()
return "projectexplorer.processstep";
}
void ProcessStep::restoreFromMap(const QMap<QString, QVariant> &map)
{
QMap<QString, QVariant>::const_iterator it = map.constFind("ProjectExplorer.ProcessStep.DisplayName");
if (it != map.constEnd())
m_name = (*it).toString();
ProjectExplorer::AbstractProcessStep::restoreFromMap(map);
}
void ProcessStep::storeIntoMap(QMap<QString, QVariant> &map)
{
map["ProjectExplorer.ProcessStep.DisplayName"] = m_name;
ProjectExplorer::AbstractProcessStep::storeIntoMap(map);
}
void ProcessStep::restoreFromMap(const QString &buildConfiguration, const QMap<QString, QVariant> &map)
{
// TODO checking for PROCESS_*
setCommand(buildConfiguration, map.value(PROCESS_COMMAND).toString());
setWorkingDirectory(buildConfiguration, map.value(PROCESS_WORKINGDIRECTORY).toString());
setArguments(buildConfiguration, map.value(PROCESS_ARGUMENTS).toStringList());
setEnabled(buildConfiguration, map.value(PROCESS_ENABLED).toBool());
ProjectExplorer::AbstractProcessStep::restoreFromMap(buildConfiguration, map);
}
void ProcessStep::storeIntoMap(const QString &buildConfiguration, QMap<QString, QVariant> &map)
{
map[PROCESS_COMMAND] = command(buildConfiguration);
map[PROCESS_WORKINGDIRECTORY] = workingDirectory(buildConfiguration);
map[PROCESS_ARGUMENTS] = arguments(buildConfiguration);
map[PROCESS_ENABLED] = enabled(buildConfiguration);
ProjectExplorer::AbstractProcessStep::storeIntoMap(buildConfiguration, map);
}
void ProcessStep::setDisplayName(const QString &name)
{
if (name.isEmpty())
setValue("ProjectExplorer.ProcessStep.DisplayName", QVariant());
m_name = QString::null;
else
setValue("ProjectExplorer.ProcessStep.DisplayName", name);
m_name = name;
}
QString ProcessStep::displayName()
{
QVariant displayName = value("ProjectExplorer.ProcessStep.DisplayName");
if (displayName.isValid())
return displayName.toString();
if (!m_name.isNull())
return m_name;
else
return tr("Custom Process Step");
}
@@ -96,6 +133,83 @@ bool ProcessStep::immutable() const
return false;
}
QString ProcessStep::command(const QString &buildConfiguration) const
{
QMap<QString, ProcessStepSettings>::const_iterator it = m_values.constFind(buildConfiguration);
QTC_ASSERT(it != m_values.end(), return QString::null);
return (*it).command;
}
QStringList ProcessStep::arguments(const QString &buildConfiguration) const
{
QMap<QString, ProcessStepSettings>::const_iterator it = m_values.constFind(buildConfiguration);
QTC_ASSERT(it != m_values.end(), return QStringList());
return (*it).arguments;
}
bool ProcessStep::enabled(const QString &buildConfiguration) const
{
QMap<QString, ProcessStepSettings>::const_iterator it = m_values.constFind(buildConfiguration);
QTC_ASSERT(it != m_values.end(), return false);
return (*it).enabled;
}
QString ProcessStep::workingDirectory(const QString &buildConfiguration) const
{
QMap<QString, ProcessStepSettings>::const_iterator it = m_values.constFind(buildConfiguration);
QTC_ASSERT(it != m_values.end(), return QString::null);
return (*it).workingDirectory;
}
void ProcessStep::setCommand(const QString &buildConfiguration, const QString &command)
{
QMap<QString, ProcessStepSettings>::iterator it = m_values.find(buildConfiguration);
QTC_ASSERT(it != m_values.end(), return);
it->command = command;
}
void ProcessStep::setArguments(const QString &buildConfiguration, const QStringList &arguments)
{
QMap<QString, ProcessStepSettings>::iterator it = m_values.find(buildConfiguration);
QTC_ASSERT(it != m_values.end(), return);
it->arguments = arguments;
}
void ProcessStep::setEnabled(const QString &buildConfiguration, bool enabled)
{
QMap<QString, ProcessStepSettings>::iterator it = m_values.find(buildConfiguration);
QTC_ASSERT(it != m_values.end(), return);
it->enabled = enabled;
}
void ProcessStep::setWorkingDirectory(const QString &buildConfiguration, const QString &workingDirectory)
{
QMap<QString, ProcessStepSettings>::iterator it = m_values.find(buildConfiguration);
QTC_ASSERT(it != m_values.end(), return);
it->workingDirectory = workingDirectory;
}
void ProcessStep::addBuildConfiguration(const QString & name)
{
QMap<QString, ProcessStepSettings>::const_iterator it = m_values.constFind(name);
QTC_ASSERT(it == m_values.constEnd(), return);
m_values.insert(name, ProcessStepSettings());
}
void ProcessStep::removeBuildConfiguration(const QString & name)
{
QMap<QString, ProcessStepSettings>::const_iterator it = m_values.constFind(name);
QTC_ASSERT(it != m_values.constEnd(), return);
m_values.remove(name);
}
void ProcessStep::copyBuildConfiguration(const QString &source, const QString &dest)
{
QMap<QString, ProcessStepSettings>::const_iterator it = m_values.constFind(source);
QTC_ASSERT(it != m_values.constEnd(), return);
m_values.insert(dest, *it);
}
//*******
// ProcessStepFactory
//*******
@@ -173,7 +287,7 @@ void ProcessStepConfigWidget::init(const QString &buildConfiguration)
if (buildConfiguration != QString::null) {
m_ui.command->setPath(m_step->command(buildConfiguration));
QString workingDirectory = m_step->value(buildConfiguration, "workingDirectory").toString();
QString workingDirectory = m_step->workingDirectory(buildConfiguration);
if (workingDirectory.isEmpty())
workingDirectory = "$BUILDDIR";
m_ui.workingDirectory->setPath(workingDirectory);
@@ -204,8 +318,7 @@ void ProcessStepConfigWidget::commandLineEditTextEdited()
void ProcessStepConfigWidget::workingDirectoryLineEditTextEdited()
{
QString wd = m_ui.workingDirectory->path();
m_step->setValue(m_buildConfiguration, "workingDirectory", wd);
m_step->setWorkingDirectory(m_buildConfiguration, m_ui.workingDirectory->path());
}
void ProcessStepConfigWidget::commandArgumentsLineEditTextEdited()

31
src/plugins/projectexplorer/processstep.h
View File

@@ -50,6 +50,15 @@ public:
virtual QString displayNameForName(const QString &name) const;
};
struct ProcessStepSettings
{
QString command;
QStringList arguments;
QString workingDirectory;
Environment env;
bool enabled;
};
class ProcessStep : public ProjectExplorer::AbstractProcessStep
{
Q_OBJECT
@@ -63,8 +72,30 @@ public:
virtual QString displayName();
virtual BuildStepConfigWidget *createConfigWidget();
virtual bool immutable() const;
virtual void restoreFromMap(const QMap<QString, QVariant> &map);
virtual void storeIntoMap(QMap<QString, QVariant> &map);
virtual void restoreFromMap(const QString &buildConfiguration, const QMap<QString, QVariant> &map);
virtual void storeIntoMap(const QString &buildConfiguration, QMap<QString, QVariant> &map);
virtual void addBuildConfiguration(const QString & name);
virtual void removeBuildConfiguration(const QString & name);
virtual void copyBuildConfiguration(const QString &source, const QString &dest);
QString command(const QString &buildConfiguration) const;
QStringList arguments(const QString &buildConfiguration) const;
bool enabled(const QString &buildConfiguration) const;
QString workingDirectory(const QString &buildConfiguration) const;
void setCommand(const QString &buildConfiguration, const QString &command);
void setArguments(const QString &buildConfiguration, const QStringList &arguments);
void setEnabled(const QString &buildConfiguration, bool enabled);
void setWorkingDirectory(const QString &buildConfiguration, const QString &workingDirectory);
private:
QString m_name;
QMap<QString, ProcessStepSettings> m_values;
};
class ProcessStepConfigWidget : public BuildStepConfigWidget

39
src/plugins/projectexplorer/project.cpp
View File

@@ -66,9 +66,8 @@ Project::~Project()
void Project::insertBuildStep(int position, BuildStep *step)
{
m_buildSteps.insert(position, step);
// check that the step has all the configurations
// add all BuildConfigurations
foreach (const BuildConfiguration *bc, buildConfigurations())
if (!step->getBuildConfiguration(bc->name()))
step->addBuildConfiguration(bc->name());
}
@@ -87,9 +86,8 @@ void Project::moveBuildStepUp(int position)
void Project::insertCleanStep(int position, BuildStep *step)
{
m_cleanSteps.insert(position, step);
// check that the step has all the configurations
// add all BuildConfigurations
foreach (const BuildConfiguration *bc, buildConfigurations())
if (!step->getBuildConfiguration(bc->name()))
step->addBuildConfiguration(bc->name());
}
@@ -256,8 +254,9 @@ void Project::saveSettingsImpl(PersistentSettingsWriter &writer)
//save buildstep configuration
int buildstepnr = 0;
foreach (BuildStep *buildStep, buildSteps()) {
QMap<QString, QVariant> buildConfiguration = buildStep->valuesToMap();
writer.saveValue("buildstep" + QString().setNum(buildstepnr), buildConfiguration);
QMap<QString, QVariant> buildStepValues;
buildStep->storeIntoMap(buildStepValues);
writer.saveValue("buildstep" + QString().setNum(buildstepnr), buildStepValues);
++buildstepnr;
}
@@ -265,8 +264,8 @@ void Project::saveSettingsImpl(PersistentSettingsWriter &writer)
foreach (const QString &buildConfigurationName, buildConfigurationNames) {
buildstepnr = 0;
foreach (BuildStep *buildStep, buildSteps()) {
QMap<QString, QVariant> temp =
buildStep->valuesToMap(buildConfigurationName);
QMap<QString, QVariant> temp;
buildStep->storeIntoMap(temp);
writer.saveValue("buildconfiguration-" + buildConfigurationName + "-buildstep" + QString().setNum(buildstepnr), temp);
++buildstepnr;
}
@@ -275,8 +274,9 @@ void Project::saveSettingsImpl(PersistentSettingsWriter &writer)
//save cleansteps buildconfiguration
int cleanstepnr = 0;
foreach (BuildStep *cleanStep, cleanSteps()) {
QMap<QString, QVariant> buildConfiguration = cleanStep->valuesToMap();
writer.saveValue("cleanstep" + QString().setNum(cleanstepnr), buildConfiguration);
QMap<QString, QVariant> buildStepValues;
cleanStep->storeIntoMap(buildStepValues);
writer.saveValue("cleanstep" + QString().setNum(cleanstepnr), buildStepValues);
++cleanstepnr;
}
@@ -284,7 +284,8 @@ void Project::saveSettingsImpl(PersistentSettingsWriter &writer)
foreach (const QString &buildConfigurationName, buildConfigurationNames) {
cleanstepnr = 0;
foreach (BuildStep *cleanStep, cleanSteps()) {
QMap<QString, QVariant> temp = cleanStep->valuesToMap(buildConfigurationName);
QMap<QString, QVariant> temp;
cleanStep->storeIntoMap(temp);
writer.saveValue("buildconfiguration-" + buildConfigurationName + "-cleanstep" + QString().setNum(cleanstepnr), temp);
++cleanstepnr;
}
@@ -344,13 +345,13 @@ bool Project::restoreSettingsImpl(PersistentSettingsReader &reader)
}
// Restoring settings
if (buildStep) {
QMap<QString, QVariant> buildConfiguration = reader.restoreValue("buildstep" + QString().setNum(buildstepnr)).toMap();
buildStep->setValuesFromMap(buildConfiguration);
QMap<QString, QVariant> buildStepValues = reader.restoreValue("buildstep" + QString().setNum(buildstepnr)).toMap();
buildStep->restoreFromMap(buildStepValues);
foreach (const QString &buildConfigurationName, buildConfigurationNames) {
//get the buildconfiguration for this build step
QMap<QString, QVariant> buildConfiguration =
QMap<QString, QVariant> buildStepValues =
reader.restoreValue("buildconfiguration-" + buildConfigurationName + "-buildstep" + QString().setNum(buildstepnr)).toMap();
buildStep->setValuesFromMap(buildConfigurationName, buildConfiguration);
buildStep->restoreFromMap(buildStepValues);
}
}
}
@@ -374,12 +375,12 @@ bool Project::restoreSettingsImpl(PersistentSettingsReader &reader)
}
// Restoring settings
if (cleanStep) {
QMap<QString, QVariant> buildConfiguration = reader.restoreValue("cleanstep" + QString().setNum(cleanstepnr)).toMap();
cleanStep->setValuesFromMap(buildConfiguration);
QMap<QString, QVariant> buildStepValues = reader.restoreValue("cleanstep" + QString().setNum(cleanstepnr)).toMap();
cleanStep->restoreFromMap(buildStepValues);
foreach (const QString &buildConfigurationName, buildConfigurationNames) {
QMap<QString, QVariant> buildConfiguration =
QMap<QString, QVariant> buildStepValues =
reader.restoreValue("buildconfiguration-" + buildConfigurationName + "-cleanstep" + QString().setNum(cleanstepnr)).toMap();
cleanStep->setValuesFromMap(buildConfigurationName, buildConfiguration);
cleanStep->restoreFromMap(buildStepValues);
}
}
}

114
src/plugins/qt4projectmanager/makestep.cpp
View File

@@ -45,7 +45,7 @@ using namespace Qt4ProjectManager;
using namespace Qt4ProjectManager::Internal;
MakeStep::MakeStep(Qt4Project * project)
: AbstractMakeStep(project)
: AbstractMakeStep(project), m_clean(false)
{
}
@@ -55,20 +55,69 @@ MakeStep::~MakeStep()
}
void MakeStep::setClean(bool clean)
{
m_clean = clean;
}
void MakeStep::restoreFromMap(const QMap<QString, QVariant> &map)
{
if (map.value("clean").isValid() && map.value("clean").toBool())
m_clean = true;
ProjectExplorer::AbstractMakeStep::restoreFromMap(map);
}
void MakeStep::storeIntoMap(QMap<QString, QVariant> &map)
{
if (m_clean)
map["clean"] = true;
ProjectExplorer::AbstractMakeStep::storeIntoMap(map);
}
void MakeStep::restoreFromMap(const QString &buildConfiguration, const QMap<QString, QVariant> &map)
{
m_values[buildConfiguration].makeargs = map.value("makeargs").toStringList();
m_values[buildConfiguration].makeCmd = map.value("makeCmd").toString();
ProjectExplorer::AbstractMakeStep::restoreFromMap(buildConfiguration, map);
}
void MakeStep::storeIntoMap(const QString &buildConfiguration, QMap<QString, QVariant> &map)
{
map["makeargs"] = m_values.value(buildConfiguration).makeargs;
map["makeCmd"] = m_values.value(buildConfiguration).makeCmd;
ProjectExplorer::AbstractMakeStep::storeIntoMap(buildConfiguration, map);
}
void MakeStep::addBuildConfiguration(const QString & name)
{
m_values.insert(name, MakeStepSettings());
}
void MakeStep::removeBuildConfiguration(const QString & name)
{
m_values.remove(name);
}
void MakeStep::copyBuildConfiguration(const QString &source, const QString &dest)
{
m_values.insert(dest, m_values.value(source));
}
bool MakeStep::init(const QString &name)
{
m_buildConfiguration = name;
ProjectExplorer::BuildConfiguration *bc = project()->buildConfiguration(name);
Environment environment = project()->environment(bc);
setEnvironment(name, environment);
setEnvironment(environment);
Qt4Project *qt4project = qobject_cast<Qt4Project *>(project());
QString workingDirectory = qt4project->buildDirectory(bc);
setWorkingDirectory(name, workingDirectory);
setWorkingDirectory(workingDirectory);
QString makeCmd = qt4project->makeCommand(bc);
if (!value(name, "makeCmd").toString().isEmpty())
makeCmd = value(name, "makeCmd").toString();
if (!m_values.value(name).makeCmd.isEmpty())
makeCmd = m_values.value(name).makeCmd;
if (!QFileInfo(makeCmd).isAbsolute()) {
// Try to detect command in environment
QString tmp = environment.searchInPath(makeCmd);
@@ -79,19 +128,14 @@ bool MakeStep::init(const QString &name)
}
makeCmd = tmp;
}
setCommand(name, makeCmd);
setCommand(makeCmd);
if (!value(name, "cleanConfig").isValid() && value("clean").isValid() && value("clean").toBool()) {
// Import old settings
setValue(name, "cleanConfig", true);
setValue(name, "makeargs", QStringList() << "clean");
}
// If we are cleaning, then make can fail with a error code, but that doesn't mean
// we should stop the clean queue
// That is mostly so that rebuild works on a alrady clean project
setIgnoreReturnValue(name, value(name, "cleanConfig").isValid());
QStringList args = value(name, "makeargs").toStringList();
if (!value(name, "cleanConfig").isValid()) {
setIgnoreReturnValue(m_clean);
QStringList args = m_values.value(name).makeargs;
if (!m_clean) {
if (!qt4project->defaultMakeTarget(bc).isEmpty())
args << qt4project->defaultMakeTarget(bc);
}
@@ -106,12 +150,12 @@ bool MakeStep::init(const QString &name)
if (toolchain)
type = toolchain->type();
if (type != ProjectExplorer::ToolChain::MSVC && type != ProjectExplorer::ToolChain::WINCE) {
if (value(name, "makeCmd").toString().isEmpty())
if (m_values.value(name).makeCmd.isEmpty())
args << "-w";
}
setEnabled(name, true);
setArguments(name, args);
setEnabled(true);
setArguments(args);
if (type == ProjectExplorer::ToolChain::MSVC || type == ProjectExplorer::ToolChain::WINCE)
setBuildParser(ProjectExplorer::Constants::BUILD_PARSER_MSVC);
@@ -135,12 +179,6 @@ void MakeStep::run(QFutureInterface<bool> & fi)
return;
}
if (!enabled(m_buildConfiguration)) {
emit addToOutputWindow(tr("<font color=\"#0000ff\"><b>No Makefile found, assuming project is clean.</b></font>"));
fi.reportResult(true);
return;
}
AbstractMakeStep::run(fi);
}
@@ -164,9 +202,14 @@ ProjectExplorer::BuildStepConfigWidget *MakeStep::createConfigWidget()
return new MakeStepConfigWidget(this);
}
QStringList MakeStep::makeArguments(const QString &buildConfiguration)
{
return m_values.value(buildConfiguration).makeargs;
}
void MakeStep::setMakeArguments(const QString &buildConfiguration, const QStringList &arguments)
{
setValue(buildConfiguration, "makeargs", arguments);
m_values[buildConfiguration].makeargs = arguments;
emit changed();
}
@@ -204,8 +247,8 @@ void MakeStepConfigWidget::updateDetails()
QString workingDirectory = pro->buildDirectory(bc);
QString makeCmd = pro->makeCommand(bc);
if (!m_makeStep->value(m_buildConfiguration, "makeCmd").toString().isEmpty())
makeCmd = m_makeStep->value(m_buildConfiguration, "makeCmd").toString();
if (!m_makeStep->m_values.value(m_buildConfiguration).makeCmd.isEmpty())
makeCmd = m_makeStep->m_values.value(m_buildConfiguration).makeCmd;
if (!QFileInfo(makeCmd).isAbsolute()) {
Environment environment = pro->environment(bc);
// Try to detect command in environment
@@ -222,13 +265,13 @@ void MakeStepConfigWidget::updateDetails()
// 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
QStringList args = m_makeStep->value(m_buildConfiguration, "makeargs").toStringList();
QStringList args = m_makeStep->makeArguments(m_buildConfiguration);
ProjectExplorer::ToolChain::ToolChainType t = ProjectExplorer::ToolChain::UNKNOWN;
ProjectExplorer::ToolChain *toolChain = pro->toolChain(bc);
if (toolChain)
t = toolChain->type();
if (t != ProjectExplorer::ToolChain::MSVC && t != ProjectExplorer::ToolChain::WINCE) {
if (m_makeStep->value(m_buildConfiguration, "makeCmd").toString().isEmpty())
if (m_makeStep->m_values.value(m_buildConfiguration).makeCmd.isEmpty())
args << "-w";
}
m_summaryText = tr("<b>Make:</b> %1 %2 in %3").arg(QFileInfo(makeCmd).fileName(), args.join(" "),
@@ -255,19 +298,12 @@ void MakeStepConfigWidget::init(const QString &buildConfiguration)
{
m_buildConfiguration = buildConfiguration;
if (!m_makeStep->value(buildConfiguration, "cleanConfig").isValid() && m_makeStep->value("clean").isValid() && m_makeStep->value("clean").toBool()) {
// Import old settings
m_makeStep->setValue(buildConfiguration, "cleanConfig", true);
m_makeStep->setValue(buildConfiguration, "makeargs", QStringList() << "clean");
}
updateMakeOverrideLabel();
const QString &makeCmd = m_makeStep->value(buildConfiguration, "makeCmd").toString();
const QString &makeCmd = m_makeStep->m_values.value(buildConfiguration).makeCmd;
m_ui.makeLineEdit->setText(makeCmd);
const QStringList &makeArguments =
m_makeStep->value(buildConfiguration, "makeargs").toStringList();
const QStringList &makeArguments = m_makeStep->makeArguments(buildConfiguration);
m_ui.makeArgumentsLineEdit->setText(ProjectExplorer::Environment::joinArgumentList(makeArguments));
updateDetails();
}
@@ -275,14 +311,14 @@ void MakeStepConfigWidget::init(const QString &buildConfiguration)
void MakeStepConfigWidget::makeLineEditTextEdited()
{
Q_ASSERT(!m_buildConfiguration.isNull());
m_makeStep->setValue(m_buildConfiguration, "makeCmd", m_ui.makeLineEdit->text());
m_makeStep->m_values[m_buildConfiguration].makeCmd = m_ui.makeLineEdit->text();
updateDetails();
}
void MakeStepConfigWidget::makeArgumentsLineEditTextEdited()
{
Q_ASSERT(!m_buildConfiguration.isNull());
m_makeStep->setValue(m_buildConfiguration, "makeargs",
m_makeStep->setMakeArguments(m_buildConfiguration,
ProjectExplorer::Environment::parseCombinedArgString(m_ui.makeArgumentsLineEdit->text()));
updateDetails();
}

23
src/plugins/qt4projectmanager/makestep.h
View File

@@ -60,9 +60,17 @@ public:
class Qt4Project;
struct MakeStepSettings
{
QStringList makeargs;
QString makeCmd;
};
class MakeStep : public ProjectExplorer::AbstractMakeStep
{
Q_OBJECT
friend class MakeStepConfigWidget; // TODO remove this
// currently used to access m_values
public:
MakeStep(Qt4Project * project);
~MakeStep();
@@ -72,11 +80,26 @@ public:
virtual QString displayName();
virtual ProjectExplorer::BuildStepConfigWidget *createConfigWidget();
virtual bool immutable() const;
QStringList makeArguments(const QString &buildConfiguration);
void setMakeArguments(const QString &buildConfiguration, const QStringList &arguments);
virtual void restoreFromMap(const QMap<QString, QVariant> &map);
virtual void storeIntoMap(QMap<QString, QVariant> &map);
void setClean(bool clean);
virtual void restoreFromMap(const QString &buildConfiguration, const QMap<QString, QVariant> &map);
virtual void storeIntoMap(const QString &buildConfiguration, QMap<QString, QVariant> &map);
virtual void addBuildConfiguration(const QString & name);
virtual void removeBuildConfiguration(const QString & name);
virtual void copyBuildConfiguration(const QString &source, const QString &dest);
signals:
void changed();
private:
QString m_buildConfiguration;
bool m_clean;
QMap<QString, MakeStepSettings> m_values;
};
class MakeStepConfigWidget : public ProjectExplorer::BuildStepConfigWidget

59
src/plugins/qt4projectmanager/qmakestep.cpp
View File

@@ -60,7 +60,7 @@ QMakeStep::~QMakeStep()
QStringList QMakeStep::arguments(const QString &buildConfiguration)
{
QStringList additonalArguments = value(buildConfiguration, "qmakeArgs").toStringList();
QStringList additonalArguments = m_values.value(buildConfiguration).qmakeArgs;
ProjectExplorer::BuildConfiguration *bc = m_pro->buildConfiguration(buildConfiguration);
QStringList arguments;
arguments << project()->file()->fileName();
@@ -121,24 +121,24 @@ bool QMakeStep::init(const QString &name)
QString program = qtVersion->qmakeCommand();
// Check wheter we need to run qmake
bool needToRunQMake = true;
m_needToRunQMake = true;
if (QDir(workingDirectory).exists(QLatin1String("Makefile"))) {
QString qmakePath = QtVersionManager::findQMakeBinaryFromMakefile(workingDirectory);
if (qtVersion->qmakeCommand() == qmakePath) {
needToRunQMake = !m_pro->compareBuildConfigurationToImportFrom(bc, workingDirectory);
m_needToRunQMake = !m_pro->compareBuildConfigurationToImportFrom(bc, workingDirectory);
}
}
if (m_forced) {
m_forced = false;
needToRunQMake = true;
m_needToRunQMake = true;
}
setEnabled(name, needToRunQMake);
setWorkingDirectory(name, workingDirectory);
setCommand(name, program);
setArguments(name, args);
setEnvironment(name, m_pro->environment(bc));
setEnabled(m_needToRunQMake);
setWorkingDirectory(workingDirectory);
setCommand(program);
setArguments(args);
setEnvironment(m_pro->environment(bc));
setBuildParser(ProjectExplorer::Constants::BUILD_PARSER_QMAKE);
return AbstractMakeStep::init(name);
@@ -151,7 +151,7 @@ void QMakeStep::run(QFutureInterface<bool> &fi)
return;
}
if (!enabled(m_buildConfiguration)) {
if (!m_needToRunQMake) {
emit addToOutputWindow(tr("<font color=\"#0000ff\">Configuration unchanged, skipping QMake step.</font>"));
fi.reportResult(true);
return;
@@ -205,10 +205,42 @@ bool QMakeStep::processFinished(int exitCode, QProcess::ExitStatus status)
void QMakeStep::setQMakeArguments(const QString &buildConfiguration, const QStringList &arguments)
{
setValue(buildConfiguration, "qmakeArgs", arguments);
m_values[buildConfiguration].qmakeArgs = arguments;
emit changed();
}
QStringList QMakeStep::qmakeArguments(const QString &buildConfiguration)
{
return m_values[buildConfiguration].qmakeArgs;
}
void QMakeStep::restoreFromMap(const QString &buildConfiguration, const QMap<QString, QVariant> &map)
{
m_values[buildConfiguration].qmakeArgs = map.value("qmakeArgs").toStringList();
AbstractProcessStep::restoreFromMap(buildConfiguration, map);
}
void QMakeStep::storeIntoMap(const QString &buildConfiguration, QMap<QString, QVariant> &map)
{
map["qmakeArgs"] = m_values.value(buildConfiguration).qmakeArgs;
AbstractProcessStep::storeIntoMap(buildConfiguration, map);
}
void QMakeStep::addBuildConfiguration(const QString & name)
{
m_values.insert(name, QMakeStepSettings());
}
void QMakeStep::removeBuildConfiguration(const QString & name)
{
m_values.remove(name);
}
void QMakeStep::copyBuildConfiguration(const QString &source, const QString &dest)
{
m_values.insert(dest, m_values.value(source));
}
QMakeStepConfigWidget::QMakeStepConfigWidget(QMakeStep *step)
: BuildStepConfigWidget(), m_step(step)
{
@@ -261,7 +293,8 @@ void QMakeStepConfigWidget::updateTitleLabel()
void QMakeStepConfigWidget::qmakeArgumentsLineEditTextEdited()
{
Q_ASSERT(!m_buildConfiguration.isNull());
m_step->setValue(m_buildConfiguration, "qmakeArgs", ProjectExplorer::Environment::parseCombinedArgString(m_ui.qmakeAdditonalArgumentsLineEdit->text()));
m_step->setQMakeArguments(m_buildConfiguration,
ProjectExplorer::Environment::parseCombinedArgString(m_ui.qmakeAdditonalArgumentsLineEdit->text()));
static_cast<Qt4Project *>(m_step->project())->invalidateCachedTargetInformation();
updateTitleLabel();
@@ -300,7 +333,7 @@ void QMakeStepConfigWidget::update()
void QMakeStepConfigWidget::init(const QString &buildConfiguration)
{
m_buildConfiguration = buildConfiguration;
QString qmakeArgs = ProjectExplorer::Environment::joinArgumentList(m_step->value(buildConfiguration, "qmakeArgs").toStringList());
QString qmakeArgs = ProjectExplorer::Environment::joinArgumentList(m_step->qmakeArguments(buildConfiguration));
m_ui.qmakeAdditonalArgumentsLineEdit->setText(qmakeArgs);
ProjectExplorer::BuildConfiguration *bc = m_step->project()->buildConfiguration(buildConfiguration);
bool debug = QtVersion::QmakeBuildConfig(bc->value("buildConfiguration").toInt()) & QtVersion::DebugBuild;

17
src/plugins/qt4projectmanager/qmakestep.h
View File

@@ -60,10 +60,16 @@ public:
class Qt4Project;
struct QMakeStepSettings
{
QStringList qmakeArgs;
};
class QMakeStep : public ProjectExplorer::AbstractMakeStep
{
Q_OBJECT
friend class Qt4Project; // TODO remove
// Currently used to access qmakeArgs
public:
QMakeStep(Qt4Project * project);
~QMakeStep();
@@ -77,8 +83,15 @@ public:
void setForced(bool b);
bool forced();
QStringList qmakeArguments(const QString &buildConfiguration);
void setQMakeArguments(const QString &buildConfiguraion, const QStringList &arguments);
virtual void restoreFromMap(const QString &buildConfiguration, const QMap<QString, QVariant> &map);
virtual void storeIntoMap(const QString &buildConfiguration, QMap<QString, QVariant> &map);
virtual void addBuildConfiguration(const QString & name);
virtual void removeBuildConfiguration(const QString & name);
virtual void copyBuildConfiguration(const QString &source, const QString &dest);
signals:
void changed();
@@ -92,6 +105,8 @@ private:
QString m_buildConfiguration;
QStringList m_lastEnv;
bool m_forced;
bool m_needToRunQMake; // set in init(), read in run()
QMap<QString, QMakeStepSettings> m_values;
};

46
src/plugins/qt4projectmanager/qt4project.cpp
View File

@@ -359,6 +359,7 @@ bool Qt4Project::restoreSettingsImpl(PersistentSettingsReader &settingsReader)
{
Project::restoreSettingsImpl(settingsReader);
if (buildConfigurations().isEmpty())
addDefaultBuild();
// Ensure that the qt version and tool chain in each build configuration is valid
@@ -450,11 +451,11 @@ void Qt4Project::addQt4BuildConfiguration(QString buildConfigurationName, QtVers
addBuildConfiguration(bc);
const QString &finalBuildConfigurationName = bc->name();
if (!additionalArguments.isEmpty())
qmake->setValue(finalBuildConfigurationName, "qmakeArgs", additionalArguments);
qmake->m_values[finalBuildConfigurationName].qmakeArgs = additionalArguments;
// set some options for qmake and make
if (qmakeBuildConfiguration & QtVersion::BuildAll) // debug_and_release => explicit targets
make->setValue(finalBuildConfigurationName, "makeargs", QStringList() << (debug ? "debug" : "release"));
make->setMakeArguments(finalBuildConfigurationName, QStringList() << (debug ? "debug" : "release"));
bc->setValue("buildConfiguration", int(qmakeBuildConfiguration));
@@ -817,52 +818,26 @@ QList<ProjectExplorer::Project*> Qt4Project::dependsOn()
void Qt4Project::addDefaultBuild()
{
if (buildConfigurations().isEmpty()) {
// We don't have any buildconfigurations, so this is a new project
// The Project Load Wizard is a work of art
// It will ask the user what kind of build setup he want
// It will add missing Qt Versions
// And get the project into a buildable state
//TODO have a better check wheter there is already a configuration?
QMakeStep *qmakeStep = 0;
MakeStep *makeStep = 0;
qmakeStep = new QMakeStep(this);
qmakeStep->setValue("mkspec", "");
insertBuildStep(1, qmakeStep);
makeStep = new MakeStep(this);
insertBuildStep(2, makeStep);
MakeStep* cleanStep = new MakeStep(this);
cleanStep->setValue("clean", true);
cleanStep->setClean(true);
insertCleanStep(1, cleanStep);
// TODO this could probably refactored
// That is the ProjectLoadWizard divided into useful bits
// and this code then called here, instead of that strange forwarding
// to a wizard, which doesn't even show up
ProjectLoadWizard wizard(this);
wizard.execDialog();
} else {
// Migrate settings
QMakeStep *qs = qmakeStep();
foreach (BuildConfiguration *bc, buildConfigurations()) {
QVariant v = qs ? qs->value(bc->name(), "buildConfiguration") : QVariant();
if (v.isValid()) {
qs->setValue(bc->name(), "buildConfiguration", QVariant());
bc->setValue("buildConfiguration", v);
} else if (!bc->value("buildConfiguration").isValid()) {
if (QtVersion *version = qtVersion(bc))
bc->setValue("buildConfiguration", int(version->defaultBuildConfig()));
else
bc->setValue("buildConfiguration", int(QtVersion::BuildAll & QtVersion::DebugBuild));
}
}
// Restoring configuration
foreach(BuildConfiguration *bc, buildConfigurations()) {
bc->setValue("addQDumper", QVariant());
}
}
}
void Qt4Project::proFileParseError(const QString &errorMessage)
@@ -1306,14 +1281,15 @@ bool Qt4Project::compareBuildConfigurationToImportFrom(BuildConfiguration *confi
// 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(configuration->name(), "qmakeArgs").toStringList(), workingDirectory, version);
QString actualSpec = extractSpecFromArgumentList(qs->m_values.value(configuration->name()).qmakeArgs, workingDirectory, version);
if (actualSpec.isEmpty()) {
// Easy one the user has choosen not to override the settings
actualSpec = version->mkspec();
}
QString parsedSpec = extractSpecFromArgumentList(result.second, workingDirectory, version);
QStringList actualArgs = removeSpecFromArgumentList(qs->value(configuration->name(), "qmakeArgs").toStringList());
QStringList actualArgs = removeSpecFromArgumentList(qs->m_values.value(configuration->name()).qmakeArgs);
QStringList parsedArgs = removeSpecFromArgumentList(result.second);
if (debug) {

2
src/plugins/qt4projectmanager/qt4projectconfigwidget.cpp
View File

@@ -311,7 +311,7 @@ void Qt4ProjectConfigWidget::importLabelClicked()
// If we are switching to BuildAll we want "release" in there and no "debug"
// or "debug" in there and no "release"
// If we are switching to not BuildAl we want neither "release" nor "debug" in there
QStringList makeCmdArguments = makeStep->value(m_buildConfiguration, "makeargs").toStringList();
QStringList makeCmdArguments = makeStep->makeArguments(m_buildConfiguration);
bool debug = qmakeBuildConfig & QtVersion::DebugBuild;
if (qmakeBuildConfig & QtVersion::BuildAll) {
makeCmdArguments.removeAll(debug ? "release" : "debug");