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

src/plugins/cmakeprojectmanager/cmakeproject.cpp

@@ -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

src/plugins/cmakeprojectmanager/makestep.cpp

@@ -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);
+    setEnabled(true);
-    setWorkingDirectory(buildConfiguration, m_pro->buildDirectory(bc));
+    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()) {
+    QStringList arguments = m_values.value(buildConfiguration).buildTargets;
-        // Import old settings
-        setValue(buildConfiguration, "cleanConfig", true);
-        setAdditionalArguments(buildConfiguration, QStringList() << "clean");
-    }
-
-    QStringList arguments = value(buildConfiguration, "buildTargets").toStringList();
     arguments << additionalArguments(buildConfiguration);
-    setArguments(buildConfiguration, arguments); // TODO
+    setArguments(arguments); // TODO
-    setEnvironment(buildConfiguration, m_pro->environment(bc));
+    setEnvironment(m_pro->environment(bc));
-    setIgnoreReturnValue(buildConfiguration, value(buildConfiguration, "cleanConfig").isValid());
+    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);
-
+    m_values[buildConfiguration].buildTargets = old;
-    setValue(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(

src/plugins/cmakeprojectmanager/makestep.h

@@ -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

src/plugins/genericprojectmanager/genericmakestep.cpp

@@ -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));
+    setCommand(makeCommand(buildConfigurationName));
-    setArguments(buildConfigurationName, replacedArguments(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();
+    const QStringList targets = m_values.value(buildConfiguration).buildTargets;
-    QStringList arguments = value(buildConfiguration, "makeArguments").toStringList();
+    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 =
+    const QStringList &makeArguments = m_makeStep->m_values.value(buildConfiguration).makeArguments;
-            m_makeStep->value(buildConfiguration, "makeArguments").toStringList();
     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",
+    m_makeStep->m_values[m_buildConfiguration].makeArguments =
-                         ProjectExplorer::Environment::parseCombinedArgString(m_ui->makeArgumentsLineEdit->text()));
+                         ProjectExplorer::Environment::parseCombinedArgString(m_ui->makeArgumentsLineEdit->text());
     updateDetails();
 }
 

src/plugins/genericprojectmanager/genericmakestep.h

@@ -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

src/plugins/projectexplorer/abstractmakestep.cpp

@@ -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);
 }

src/plugins/projectexplorer/abstractprocessstep.cpp

@@ -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();
+    return m_workingDirectory;
-    if (QFileInfo(result).isRelative()) {
+}
-        QString searchInPath = environment(buildConfiguration).searchInPath(result);
+
+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;
 }
 

src/plugins/projectexplorer/abstractprocessstep.h

@@ -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);
+    /// should be called from init()
-    /// returns the executable that is run for the \p buildConfiguration
+    void setCommand(const QString &cmd);
-    QString command(const QString &buildConfiguration) const;
 
     /// 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
+    /// should be called from init()
-    void setWorkingDirectory(const QString &buildConfiguration, const QString &workingDirectory);
+    void setWorkingDirectory(const QString &workingDirectory);
-    /// returns the workingDirectory for a \p buildConfiguration
-    QString workingDirectory(const QString &buildConfiguration) const;
 
     /// sets the command line arguments used by the process for a \p buildConfiguration
-    void setArguments(const QString &buildConfiguration, const QStringList &arguments);
+    /// should be called from init()
-    /// returns the arguments used in the \p buildCOnfiguration
+    void setArguments(const QStringList &arguments);
-    QStringList arguments(const QString &buildConfiguration) const;
 
     /// enables or disables a BuildStep
     /// Disabled BuildSteps immediately return true from their run method
-    void setEnabled(const QString &buildConfiguration, bool b);
+    /// should be called from init()
-    /// returns wheter the BuildStep is disabled
+    void setEnabled(bool b);
-    bool enabled(const QString &buildConfiguration) const;
 
-    /*! If ignoreReturnValue is set to true, then the abstractprocess step will
+    /// If ignoreReturnValue is set to true, then the abstractprocess step will
-        return sucess even if the return value indicates otherwise
+    /// return sucess even if the return value indicates otherwise
-    */
+    /// should be called from init
-    void setIgnoreReturnValue(const QString &buildConfiguration,bool b);
+    void setIgnoreReturnValue(bool b);
-    /*! returns ignoreReturnValue
+    /// Set the Environment for running the command
-    */
+    /// should be called from init()
-    bool ignoreReturnValue(const QString &buildConfiguration) const;
+    void setEnvironment(Environment env);
-
-    void setEnvironment(const QString &buildConfiguration, Environment env);
-    Environment environment(const QString &buildConfiguration) const;
 
