Files
qt-creator/src/plugins/qt4projectmanager/makestep.cpp

326 lines
11 KiB
C++
Raw Normal View History

/**************************************************************************
2008-12-02 12:01:29 +01:00
**
** This file is part of Qt Creator
**
** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
2008-12-02 12:01:29 +01:00
**
** Contact: Nokia Corporation (qt-info@nokia.com)
2008-12-02 12:01:29 +01:00
**
** Commercial Usage
**
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
**
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** If you are unsure which license is appropriate for your use, please
2009-08-14 09:30:56 +02:00
** contact the sales department at http://qt.nokia.com/contact.
2008-12-02 12:01:29 +01:00
**
**************************************************************************/
2008-12-02 16:19:05 +01:00
2008-12-02 12:01:29 +01:00
#include "makestep.h"
2008-12-02 16:19:05 +01:00
2008-12-02 12:01:29 +01:00
#include "qt4project.h"
#include "qt4projectmanagerconstants.h"
#include <projectexplorer/projectexplorerconstants.h>
2008-12-09 15:25:01 +01:00
#include <QtCore/QDir>
#include <QtCore/QFileInfo>
2008-12-02 12:01:29 +01:00
using ProjectExplorer::IBuildParserFactory;
using ProjectExplorer::IBuildParser;
2008-12-02 12:01:29 +01:00
using ProjectExplorer::Environment;
using ExtensionSystem::PluginManager;
using namespace Qt4ProjectManager;
using namespace Qt4ProjectManager::Internal;
MakeStep::MakeStep(Qt4Project * project)
: AbstractMakeStep(project)
2008-12-02 12:01:29 +01:00
{
}
MakeStep::~MakeStep()
2008-12-02 12:01:29 +01:00
{
}
bool MakeStep::init(const QString &name)
{
m_buildConfiguration = name;
ProjectExplorer::BuildConfiguration *bc = project()->buildConfiguration(name);
Environment environment = project()->environment(bc);
2008-12-02 12:01:29 +01:00
setEnvironment(name, environment);
Qt4Project *qt4project = qobject_cast<Qt4Project *>(project());
QString workingDirectory = qt4project->buildDirectory(bc);
2008-12-02 12:01:29 +01:00
setWorkingDirectory(name, workingDirectory);
QString makeCmd = qt4project->makeCommand(bc);
2008-12-09 11:07:24 +01:00
if (!value(name, "makeCmd").toString().isEmpty())
2008-12-02 12:01:29 +01:00
makeCmd = value(name, "makeCmd").toString();
if (!QFileInfo(makeCmd).isAbsolute()) {
// Try to detect command in environment
QString tmp = environment.searchInPath(makeCmd);
2008-12-09 11:07:24 +01:00
if (tmp == QString::null) {
2008-12-02 12:01:29 +01:00
emit addToOutputWindow(tr("<font color=\"#ff0000\">Could not find make command: %1 "\
"in the build environment</font>").arg(makeCmd));
return false;
}
makeCmd = tmp;
}
setCommand(name, makeCmd);
if (!value(name, "cleanConfig").isValid() && value("clean").isValid() && value("clean").toBool()) {
// Import old settings
setValue(name, "cleanConfig", true);
setValue(name, "makeargs", QStringList() << "clean");
2008-12-02 12:01:29 +01:00
}
// 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()) {
if (!qt4project->defaultMakeTarget(bc).isEmpty())
args << qt4project->defaultMakeTarget(bc);
2008-12-02 12:01:29 +01:00
}
// -w option enables "Enter"/"Leaving directory" messages, which we need for detecting the
// absolute file path
// FIXME doing this without the user having a way to override this is rather bad
// so we only do it for unix and if the user didn't override the make command
// but for now this is the least invasive change
ProjectExplorer::ToolChain *toolchain = qt4project->toolChain(bc);
2009-10-28 16:26:43 +01:00
ProjectExplorer::ToolChain::ToolChainType type = ProjectExplorer::ToolChain::UNKNOWN;
if (toolchain)
2009-10-28 16:26:43 +01:00
type = toolchain->type();
if (type != ProjectExplorer::ToolChain::MSVC && type != ProjectExplorer::ToolChain::WINCE) {
2008-12-02 12:01:29 +01:00
if (value(name, "makeCmd").toString().isEmpty())
args << "-w";
}
setEnabled(name, true);
2008-12-02 12:01:29 +01:00
setArguments(name, args);
2009-10-28 16:26:43 +01:00
if (type == ProjectExplorer::ToolChain::MSVC || type == ProjectExplorer::ToolChain::WINCE)
setBuildParser(ProjectExplorer::Constants::BUILD_PARSER_MSVC);
else if (ProjectExplorer::ToolChain::GCCE == type)
setBuildParser(ProjectExplorer::Constants::BUILD_PARSER_ABLD_GCCE);
else if (ProjectExplorer::ToolChain::WINSCW == type)
setBuildParser(ProjectExplorer::Constants::BUILD_PARSER_ABLD_WINSCW);
else if (ProjectExplorer::ToolChain::RVCT_ARMV5 == type ||
ProjectExplorer::ToolChain::RVCT_ARMV6 == type)
setBuildParser(ProjectExplorer::Constants::BUILD_PARSER_ABLD_RVCT);
else
setBuildParser(ProjectExplorer::Constants::BUILD_PARSER_GCC);
2008-12-02 12:01:29 +01:00
return AbstractMakeStep::init(name);
2008-12-02 12:01:29 +01:00
}
void MakeStep::run(QFutureInterface<bool> & fi)
{
if (qobject_cast<Qt4Project *>(project())->rootProjectNode()->projectType() == ScriptTemplate) {
fi.reportResult(true);
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);
2008-12-02 12:01:29 +01:00
}
QString MakeStep::name()
{
return Constants::MAKESTEP;
}
QString MakeStep::displayName()
{
return "Make";
}
bool MakeStep::immutable() const
{
2009-07-27 16:36:27 +02:00
return false;
2008-12-02 12:01:29 +01:00
}
ProjectExplorer::BuildStepConfigWidget *MakeStep::createConfigWidget()
{
return new MakeStepConfigWidget(this);
}
void MakeStep::setMakeArguments(const QString &buildConfiguration, const QStringList &arguments)
{
setValue(buildConfiguration, "makeargs", arguments);
emit changed();
}
2008-12-02 12:01:29 +01:00
MakeStepConfigWidget::MakeStepConfigWidget(MakeStep *makeStep)
: BuildStepConfigWidget(), m_makeStep(makeStep)
{
m_ui.setupUi(this);
connect(m_ui.makeLineEdit, SIGNAL(textEdited(QString)),
2008-12-02 12:01:29 +01:00
this, SLOT(makeLineEditTextEdited()));
connect(m_ui.makeArgumentsLineEdit, SIGNAL(textEdited(QString)),
2008-12-02 12:01:29 +01:00
this, SLOT(makeArgumentsLineEditTextEdited()));
connect(makeStep, SIGNAL(changed()),
this, SLOT(update()));
connect(makeStep->project(), SIGNAL(buildDirectoryChanged()),
this, SLOT(updateDetails()));
connect(ProjectExplorer::ProjectExplorerPlugin::instance(), SIGNAL(settingsChanged()),
this, SLOT(updateMakeOverrideLabel()));
connect(ProjectExplorer::ProjectExplorerPlugin::instance(), SIGNAL(settingsChanged()),
this, SLOT(updateDetails()));
}
void MakeStepConfigWidget::updateMakeOverrideLabel()
{
Qt4Project *qt4project = qobject_cast<Qt4Project *>(m_makeStep->project());
m_ui.makeLabel->setText(tr("Override %1:").arg(qt4project->
makeCommand(qt4project->buildConfiguration(m_buildConfiguration))));
}
2009-08-13 11:47:34 +02:00
void MakeStepConfigWidget::updateDetails()
{
Qt4Project *pro = static_cast<Qt4Project *>(m_makeStep->project());
ProjectExplorer::BuildConfiguration *bc = pro->buildConfiguration(m_buildConfiguration);
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 (!QFileInfo(makeCmd).isAbsolute()) {
Environment environment = pro->environment(bc);
// Try to detect command in environment
QString tmp = environment.searchInPath(makeCmd);
if (tmp == QString::null) {
m_summaryText = tr("<b>Make Step:</b> %1 not found in the environment.").arg(makeCmd);
emit updateSummary();
return;
}
makeCmd = tmp;
}
// -w option enables "Enter"/"Leaving directory" messages, which we need for detecting the
// absolute file path
// FIXME doing this without the user having a way to override this is rather bad
// so we only do it for unix and if the user didn't override the make command
// but for now this is the least invasive change
QStringList args = m_makeStep->value(m_buildConfiguration, "makeargs").toStringList();
2009-09-03 17:45:55 +02:00
ProjectExplorer::ToolChain::ToolChainType t = ProjectExplorer::ToolChain::UNKNOWN;
ProjectExplorer::ToolChain *toolChain = pro->toolChain(bc);
2009-09-03 17:45:55 +02:00
if (toolChain)
t = toolChain->type();
if (t != ProjectExplorer::ToolChain::MSVC && t != ProjectExplorer::ToolChain::WINCE) {
if (m_makeStep->value(m_buildConfiguration, "makeCmd").toString().isEmpty())
args << "-w";
}
2009-08-13 15:25:12 +02:00
m_summaryText = tr("<b>Make:</b> %1 %2 in %3").arg(QFileInfo(makeCmd).fileName(), args.join(" "),
QDir::toNativeSeparators(workingDirectory));
emit updateSummary();
}
QString MakeStepConfigWidget::summaryText() const
{
return m_summaryText;
2008-12-02 12:01:29 +01:00
}
QString MakeStepConfigWidget::displayName() const
{
return m_makeStep->displayName();
}
void MakeStepConfigWidget::update()
{
init(m_buildConfiguration);
}
2008-12-02 12:01:29 +01:00
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");
}
2008-12-02 12:01:29 +01:00
updateMakeOverrideLabel();
const QString &makeCmd = m_makeStep->value(buildConfiguration, "makeCmd").toString();
m_ui.makeLineEdit->setText(makeCmd);
const QStringList &makeArguments =
2008-12-02 12:01:29 +01:00
m_makeStep->value(buildConfiguration, "makeargs").toStringList();
m_ui.makeArgumentsLineEdit->setText(ProjectExplorer::Environment::joinArgumentList(makeArguments));
2009-08-13 11:47:34 +02:00
updateDetails();
2008-12-02 12:01:29 +01:00
}
void MakeStepConfigWidget::makeLineEditTextEdited()
{
Q_ASSERT(!m_buildConfiguration.isNull());
2008-12-02 12:01:29 +01:00
m_makeStep->setValue(m_buildConfiguration, "makeCmd", m_ui.makeLineEdit->text());
2009-08-13 11:47:34 +02:00
updateDetails();
2008-12-02 12:01:29 +01:00
}
void MakeStepConfigWidget::makeArgumentsLineEditTextEdited()
{
Q_ASSERT(!m_buildConfiguration.isNull());
m_makeStep->setValue(m_buildConfiguration, "makeargs",
ProjectExplorer::Environment::parseCombinedArgString(m_ui.makeArgumentsLineEdit->text()));
2009-08-13 11:47:34 +02:00
updateDetails();
2008-12-02 12:01:29 +01:00
}
///
// MakeStep
///
MakeStepFactory::MakeStepFactory()
{
}
MakeStepFactory::~MakeStepFactory()
{
}
bool MakeStepFactory::canCreate(const QString & name) const
{
return (name == Constants::MAKESTEP);
}
ProjectExplorer::BuildStep * MakeStepFactory::create(ProjectExplorer::Project * pro, const QString & name) const
{
Q_UNUSED(name)
return new MakeStep(static_cast<Qt4Project *>(pro));
}
QStringList MakeStepFactory::canCreateForProject(ProjectExplorer::Project *pro) const
{
if (qobject_cast<Qt4Project *>(pro))
return QStringList() << Constants::MAKESTEP;
else
return QStringList();
}
QString MakeStepFactory::displayNameForName(const QString &name) const
{
Q_UNUSED(name)
return tr("Make");
}