** conditions contained in a signed written agreement between you and Nokia.
**
** If you have questions regarding the use of this file, please contact
-** Nokia at qt-info@nokia.com.
+** Nokia at info@qt.nokia.com.
**
**************************************************************************/
#include "qt4nodes.h"
#include "qmakestep.h"
#include "makestep.h"
+#include "qt4basetargetfactory.h"
#include <utils/qtcassert.h>
#include <utils/qtcprocess.h>
#include <limits>
#include <projectexplorer/buildsteplist.h>
#include <projectexplorer/projectexplorerconstants.h>
+#include <projectexplorer/toolchain.h>
#include <projectexplorer/toolchainmanager.h>
-
+#include <qtsupport/qtversionfactory.h>
+#include <qtsupport/baseqtversion.h>
+#include <qtsupport/qtversionmanager.h>
#include <QtCore/QDebug>
#include <QtGui/QInputDialog>
return map;
}
-static inline QString msgBuildConfigNotApplicable(const QString &d, const QtVersion *qtVersion,
+static inline QString msgBuildConfigNotApplicable(const QString &d, const QtSupport::BaseQtVersion *qtVersion,
const Target *target)
{
return QString::fromLatin1("Warning: Buildconfiguration '%1' : Qt '%2' from %3 not supported by target '%4'").
arg(d, qtVersion->displayName(), qtVersion->qmakeCommand(), target->id());
}
-#include "qt4basetargetfactory.h"
-
bool Qt4BuildConfiguration::fromMap(const QVariantMap &map)
{
if (!BuildConfiguration::fromMap(map))
m_shadowBuild = map.value(QLatin1String(USE_SHADOW_BUILD_KEY), true).toBool();
m_qtVersionId = map.value(QLatin1String(QT_VERSION_ID_KEY)).toInt();
ProjectExplorer::ToolChain *tc = toolChain();
- m_qmakeBuildConfiguration = QtVersion::QmakeBuildConfigs(map.value(QLatin1String(BUILD_CONFIGURATION_KEY)).toInt());
+ m_qmakeBuildConfiguration = QtSupport::BaseQtVersion::QmakeBuildConfigs(map.value(QLatin1String(BUILD_CONFIGURATION_KEY)).toInt());
m_buildDirectory = map.value(QLatin1String(BUILD_DIRECTORY_KEY), defaultShadowBuildDirectory()).toString();
- m_lastEmmitedBuildDirectory = buildDirectory();
-
// Pick a Qt version if the default version is used:
// We assume that the default Qt version was used in earlier versions of Qt creator.
- // Pick a Qt version that is supporting a desktop.
+ // Pick a Qt version that supports this target (usually desktop)
if (m_qtVersionId == 0) {
- QList<QtVersion *> versions = QtVersionManager::instance()->versions();
- foreach (QtVersion *v, versions) {
- if (v->isValid() && v->supportsTargetId(QLatin1String(Constants::DESKTOP_TARGET_ID))) {
+ QList<QtSupport::BaseQtVersion *> versions = QtSupport::QtVersionManager::instance()->versionsForTargetId(target()->id());
+ foreach (QtSupport::BaseQtVersion *v, versions) {
+ if (v->isValid()) {
m_qtVersionId = v->uniqueId();
break;
}
}
if (m_qtVersionId == 0)
- m_qtVersionId = versions.at(0)->uniqueId();
+ m_qtVersionId = -1;
}
- QtVersion *version = qtVersion();
- if (!map.contains(QLatin1String("Qt4ProjectManager.Qt4BuildConfiguration.NeedsV0Update"))) { // we are not upgrading from pre-targets!
- if (version->isValid() && !version->supportedTargetIds().contains(target()->id())) {
- qWarning("%s", qPrintable(msgBuildConfigNotApplicable(displayName(), version, target())));
- return false;
- }
- } else {
- if (!version->isValid() || !version->supportedTargetIds().contains(target()->id())) {
- qWarning("%s", qPrintable(msgBuildConfigNotApplicable(displayName(), version, target())));
- return false;
- }
+ QtSupport::BaseQtVersion *version = QtSupport::QtVersionManager::instance()->version(m_qtVersionId);
+ if (!version || !version->supportsTargetId(target()->id())) {
+ m_qtVersionId = -1;
+ version = 0;
}
- if (version->isValid()) {
- if (!tc)
- tc = qt4Target()->preferredToolChain(this);
- if (tc && qt4Target()->possibleToolChains(this).contains(tc))
- setToolChain(tc);
+ m_lastEmmitedBuildDirectory = buildDirectory();
+
+ if (version && version->isValid()) {
+ if (tc && !qt4Target()->possibleToolChains(this).contains(tc))
+ setToolChain(0);
+ if (!toolChain())
+ setToolChain(qt4Target()->preferredToolChain(this));
m_shadowBuild = (m_shadowBuild && version->supportsShadowBuilds());
}
if (!toolChain()) {
- if (version->isValid()) {
+ if (version && version->isValid()) {
qWarning("Warning: No tool chain available for '%s' from %s used in '%s'.",
qPrintable(version->displayName()), qPrintable(version->qmakeCommand()),
qPrintable(target()->id()));
qWarning("Warning: No tool chain available for invalid Qt version used in '%s'.",
qPrintable(target()->id()));
}
- return false;
}
return true;
connect(this, SIGNAL(environmentChanged()),
this, SLOT(emitBuildDirectoryChanged()));
connect(this, SIGNAL(environmentChanged()),
- this, SLOT(emitProFileEvaluteNeeded()));
+ this, SLOT(emitProFileEvaluateNeeded()));
+ connect(qt4Target()->qt4Project(), SIGNAL(proFileUpdated(Qt4ProjectManager::Qt4ProFileNode*,bool,bool)),
+ this, SLOT(proFileUpdated()));
- QtVersionManager *vm = QtVersionManager::instance();
+ QtSupport::QtVersionManager *vm = QtSupport::QtVersionManager::instance();
connect(vm, SIGNAL(qtVersionsChanged(QList<int>)),
this, SLOT(qtVersionsChanged(QList<int>)));
}
}
}
-void Qt4BuildConfiguration::pickValidQtVersion()
+void Qt4BuildConfiguration::proFileUpdated()
{
- QList<QtVersion *> versions = QtVersionManager::instance()->versionsForTargetId(qt4Target()->id());
- if (!versions.isEmpty())
- setQtVersion(versions.at(0));
- else
- setQtVersion(QtVersionManager::instance()->emptyVersion());
+ // Changing the included Qt modules from 0 to at least one might have caused the
+ // tool chain to become invalid.
+ if (!qt4Target()->possibleToolChains(this).contains(toolChain()))
+ setToolChain(qt4Target()->preferredToolChain(this));
}
Qt4BaseTarget *Qt4BuildConfiguration::qt4Target() const
Utils::Environment Qt4BuildConfiguration::baseEnvironment() const
{
Utils::Environment env = BuildConfiguration::baseEnvironment();
- qtVersion()->addToEnvironment(env);
+ if (qtVersion())
+ qtVersion()->addToEnvironment(env);
ToolChain *tc = toolChain();
if (tc)
/// If only a sub tree should be build this function returns which sub node
/// should be build
/// \see Qt4BuildConfiguration::setSubNodeBuild
-Qt4ProjectManager::Internal::Qt4ProFileNode *Qt4BuildConfiguration::subNodeBuild() const
+Qt4ProjectManager::Qt4ProFileNode *Qt4BuildConfiguration::subNodeBuild() const
{
return m_subNodeBuild;
}
/// calling BuildManager::buildProject( BuildConfiguration * )
/// and reset immediately afterwards
/// That is m_subNodesBuild is set only temporarly
-void Qt4BuildConfiguration::setSubNodeBuild(Qt4ProjectManager::Internal::Qt4ProFileNode *node)
+void Qt4BuildConfiguration::setSubNodeBuild(Qt4ProjectManager::Qt4ProFileNode *node)
{
m_subNodeBuild = node;
}
void Qt4BuildConfiguration::setShadowBuildAndDirectory(bool shadowBuild, const QString &buildDirectory)
{
- QtVersion *version = qtVersion();
+ QtSupport::BaseQtVersion *version = qtVersion();
QString directoryToSet = buildDirectory;
- bool toSet = (shadowBuild && version->isValid() && version->supportsShadowBuilds());
+ bool toSet = (shadowBuild && version && version->isValid() && version->supportsShadowBuilds());
if (m_shadowBuild == toSet && m_buildDirectory == directoryToSet)
return;
return tc ? tc->makeCommand() : "make";
}
-static inline QString symbianMakeTarget(QtVersion::QmakeBuildConfigs buildConfig,
+static inline QString symbianMakeTarget(QtSupport::BaseQtVersion::QmakeBuildConfigs buildConfig,
const QString &type)
{
- QString rc = (buildConfig & QtVersion::DebugBuild) ?
+ QString rc = (buildConfig & QtSupport::BaseQtVersion::DebugBuild) ?
QLatin1String("debug-") : QLatin1String("release-");
rc += type;
return rc;
ToolChain *tc = toolChain();
if (!tc || target()->id() != Constants::S60_DEVICE_TARGET_ID)
return QString();
- const QtVersion::QmakeBuildConfigs buildConfig = qmakeBuildConfiguration();
+ const QtSupport::BaseQtVersion::QmakeBuildConfigs buildConfig = qmakeBuildConfiguration();
return symbianMakeTarget(buildConfig, tc->defaultMakeTarget());
}
QString Qt4BuildConfiguration::makefile() const
{
- return qt4Target()->qt4Project()->rootProjectNode()->makefile();
+ return qt4Target()->qt4Project()->rootQt4ProjectNode()->makefile();
}
-QtVersion *Qt4BuildConfiguration::qtVersion() const
+QtSupport::BaseQtVersion *Qt4BuildConfiguration::qtVersion() const
{
- QtVersionManager *vm = QtVersionManager::instance();
+ QtSupport::QtVersionManager *vm = QtSupport::QtVersionManager::instance();
return vm->version(m_qtVersionId);
}
-void Qt4BuildConfiguration::setQtVersion(QtVersion *version)
+void Qt4BuildConfiguration::setQtVersion(QtSupport::BaseQtVersion *version)
{
- Q_ASSERT(version);
-
- if (m_qtVersionId == version->uniqueId())
+ if (version == 0) {
+ m_qtVersionId = -1;
+ m_shadowBuild = false;
+ setToolChain(0);
+ emit proFileEvaluateNeeded(this);
+ emit qtVersionChanged();
+ emit environmentChanged();
+ emitBuildDirectoryChanged();
return;
+ }
+ if (m_qtVersionId == version->uniqueId())
+ return;
m_qtVersionId = version->uniqueId();
void Qt4BuildConfiguration::setToolChain(ProjectExplorer::ToolChain *tc)
{
- Q_ASSERT(qtVersion());
if (tc != 0 && !qt4Target()->possibleToolChains(this).contains(tc))
return;
+ if (toolChain() == tc)
+ return;
+
BuildConfiguration::setToolChain(tc);
emit proFileEvaluateNeeded(this);
- emit environmentChanged();
emitBuildDirectoryChanged();
}
-QtVersion::QmakeBuildConfigs Qt4BuildConfiguration::qmakeBuildConfiguration() const
+QtSupport::BaseQtVersion::QmakeBuildConfigs Qt4BuildConfiguration::qmakeBuildConfiguration() const
{
return m_qmakeBuildConfiguration;
}
-void Qt4BuildConfiguration::setQMakeBuildConfiguration(QtVersion::QmakeBuildConfigs config)
+void Qt4BuildConfiguration::setQMakeBuildConfiguration(QtSupport::BaseQtVersion::QmakeBuildConfigs config)
{
if (m_qmakeBuildConfiguration == config)
return;
emitBuildDirectoryChanged();
}
-void Qt4BuildConfiguration::emitProFileEvaluteNeeded()
+void Qt4BuildConfiguration::emitProFileEvaluateNeeded()
{
emit proFileEvaluateNeeded(this);
}
QStringList Qt4BuildConfiguration::configCommandLineArguments() const
{
QStringList result;
- QtVersion::QmakeBuildConfigs defaultBuildConfiguration = qtVersion()->defaultBuildConfig();
- QtVersion::QmakeBuildConfigs userBuildConfiguration = m_qmakeBuildConfiguration;
- if ((defaultBuildConfiguration & QtVersion::BuildAll) && !(userBuildConfiguration & QtVersion::BuildAll))
+ QtSupport::BaseQtVersion::QmakeBuildConfigs defaultBuildConfiguration = qtVersion() ? qtVersion()->defaultBuildConfig() : (QtSupport::BaseQtVersion::DebugBuild | QtSupport::BaseQtVersion::BuildAll);
+ QtSupport::BaseQtVersion::QmakeBuildConfigs userBuildConfiguration = m_qmakeBuildConfiguration;
+ if ((defaultBuildConfiguration & QtSupport::BaseQtVersion::BuildAll) && !(userBuildConfiguration & QtSupport::BaseQtVersion::BuildAll))
result << "CONFIG-=debug_and_release";
- if (!(defaultBuildConfiguration & QtVersion::BuildAll) && (userBuildConfiguration & QtVersion::BuildAll))
+ if (!(defaultBuildConfiguration & QtSupport::BaseQtVersion::BuildAll) && (userBuildConfiguration & QtSupport::BaseQtVersion::BuildAll))
result << "CONFIG+=debug_and_release";
- if ((defaultBuildConfiguration & QtVersion::DebugBuild)
- && !(userBuildConfiguration & QtVersion::DebugBuild)
- && !(userBuildConfiguration & QtVersion::BuildAll))
+ if ((defaultBuildConfiguration & QtSupport::BaseQtVersion::DebugBuild) && !(userBuildConfiguration & QtSupport::BaseQtVersion::DebugBuild))
result << "CONFIG+=release";
- if (!(defaultBuildConfiguration & QtVersion::DebugBuild)
- && (userBuildConfiguration & QtVersion::DebugBuild)
- && !(userBuildConfiguration & QtVersion::BuildAll))
+ if (!(defaultBuildConfiguration & QtSupport::BaseQtVersion::DebugBuild) && (userBuildConfiguration & QtSupport::BaseQtVersion::DebugBuild))
result << "CONFIG+=debug";
return result;
}
{
if (!changedVersions.contains(m_qtVersionId))
return;
- if (!qtVersion()->isValid())
- pickValidQtVersion();
emit environmentChanged(); // Our qt version changed, that might have changed the environment
}
{
QMakeStep *qs = qmakeStep();
if (QFileInfo(makefile).exists() && qs) {
- QString qmakePath = QtVersionManager::findQMakeBinaryFromMakefile(makefile);
- QtVersion *version = qtVersion();
+ QString qmakePath = QtSupport::QtVersionManager::findQMakeBinaryFromMakefile(makefile);
+ QtSupport::BaseQtVersion *version = qtVersion();
+ if (!version)
+ return false;
if (version->qmakeCommand() == qmakePath) {
// same qtversion
- QPair<QtVersion::QmakeBuildConfigs, QString> result =
- QtVersionManager::scanMakeFile(makefile, version->defaultBuildConfig());
+ QPair<QtSupport::BaseQtVersion::QmakeBuildConfigs, QString> result =
+ QtSupport::QtVersionManager::scanMakeFile(makefile, version->defaultBuildConfig());
if (qmakeBuildConfiguration() == result.first) {
// The qmake Build Configuration are the same,
// now compare arguments lists
// we have to compare without the spec/platform cmd argument
// and compare that on its own
QString workingDirectory = QFileInfo(makefile).absolutePath();
- QString userArgs = qs->userArguments();
QStringList actualArgs;
- QString actualSpec = extractSpecFromArguments(&userArgs, workingDirectory, version, &actualArgs);
- if (actualSpec.isEmpty()) {
- // Easy one: the user has chosen not to override the settings
- actualSpec = version->mkspec();
- }
+ QString userArgs = qs->userArguments();
+ // This copies the settings from userArgs to actualArgs (minus some we
+ // are not interested in), splitting them up into individual strings:
+ extractSpecFromArguments(&userArgs, workingDirectory, version, &actualArgs),
actualArgs += qs->moreArguments();
+ QString actualSpec = qs->mkspec();
QString qmakeArgs = result.second;
QStringList parsedArgs;
return false;
}
-void Qt4BuildConfiguration::removeQMLInspectorFromArguments(QString *args)
+bool Qt4BuildConfiguration::removeQMLInspectorFromArguments(QString *args)
{
- for (Utils::QtcProcess::ArgIterator ait(args); ait.next(); )
- if (ait.value().contains(QLatin1String(Constants::QMAKEVAR_QMLJSDEBUGGER_PATH)))
+ bool removedArgument = false;
+ for (Utils::QtcProcess::ArgIterator ait(args); ait.next(); ) {
+ const QString arg = ait.value();
+ if (arg.contains(QLatin1String(Constants::QMAKEVAR_QMLJSDEBUGGER_PATH))
+ || arg.contains(Constants::QMAKEVAR_DECLARATIVE_DEBUG)) {
ait.deleteArg();
+ removedArgument = true;
+ }
+ }
+ return removedArgument;
}
QString Qt4BuildConfiguration::extractSpecFromArguments(QString *args,
- const QString &directory, const QtVersion *version,
+ const QString &directory, const QtSupport::BaseQtVersion *version,
QStringList *outArgs)
{
QString parsedSpec;
return m_isEnabled;
}
+QString Qt4BuildConfiguration::disabledReason() const
+{
+ if (!m_isEnabled)
+ return tr("Parsing the .pro file");
+ return QString();
+}
+
void Qt4BuildConfiguration::setEnabled(bool enabled)
{
if (m_isEnabled == enabled)
{
update();
- QtVersionManager *vm = QtVersionManager::instance();
+ QtSupport::QtVersionManager *vm = QtSupport::QtVersionManager::instance();
connect(vm, SIGNAL(qtVersionsChanged(QList<int>)),
this, SLOT(update()));
}
void Qt4BuildConfigurationFactory::update()
{
m_versions.clear();
- QtVersionManager *vm = QtVersionManager::instance();
- foreach (const QtVersion *version, vm->versions()) {
- if (version->isValid()) {
- QString key = QString::fromLatin1(QT4_BC_ID_PREFIX)
- + QString::fromLatin1("Qt%1").arg(version->uniqueId());
- VersionInfo info(tr("Using Qt Version \"%1\"").arg(version->displayName()), version->uniqueId());
- m_versions.insert(key, info);
- }
+ QtSupport::QtVersionManager *vm = QtSupport::QtVersionManager::instance();
+ foreach (QtSupport::BaseQtVersion *version, vm->validVersions()) {
+ QString key = QString::fromLatin1(QT4_BC_ID_PREFIX)
+ + QString::fromLatin1("Qt%1").arg(version->uniqueId());
+ VersionInfo info(tr("Using Qt Version \"%1\"").arg(version->displayName()), version->uniqueId());
+ m_versions.insert(key, info);
}
emit availableCreationIdsChanged();
}
return QStringList();
QStringList results;
- QtVersionManager *vm = QtVersionManager::instance();
+ QtSupport::QtVersionManager *vm = QtSupport::QtVersionManager::instance();
for (QMap<QString, VersionInfo>::const_iterator i = m_versions.constBegin();
i != m_versions.constEnd(); ++i) {
- if (vm->version(i.value().versionId)->supportsTargetId(parent->id()))
+ if (vm->version(i.value().versionId)->supportsTargetId(parent->id())
+ && vm->version(i.value().versionId)->toolChainAvailable(parent->id()))
results.append(i.key());
}
return results;
if (!m_versions.contains(id))
return false;
const VersionInfo &info = m_versions.value(id);
- QtVersion *version = QtVersionManager::instance()->version(info.versionId);
+ QtSupport::BaseQtVersion *version = QtSupport::QtVersionManager::instance()->version(info.versionId);
if (!version ||
!version->supportsTargetId(parent->id()))
return false;
return 0;
const VersionInfo &info = m_versions.value(id);
- QtVersion *version = QtVersionManager::instance()->version(info.versionId);
+ QtSupport::BaseQtVersion *version = QtSupport::QtVersionManager::instance()->version(info.versionId);
Q_ASSERT(version);
Qt4BaseTarget *qt4Target = static_cast<Qt4BaseTarget *>(parent);
return 0;
//: Debug build configuration. We recommend not translating it.
- qt4Target->addQt4BuildConfiguration(tr("%1 Debug").arg(buildConfigurationName),
- version,
- (version->defaultBuildConfig() | QtVersion::DebugBuild),
- QString(), QString());
- BuildConfiguration *bc =
- //: Release build configuration. We recommend not translating it.
- qt4Target->addQt4BuildConfiguration(tr("%1 Release").arg(buildConfigurationName),
+ QString defaultDebugName = tr("%1 Debug").arg(version->displayName());
+ QString customDebugName;
+ if (buildConfigurationName != version->displayName())
+ customDebugName = tr("%1 Debug").arg(buildConfigurationName);
+
+ BuildConfiguration *bc = qt4Target->addQt4BuildConfiguration(defaultDebugName, customDebugName,
version,
- (version->defaultBuildConfig() & ~QtVersion::DebugBuild),
- QString(), QString());
+ (version->defaultBuildConfig() | QtSupport::BaseQtVersion::DebugBuild),
+ QString(), QString(), false);
+
+ if (qt4Target->id() != Constants::S60_EMULATOR_TARGET_ID) {
+ //: Release build configuration. We recommend not translating it.
+ QString defaultReleaseName = tr("%1 Release").arg(version->displayName());
+ QString customReleaseName;
+ if (buildConfigurationName != version->displayName())
+ customReleaseName = tr("%1 Release").arg(buildConfigurationName);
+
+ bc = qt4Target->addQt4BuildConfiguration(defaultReleaseName, customReleaseName,
+ version,
+ (version->defaultBuildConfig() & ~QtSupport::BaseQtVersion::DebugBuild),
+ QString(), QString(), false);
+ }
return bc;
}
if (!qt4bc)
return false;
- QtVersion *version = qt4bc->qtVersion();
+ QtSupport::BaseQtVersion *version = qt4bc->qtVersion();
if (!version ||
!version->supportsTargetId(parent->id()))
return false;
else
mkfile.append(makefile());
- QString qmakePath = QtVersionManager::findQMakeBinaryFromMakefile(mkfile);
+ QString qmakePath = QtSupport::QtVersionManager::findQMakeBinaryFromMakefile(mkfile);
if (!qmakePath.isEmpty()) {
- QtVersionManager *vm = QtVersionManager::instance();
- QtVersion *version = vm->qtVersionForQMakeBinary(qmakePath);
+ QtSupport::QtVersionManager *vm = QtSupport::QtVersionManager::instance();
+ QtSupport::BaseQtVersion *version = vm->qtVersionForQMakeBinary(qmakePath);
if (!version) {
- version = new QtVersion(qmakePath);
+ version = QtSupport::QtVersionFactory::createQtVersionFromQMakePath(qmakePath);
vm->addVersion(version);
}
- QPair<QtVersion::QmakeBuildConfigs, QString> result =
- QtVersionManager::scanMakeFile(directory, version->defaultBuildConfig());
- QtVersion::QmakeBuildConfigs qmakeBuildConfig = result.first;
-
- QString aa = result.second;
- QString parsedSpec = Qt4BuildConfiguration::extractSpecFromArguments(&aa, directory, version);
- QString versionSpec = version->mkspec();
- QString additionalArguments;
- if (parsedSpec.isEmpty() || parsedSpec == versionSpec || parsedSpec == "default") {
- // using the default spec, don't modify additional arguments
- } else {
- additionalArguments = "-spec " + Utils::QtcProcess::quoteArg(parsedSpec);
- }
- Utils::QtcProcess::addArgs(&additionalArguments, aa);
+ QPair<QtSupport::BaseQtVersion::QmakeBuildConfigs, QString> result =
+ QtSupport::QtVersionManager::scanMakeFile(mkfile, version->defaultBuildConfig());
+ QtSupport::BaseQtVersion::QmakeBuildConfigs qmakeBuildConfig = result.first;
- Qt4BuildConfiguration::removeQMLInspectorFromArguments(&additionalArguments);
+ QString additionalArguments = result.second;
+ QString parsedSpec = Qt4BuildConfiguration::extractSpecFromArguments(&additionalArguments, directory, version);
+ const bool enableQmlDebugger =
+ Qt4BuildConfiguration::removeQMLInspectorFromArguments(&additionalArguments);
// So we got all the information now apply it...
setQtVersion(version);
- qmakeStep()->setUserArguments(additionalArguments);
+ QMakeStep *qs = qmakeStep();
+ qs->setUserArguments(additionalArguments);
+ qs->setLinkQmlDebuggingLibrary(enableQmlDebugger);
+ if (!parsedSpec.isEmpty() && parsedSpec != QLatin1String("default") && qs->mkspec() != parsedSpec) {
+ Utils::QtcProcess::addArgs(&additionalArguments, (QStringList() << "-spec" << parsedSpec));
+ qs->setUserArguments(additionalArguments);
+ }
setQMakeBuildConfiguration(qmakeBuildConfig);
// Adjust command line arguments, this is ugly as hell
// If we are switching to BuildAll we want "release" in there and no "debug"
// or "debug" in there and no "release"
- // If we are switching to not BuildAl we want neither "release" nor "debug" in there
- bool debug = qmakeBuildConfig & QtVersion::DebugBuild;
- bool haveTag = !(qmakeBuildConfig & QtVersion::BuildAll);
+ // If we are switching to not BuildAll we want neither "release" nor "debug" in there
+ bool debug = qmakeBuildConfig & QtSupport::BaseQtVersion::DebugBuild;
+ bool haveTag = !(qmakeBuildConfig & QtSupport::BaseQtVersion::BuildAll);
QString makeCmdArguments = makeStep()->userArguments();
Utils::QtcProcess::ArgIterator ait(&makeCmdArguments);
while (ait.next()) {
BuildConfiguration::BuildType Qt4BuildConfiguration::buildType() const
{
- if (qmakeBuildConfiguration() & QtVersion::DebugBuild)
+ if (qmakeBuildConfiguration() & QtSupport::BaseQtVersion::DebugBuild)
return Debug;
else
return Release;
}
-
OSDN Git Service