+    // 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();

src/plugins/projectexplorer/buildstep.cpp

@@ -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)
+    Q_UNUSED(name)
-        if (m_buildConfigurations.at(i)->name() == name) {
-            delete m_buildConfigurations.at(i);
-            m_buildConfigurations.removeAt(i);
-            break;
-        }
 }
 
 void BuildStep::copyBuildConfiguration(const QString &source, const QString &dest)
 {
-    for (int i = 0; i != m_buildConfigurations.size(); ++i)
+    Q_UNUSED(source)
-        if (m_buildConfigurations.at(i)->name() == source)
+    Q_UNUSED(dest)
-            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;
 }
 
 bool BuildStep::immutable() const

src/plugins/projectexplorer/buildstep.h

@@ -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;
 };
 

src/plugins/projectexplorer/processstep.cpp

@@ -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));
+    setEnvironment(project()->environment(bc));
-    QVariant wd = value(buildConfigurationName, "workingDirectory").toString();
+    QString wd = workingDirectory(buildConfigurationName);
-    QString workingDirectory;
+    if (wd.isEmpty())
-    if (!wd.isValid() || wd.toString().isEmpty())
+        wd = "$BUILDDIR";
-        workingDirectory = "$BUILDDIR";
+
-    else
+    AbstractProcessStep::setWorkingDirectory(wd.replace("$BUILDDIR", project()->buildDirectory(bc)));
-        workingDirectory = wd.toString();
-    setWorkingDirectory(buildConfigurationName, workingDirectory.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 (!m_name.isNull())
-    if (displayName.isValid())
+        return m_name;
-        return displayName.toString();
     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->setWorkingDirectory(m_buildConfiguration, m_ui.workingDirectory->path());
-    m_step->setValue(m_buildConfiguration, "workingDirectory", wd);
 }
 
 void ProcessStepConfigWidget::commandArgumentsLineEditTextEdited()

src/plugins/projectexplorer/processstep.h

@@ -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

src/plugins/projectexplorer/project.cpp

@@ -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();
+        QMap<QString, QVariant> buildStepValues;
-        writer.saveValue("buildstep" + QString().setNum(buildstepnr), buildConfiguration);
+        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 =
+            QMap<QString, QVariant> temp;
-                buildStep->valuesToMap(buildConfigurationName);
+            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();
+        QMap<QString, QVariant> buildStepValues;
-        writer.saveValue("cleanstep" + QString().setNum(cleanstepnr), buildConfiguration);
+        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();
+                QMap<QString, QVariant> buildStepValues = reader.restoreValue("buildstep" + QString().setNum(buildstepnr)).toMap();
-                buildStep->setValuesFromMap(buildConfiguration);
+                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();
+                QMap<QString, QVariant> buildStepValues = reader.restoreValue("cleanstep" + QString().setNum(cleanstepnr)).toMap();
-                cleanStep->setValuesFromMap(buildConfiguration);
+                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);
                 }
             }
         }

src/plugins/qt4projectmanager/makestep.cpp

@@ -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())
+    if (!m_values.value(name).makeCmd.isEmpty())
-        makeCmd = value(name, "makeCmd").toString();
+        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());
+    setIgnoreReturnValue(m_clean);
-    QStringList args = value(name, "makeargs").toStringList();
+    QStringList args = m_values.value(name).makeargs;
-    if (!value(name, "cleanConfig").isValid()) {
+    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);
+    setEnabled(true);
-    setArguments(name, args);
+    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())
+    if (!m_makeStep->m_values.value(m_buildConfiguration).makeCmd.isEmpty())
-        makeCmd = m_makeStep->value(m_buildConfiguration, "makeCmd").toString();
+        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 =
+    const QStringList &makeArguments = m_makeStep->makeArguments(buildConfiguration);
-            m_makeStep->value(buildConfiguration, "makeargs").toStringList();
     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();
 }

src/plugins/qt4projectmanager/makestep.h

@@ -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

src/plugins/qt4projectmanager/qmakestep.cpp

@@ -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);
+    setEnabled(m_needToRunQMake);
-    setWorkingDirectory(name, workingDirectory);
+    setWorkingDirectory(workingDirectory);
-    setCommand(name, program);
+    setCommand(program);
-    setArguments(name, args);
+    setArguments(args);
-    setEnvironment(name, m_pro->environment(bc));
+    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;

src/plugins/qt4projectmanager/qmakestep.h

@@ -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;
 };
 
 

src/plugins/qt4projectmanager/qt4project.cpp

@@ -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) {

src/plugins/qt4projectmanager/qt4projectconfigwidget.cpp

@@ -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");