bool AndroidPackageInstallationStep::init() { ProjectExplorer::BuildConfiguration *bc = buildConfiguration(); QString dirPath = bc->buildDirectory().appendPath(QLatin1String(Constants::ANDROID_BUILDDIRECTORY)).toString(); if (Utils::HostOsInfo::isWindowsHost()) if (bc->environment().searchInPath(QLatin1String("sh.exe")).isEmpty()) dirPath = QDir::toNativeSeparators(dirPath); ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit()); ProjectExplorer::ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); pp->setWorkingDirectory(bc->buildDirectory().toString()); pp->setCommand(tc->makeCommand(bc->environment())); Utils::Environment env = bc->environment(); // Force output to english for the parsers. Do this here and not in the toolchain's // addToEnvironment() to not screw up the users run environment. env.set(QLatin1String("LC_ALL"), QLatin1String("C")); pp->setEnvironment(env); pp->setArguments(QString::fromLatin1("INSTALL_ROOT=\"%1\" install").arg(dirPath)); pp->resolveAll(); setOutputParser(new ProjectExplorer::GnuMakeParser()); ProjectExplorer::IOutputParser *parser = target()->kit()->createOutputParser(); if (parser) appendOutputParser(parser); outputParser()->setWorkingDirectory(pp->effectiveWorkingDirectory()); m_androidDirToClean = dirPath; return AbstractProcessStep::init(); }
QList<ProjectExplorer::Task> BaseQtVersion::validateKit(const ProjectExplorer::Kit *k) { QList<ProjectExplorer::Task> result; BaseQtVersion *version = QtKitInformation::qtVersion(k); Q_ASSERT(version == this); ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(k); const QList<ProjectExplorer::Abi> qtAbis = version->qtAbis(); if (tc && !qtAbis.contains(tc->targetAbi())) { QString qtAbiString; foreach (const ProjectExplorer::Abi &qtAbi, qtAbis) { if (!qtAbiString.isEmpty()) qtAbiString.append(QLatin1Char(' ')); qtAbiString.append(qtAbi.toString()); } const QString message = QCoreApplication::translate("BaseQtVersion", "The compiler '%1' (%2) cannot produce code for the Qt version '%3' (%4)."). arg(tc->displayName(), tc->targetAbi().toString(), version->displayName(), qtAbiString); result << ProjectExplorer::Task(ProjectExplorer::Task::Error, message, FileName(), -1, Core::Id(ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM)); } // Abi mismatch
ProjectExplorer::IOutputParser *GenericBuildConfiguration::createOutputParser() const { ProjectExplorer::ToolChain *tc = genericTarget()->genericProject()->toolChain(); if (tc) return tc->outputParser(); return 0; }
QMakeStepConfig QMakeStep::deducedArguments() const { ProjectExplorer::Kit *kit = target()->kit(); QMakeStepConfig config; ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(kit); ProjectExplorer::Abi targetAbi; if (tc) targetAbi = tc->targetAbi(); BaseQtVersion *version = QtKitInformation::qtVersion(target()->kit()); config.archConfig = QMakeStepConfig::targetArchFor(targetAbi, version); config.osType = QMakeStepConfig::osTypeFor(targetAbi, version); if (linkQmlDebuggingLibrary() && version && version->qtVersion().majorVersion >= 5) config.linkQmlDebuggingQQ2 = true; if (useQtQuickCompiler() && version) config.useQtQuickCompiler = true; if (separateDebugInfo()) config.separateDebugInfo = true; return config; }
BuildInfo CMakeBuildConfigurationFactory::createBuildInfo(const Kit *k, const QString &sourceDir, BuildType buildType) const { BuildInfo info(this); info.kitId = k->id(); CMakeExtraBuildInfo extra; extra.sourceDirectory = sourceDir; CMakeConfigItem buildTypeItem; switch (buildType) { case BuildTypeNone: info.typeName = tr("Build"); break; case BuildTypeDebug: buildTypeItem = {CMakeConfigItem("CMAKE_BUILD_TYPE", "Debug")}; info.typeName = tr("Debug"); info.buildType = BuildConfiguration::Debug; break; case BuildTypeRelease: buildTypeItem = {CMakeConfigItem("CMAKE_BUILD_TYPE", "Release")}; info.typeName = tr("Release"); info.buildType = BuildConfiguration::Release; break; case BuildTypeMinSizeRel: buildTypeItem = {CMakeConfigItem("CMAKE_BUILD_TYPE", "MinSizeRel")}; info.typeName = tr("Minimum Size Release"); info.buildType = BuildConfiguration::Release; break; case BuildTypeRelWithDebInfo: buildTypeItem = {CMakeConfigItem("CMAKE_BUILD_TYPE", "RelWithDebInfo")}; info.typeName = tr("Release with Debug Information"); info.buildType = BuildConfiguration::Profile; break; default: QTC_CHECK(false); break; } if (!buildTypeItem.isNull()) extra.configuration.append(buildTypeItem); const QString sysRoot = SysRootKitInformation::sysRoot(k).toString(); if (!sysRoot.isEmpty()) { extra.configuration.append(CMakeConfigItem("CMAKE_SYSROOT", sysRoot.toUtf8())); ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain( k, ProjectExplorer::Constants::CXX_LANGUAGE_ID); if (tc) { const QByteArray targetTriple = tc->originalTargetTriple().toUtf8(); extra.configuration.append(CMakeConfigItem("CMAKE_C_COMPILER_TARGET", targetTriple)); extra.configuration.append(CMakeConfigItem("CMAKE_CXX_COMPILER_TARGET ", targetTriple)); } } info.extraInfo = QVariant::fromValue(extra); return info; }
/// /// moreArguments, /// -unix for Maemo /// QMAKE_VAR_QMLJSDEBUGGER_PATH QStringList QMakeStep::deducedArguments() { QStringList arguments; ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainProfileInformation::toolChain(target()->profile()); ProjectExplorer::Abi targetAbi; if (tc) targetAbi = tc->targetAbi(); #if defined(Q_OS_WIN) || defined(Q_OS_MAC) if ((targetAbi.osFlavor() == ProjectExplorer::Abi::HarmattanLinuxFlavor || targetAbi.osFlavor() == ProjectExplorer::Abi::MaemoLinuxFlavor)) arguments << QLatin1String("-unix"); #endif // explicitly add architecture to CONFIG if ((targetAbi.os() == ProjectExplorer::Abi::MacOS) && (targetAbi.binaryFormat() == ProjectExplorer::Abi::MachOFormat)) { if (targetAbi.architecture() == ProjectExplorer::Abi::X86Architecture) { if (targetAbi.wordWidth() == 32) arguments << QLatin1String("CONFIG+=x86"); else if (targetAbi.wordWidth() == 64) arguments << QLatin1String("CONFIG+=x86_64"); } else if (targetAbi.architecture() == ProjectExplorer::Abi::PowerPCArchitecture) { if (targetAbi.wordWidth() == 32) arguments << QLatin1String("CONFIG+=ppc"); else if (targetAbi.wordWidth() == 64) arguments << QLatin1String("CONFIG+=ppc64"); } } QtSupport::BaseQtVersion *version = QtSupport::QtProfileInformation::qtVersion(target()->profile()); if (linkQmlDebuggingLibrary() && version) { if (!version->needsQmlDebuggingLibrary()) { // This Qt version has the QML debugging services built in, however // they still need to be enabled at compile time arguments << (version->qtVersion().majorVersion >= 5 ? QLatin1String(Constants::QMAKEVAR_DECLARATIVE_DEBUG5) : QLatin1String(Constants::QMAKEVAR_DECLARATIVE_DEBUG4)); } else { const QString qmlDebuggingHelperLibrary = version->qmlDebuggingHelperLibrary(true); if (!qmlDebuggingHelperLibrary.isEmpty()) { // Do not turn debugger path into native path separators: Qmake does not like that! const QString debuggingHelperPath = QFileInfo(qmlDebuggingHelperLibrary).dir().path(); arguments << QLatin1String(Constants::QMAKEVAR_QMLJSDEBUGGER_PATH) + QLatin1Char('=') + debuggingHelperPath; } } } return arguments; }
QString PuppetCreator::buildCommand() const { Utils::Environment environment = Utils::Environment::systemEnvironment(); m_kit->addToEnvironment(environment); ProjectExplorer::ToolChain *toolChain = ProjectExplorer::ToolChainKitInformation::toolChain(m_kit); if (toolChain) return toolChain->makeCommand(environment); return QString(); }
ProjectExplorer::IOutputParser *CMakeBuildConfiguration::createOutputParser() const { ProjectExplorer::IOutputParser *parserchain = new ProjectExplorer::GnuMakeParser; int versionId = QtSupport::QtKitInformation::qtVersionId(target()->kit()); if (versionId >= 0) parserchain->appendOutputParser(new QtSupport::QtParser); ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit()); if (tc) parserchain->appendOutputParser(tc->outputParser()); return parserchain; }
QList<Core::Id> RemoteLinuxDeployConfigurationFactory::availableCreationIds(Target *parent) const { QList<Core::Id> ids; if (!parent->project()->supportsKit(parent->kit())) return ids; ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(parent->kit()); if (!tc || tc->targetAbi().os() != ProjectExplorer::Abi::LinuxOS) return ids; const Core::Id devType = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(parent->kit()); if (devType == Constants::GenericLinuxOsType) ids << genericDeployConfigurationId(); return ids; }
/// /// moreArguments, /// -unix for Maemo /// -after OBJECTS_DIR, MOC_DIR, UI_DIR, RCC_DIR /// QMAKE_VAR_QMLJSDEBUGGER_PATH QStringList QMakeStep::moreArguments() { Qt4BuildConfiguration *bc = qt4BuildConfiguration(); QStringList arguments; #if defined(Q_OS_WIN) || defined(Q_OS_MAC) ProjectExplorer::ToolChain *tc = bc->toolChain(); if (tc && (tc->targetAbi().osFlavor() == ProjectExplorer::Abi::HarmattanLinuxFlavor || tc->targetAbi().osFlavor() == ProjectExplorer::Abi::MaemoLinuxFlavor)) arguments << QLatin1String("-unix"); #endif if (linkQmlDebuggingLibrary() && bc->qtVersion()) { if (!bc->qtVersion()->needsQmlDebuggingLibrary()) { // This Qt version has the QML debugging services built in, however // they still need to be enabled at compile time arguments << QLatin1String("CONFIG+=declarative_debug"); } else { QString qmlDebuggingHelperLibrary = bc->qtVersion()->qmlDebuggingHelperLibrary(true); if (!qmlDebuggingHelperLibrary.isEmpty()) { // Do not turn debugger path into native path separators: Qmake does not like that! const QString debuggingHelperPath = QFileInfo(qmlDebuggingHelperLibrary).dir().path(); arguments << QLatin1String(Constants::QMAKEVAR_QMLJSDEBUGGER_PATH) + QLatin1Char('=') + debuggingHelperPath; } } } if (bc->qtVersion() && !bc->qtVersion()->supportsShadowBuilds()) { // We have a target which does not allow shadow building. // But we really don't want to have the build artefacts in the source dir // so we try to hack around it, to make the common cases work. // This is a HACK, remove once the symbian make generator supports // shadow building arguments << QLatin1String("-after") << QLatin1String("OBJECTS_DIR=obj") << QLatin1String("MOC_DIR=moc") << QLatin1String("UI_DIR=ui") << QLatin1String("RCC_DIR=rcc"); } return arguments; }
/// /// moreArguments, /// iphoneos/iphonesimulator for ios /// QMAKE_VAR_QMLJSDEBUGGER_PATH QStringList QMakeStep::deducedArguments() { QStringList arguments; ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit()); ProjectExplorer::Abi targetAbi; if (tc) targetAbi = tc->targetAbi(); // explicitly add architecture to CONFIG if ((targetAbi.os() == ProjectExplorer::Abi::MacOS) && (targetAbi.binaryFormat() == ProjectExplorer::Abi::MachOFormat)) { if (targetAbi.architecture() == ProjectExplorer::Abi::X86Architecture) { if (targetAbi.wordWidth() == 32) arguments << QLatin1String("CONFIG+=x86"); else if (targetAbi.wordWidth() == 64) arguments << QLatin1String("CONFIG+=x86_64"); const char IOSQT[] = "Qt4ProjectManager.QtVersion.Ios"; // from Ios::Constants (include header?) QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(target()->kit()); if (version && version->type() == QLatin1String(IOSQT)) arguments << QLatin1String("CONFIG+=iphonesimulator"); } else if (targetAbi.architecture() == ProjectExplorer::Abi::PowerPCArchitecture) { if (targetAbi.wordWidth() == 32) arguments << QLatin1String("CONFIG+=ppc"); else if (targetAbi.wordWidth() == 64) arguments << QLatin1String("CONFIG+=ppc64"); } else if (targetAbi.architecture() == ProjectExplorer::Abi::ArmArchitecture) { arguments << QLatin1String("CONFIG+=iphoneos"); } } QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(target()->kit()); if (linkQmlDebuggingLibrary() && version) { arguments << QLatin1String(Constants::QMAKEVAR_QUICK1_DEBUG); if (version->qtVersion().majorVersion >= 5) arguments << QLatin1String(Constants::QMAKEVAR_QUICK2_DEBUG); } return arguments; }
void MakeStepConfigWidget::updateDetails() { CMakeBuildConfiguration *bc = m_makeStep->cmakeBuildConfiguration(); ProjectExplorer::ToolChain *tc = bc->toolChain(); if (tc) { QString arguments = Utils::QtcProcess::joinArgs(m_makeStep->m_buildTargets); Utils::QtcProcess::addArgs(&arguments, m_makeStep->additionalArguments()); ProcessParameters param; param.setMacroExpander(bc->macroExpander()); param.setEnvironment(bc->environment()); param.setWorkingDirectory(bc->buildDirectory()); param.setCommand(tc->makeCommand()); param.setArguments(arguments); m_summaryText = param.summary(displayName()); } else { m_summaryText = tr("<b>Unknown tool chain</b>"); } emit updateSummary(); }
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(); 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()) args << "-w"; } m_summaryText = tr("<b>Make:</b> %1 %2 in %3").arg(QFileInfo(makeCmd).fileName(), args.join(" "), QDir::toNativeSeparators(workingDirectory)); emit updateSummary(); }
/// /// moreArguments, /// iphoneos/iphonesimulator for ios /// QMAKE_VAR_QMLJSDEBUGGER_PATH QStringList QMakeStep::deducedArguments() { QStringList arguments; ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit()); ProjectExplorer::Abi targetAbi; if (tc) targetAbi = tc->targetAbi(); // explicitly add architecture to CONFIG QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(target()->kit()); arguments << QmakeBuildConfiguration::deduceArgumnetsForTargetAbi(targetAbi, version); if (linkQmlDebuggingLibrary() && version && !useQtQuickCompiler()) { arguments << QLatin1String(Constants::QMAKEVAR_QUICK1_DEBUG); if (version->qtVersion().majorVersion >= 5) arguments << QLatin1String(Constants::QMAKEVAR_QUICK2_DEBUG); } if (useQtQuickCompiler() && version) arguments << QLatin1String("CONFIG+=qtquickcompiler"); return arguments; }
void QbsManager::addProfileFromKit(const ProjectExplorer::Kit *k) { QStringList usedProfileNames = profileNames(); const QString name = ProjectExplorer::Project::makeUnique( QString::fromLatin1("qtc_") + k->fileSystemFriendlyName(), usedProfileNames); setProfileForKit(name, k); QVariantMap data; QtSupport::BaseQtVersion *qt = QtSupport::QtKitInformation::qtVersion(k); if (qt) { data.insert(QLatin1String(QTCORE_BINPATH), qt->binPath().toUserOutput()); QStringList builds; if (qt->hasDebugBuild()) builds << QLatin1String("debug"); if (qt->hasReleaseBuild()) builds << QLatin1String("release"); data.insert(QLatin1String(QTCORE_BUILDVARIANT), builds); data.insert(QLatin1String(QTCORE_DOCPATH), qt->docsPath().toUserOutput()); data.insert(QLatin1String(QTCORE_INCPATH), qt->headerPath().toUserOutput()); data.insert(QLatin1String(QTCORE_LIBPATH), qt->libraryPath().toUserOutput()); Utils::FileName mkspecPath = qt->mkspecsPath(); mkspecPath.appendPath(qt->mkspec().toString()); data.insert(QLatin1String(QTCORE_MKSPEC), mkspecPath.toUserOutput()); data.insert(QLatin1String(QTCORE_NAMESPACE), qt->qtNamespace()); data.insert(QLatin1String(QTCORE_LIBINFIX), qt->qtLibInfix()); data.insert(QLatin1String(QTCORE_VERSION), qt->qtVersionString()); if (qt->isFrameworkBuild()) data.insert(QLatin1String(QTCORE_FRAMEWORKBUILD), true); } if (ProjectExplorer::SysRootKitInformation::hasSysRoot(k)) data.insert(QLatin1String(QBS_SYSROOT), ProjectExplorer::SysRootKitInformation::sysRoot(k).toUserOutput()); ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(k); if (tc) { // FIXME/CLARIFY: How to pass the sysroot? ProjectExplorer::Abi targetAbi = tc->targetAbi(); QString architecture = ProjectExplorer::Abi::toString(targetAbi.architecture()); if (targetAbi.wordWidth() == 64) architecture.append(QLatin1String("_64")); data.insert(QLatin1String(QBS_ARCHITECTURE), architecture); if (targetAbi.endianness() == ProjectExplorer::Abi::BigEndian) data.insert(QLatin1String(QBS_ENDIANNESS), QLatin1String("big")); else data.insert(QLatin1String(QBS_ENDIANNESS), QLatin1String("little")); if (targetAbi.os() == ProjectExplorer::Abi::WindowsOS) { data.insert(QLatin1String(QBS_TARGETOS), QLatin1String("windows")); data.insert(QLatin1String(QBS_TOOLCHAIN), targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMSysFlavor ? QStringList() << QLatin1String("mingw") << QLatin1String("gcc") : QStringList() << QLatin1String("msvc")); } else if (targetAbi.os() == ProjectExplorer::Abi::MacOS) { data.insert(QLatin1String(QBS_TARGETOS), QStringList() << QLatin1String("osx") << QLatin1String("darwin") << QLatin1String("unix")); if (tc->type() != QLatin1String("clang")) { data.insert(QLatin1String(QBS_TOOLCHAIN), QLatin1String("gcc")); } else { data.insert(QLatin1String(QBS_TOOLCHAIN), QStringList() << QLatin1String("clang") << QLatin1String("llvm") << QLatin1String("gcc")); } } else if (targetAbi.os() == ProjectExplorer::Abi::LinuxOS) { data.insert(QLatin1String(QBS_TARGETOS), QStringList() << QLatin1String("linux") << QLatin1String("unix")); if (tc->type() != QLatin1String("clang")) { data.insert(QLatin1String(QBS_TOOLCHAIN), QLatin1String("gcc")); } else { data.insert(QLatin1String(QBS_TOOLCHAIN), QStringList() << QLatin1String("clang") << QLatin1String("llvm") << QLatin1String("gcc")); } } Utils::FileName cxx = tc->compilerCommand(); data.insert(QLatin1String(CPP_TOOLCHAINPATH), cxx.toFileInfo().absolutePath()); data.insert(QLatin1String(CPP_COMPILERNAME), cxx.toFileInfo().fileName()); } addProfile(name, data); }
bool AndroidDeployQtStep::init(QList<const BuildStep *> &earlierSteps) { Q_UNUSED(earlierSteps); m_androiddeployqtArgs.clear(); if (AndroidManager::checkForQt51Files(project()->projectDirectory())) emit addOutput(tr("Found old folder \"android\" in source directory. Qt 5.2 does not use that folder by default."), ErrorOutput); m_targetArch = AndroidManager::targetArch(target()); if (m_targetArch.isEmpty()) { emit addOutput(tr("No Android arch set by the .pro file."), ErrorOutput); return false; } AndroidBuildApkStep *androidBuildApkStep = AndroidGlobal::buildStep<AndroidBuildApkStep>(target()->activeBuildConfiguration()); if (!androidBuildApkStep) { emit addOutput(tr("Cannot find the android build step."), ErrorOutput); return false; } int deviceAPILevel = AndroidManager::minimumSDK(target()); AndroidConfigurations::Options options = AndroidConfigurations::None; if (androidBuildApkStep->deployAction() == AndroidBuildApkStep::DebugDeployment) options = AndroidConfigurations::FilterAndroid5; AndroidDeviceInfo info = earlierDeviceInfo(earlierSteps, Id); if (!info.isValid()) { info = AndroidConfigurations::showDeviceDialog(project(), deviceAPILevel, m_targetArch, options); m_deviceInfo = info; // Keep around for later steps } if (!info.isValid()) // aborted return false; m_avdName = info.avdname; m_serialNumber = info.serialNumber; m_appProcessBinaries.clear(); m_libdir = QLatin1String("lib"); if (info.cpuAbi.contains(QLatin1String("arm64-v8a")) || info.cpuAbi.contains(QLatin1String("x86_64"))) { ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit(), ToolChain::Language::Cxx); if (tc && tc->targetAbi().wordWidth() == 64) { m_appProcessBinaries << QLatin1String("/system/bin/app_process64"); m_libdir += QLatin1String("64"); } else { m_appProcessBinaries << QLatin1String("/system/bin/app_process32"); } } else { m_appProcessBinaries << QLatin1String("/system/bin/app_process32") << QLatin1String("/system/bin/app_process"); } AndroidManager::setDeviceSerialNumber(target(), m_serialNumber); ProjectExplorer::BuildConfiguration *bc = target()->activeBuildConfiguration(); QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(target()->kit()); if (!version) return false; m_uninstallPreviousPackageRun = m_uninstallPreviousPackage; if (m_uninstallPreviousPackageRun) m_manifestName = AndroidManager::manifestPath(target()); m_useAndroiddeployqt = version->qtVersion() >= QtSupport::QtVersionNumber(5, 4, 0); if (m_useAndroiddeployqt) { Utils::FileName tmp = AndroidManager::androidQtSupport(target())->androiddeployqtPath(target()); if (tmp.isEmpty()) { emit addOutput(tr("Cannot find the androiddeployqt tool."), ErrorOutput); return false; } m_command = tmp.toString(); m_workingDirectory = bc->buildDirectory().appendPath(QLatin1String(Constants::ANDROID_BUILDDIRECTORY)).toString(); Utils::QtcProcess::addArg(&m_androiddeployqtArgs, QLatin1String("--verbose")); Utils::QtcProcess::addArg(&m_androiddeployqtArgs, QLatin1String("--output")); Utils::QtcProcess::addArg(&m_androiddeployqtArgs, m_workingDirectory); Utils::QtcProcess::addArg(&m_androiddeployqtArgs, QLatin1String("--no-build")); Utils::QtcProcess::addArg(&m_androiddeployqtArgs, QLatin1String("--input")); tmp = AndroidManager::androidQtSupport(target())->androiddeployJsonPath(target()); if (tmp.isEmpty()) { emit addOutput(tr("Cannot find the androiddeploy Json file."), ErrorOutput); return false; } Utils::QtcProcess::addArg(&m_androiddeployqtArgs, tmp.toString()); Utils::QtcProcess::addArg(&m_androiddeployqtArgs, QLatin1String("--deployment")); switch (androidBuildApkStep->deployAction()) { case AndroidBuildApkStep::MinistroDeployment: Utils::QtcProcess::addArg(&m_androiddeployqtArgs, QLatin1String("ministro")); break; case AndroidBuildApkStep::DebugDeployment: Utils::QtcProcess::addArg(&m_androiddeployqtArgs, QLatin1String("debug")); break; case AndroidBuildApkStep::BundleLibrariesDeployment: Utils::QtcProcess::addArg(&m_androiddeployqtArgs, QLatin1String("bundled")); break; } if (androidBuildApkStep->useGradle()) Utils::QtcProcess::addArg(&m_androiddeployqtArgs, QLatin1String("--gradle")); if (androidBuildApkStep->signPackage()) { // The androiddeployqt tool is not really written to do stand-alone installations. // This hack forces it to use the correct filename for the apk file when installing // as a temporary fix until androiddeployqt gets the support. Since the --sign is // only used to get the correct file name of the apk, its parameters are ignored. Utils::QtcProcess::addArg(&m_androiddeployqtArgs, QLatin1String("--sign")); Utils::QtcProcess::addArg(&m_androiddeployqtArgs, QLatin1String("foo")); Utils::QtcProcess::addArg(&m_androiddeployqtArgs, QLatin1String("bar")); } } else { m_uninstallPreviousPackageRun = true; m_command = AndroidConfigurations::currentConfig().adbToolPath().toString(); m_apkPath = AndroidManager::androidQtSupport(target())->apkPath(target()).toString(); m_workingDirectory = bc->buildDirectory().toString(); } m_environment = bc->environment(); m_buildDirectory = bc->buildDirectory().toString(); m_adbPath = AndroidConfigurations::currentConfig().adbToolPath().toString(); if (AndroidConfigurations::currentConfig().findAvd(m_avdName).isEmpty()) AndroidConfigurations::currentConfig().startAVDAsync(m_avdName); return true; }
LibraryDetailsController::LibraryDetailsController( Ui::LibraryDetailsWidget *libraryDetails, const QString &proFile, QObject *parent) : QObject(parent), m_platforms(AddLibraryWizard::LinuxPlatform | AddLibraryWizard::MacPlatform | AddLibraryWizard::WindowsMinGWPlatform | AddLibraryWizard::WindowsMSVCPlatform), m_linkageType(AddLibraryWizard::NoLinkage), m_macLibraryType(AddLibraryWizard::NoLibraryType), m_proFile(proFile), m_ignoreGuiSignals(false), m_includePathChanged(false), m_linkageRadiosVisible(true), m_macLibraryRadiosVisible(true), m_includePathVisible(true), m_windowsGroupVisible(true), m_libraryDetailsWidget(libraryDetails) { switch (Utils::HostOsInfo::hostOs()) { case Utils::OsTypeMac: m_creatorPlatform = CreatorMac; break; case Utils::OsTypeLinux: m_creatorPlatform = CreatorLinux; break; case Utils::OsTypeWindows: m_creatorPlatform = CreatorWindows; break; default: break; } if (!Utils::HostOsInfo::isLinuxHost()) { // project for which we are going to insert the snippet const Project *project = SessionManager::projectForFile(proFile); if (project && project->activeTarget()) { // if its tool chain is maemo behave the same as we would be on linux ProjectExplorer::ToolChain *tc = ToolChainKitInformation::toolChain(project->activeTarget()->kit()); if (tc) { switch (tc->targetAbi().os()) { case Abi::WindowsOS: m_creatorPlatform = CreatorWindows; break; case Abi::MacOS: m_creatorPlatform = CreatorMac; break; default: m_creatorPlatform = CreatorLinux; break; } } } } setPlatformsVisible(true); setLinkageGroupVisible(true); setMacLibraryGroupVisible(true); setPackageLineEditVisible(false); if (creatorPlatform() == CreatorMac) setMacLibraryRadiosVisible(false); if (creatorPlatform() != CreatorWindows) setLinkageRadiosVisible(false); connect(m_libraryDetailsWidget->includePathChooser, SIGNAL(changed(QString)), this, SLOT(slotIncludePathChanged())); connect(m_libraryDetailsWidget->frameworkRadio, SIGNAL(clicked(bool)), this, SLOT(slotMacLibraryTypeChanged())); connect(m_libraryDetailsWidget->libraryRadio, SIGNAL(clicked(bool)), this, SLOT(slotMacLibraryTypeChanged())); connect(m_libraryDetailsWidget->useSubfoldersCheckBox, SIGNAL(toggled(bool)), this, SLOT(slotUseSubfoldersChanged(bool))); connect(m_libraryDetailsWidget->addSuffixCheckBox, SIGNAL(toggled(bool)), this, SLOT(slotAddSuffixChanged(bool))); connect(m_libraryDetailsWidget->linCheckBox, SIGNAL(clicked(bool)), this, SLOT(slotPlatformChanged())); connect(m_libraryDetailsWidget->macCheckBox, SIGNAL(clicked(bool)), this, SLOT(slotPlatformChanged())); connect(m_libraryDetailsWidget->winCheckBox, SIGNAL(clicked(bool)), this, SLOT(slotPlatformChanged())); }
bool MakeStep::init() { Qt4BuildConfiguration *bc = qt4BuildConfiguration(); m_tasks.clear(); if (!bc->toolChain()) { m_tasks.append(ProjectExplorer::Task(ProjectExplorer::Task::Error, tr("Qt Creator needs a tool chain set up to build. Please configure a tool chain in Project mode."), QString(), -1, QLatin1String(ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM))); } ProjectExplorer::ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); Utils::Environment environment = bc->environment(); pp->setEnvironment(environment); QString workingDirectory; if (bc->subNodeBuild()) workingDirectory = bc->subNodeBuild()->buildDir(); else workingDirectory = bc->buildDirectory(); pp->setWorkingDirectory(workingDirectory); QString makeCmd = bc->makeCommand(); if (!m_makeCmd.isEmpty()) makeCmd = m_makeCmd; pp->setCommand(makeCmd); // 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 already clean project setIgnoreReturnValue(m_clean); QString args; ProjectExplorer::ToolChain *toolchain = bc->toolChain(); if (bc->subNodeBuild()) { QString makefile = bc->subNodeBuild()->makefile(); if(!makefile.isEmpty()) { Utils::QtcProcess::addArg(&args, QLatin1String("-f")); Utils::QtcProcess::addArg(&args, makefile); m_makeFileToCheck = QDir(workingDirectory).filePath(makefile); } else { m_makeFileToCheck = QDir(workingDirectory).filePath("Makefile"); } } else { if (!bc->makefile().isEmpty()) { Utils::QtcProcess::addArg(&args, QLatin1String("-f")); Utils::QtcProcess::addArg(&args, bc->makefile()); m_makeFileToCheck = QDir(workingDirectory).filePath(bc->makefile()); } else { m_makeFileToCheck = QDir(workingDirectory).filePath("Makefile"); } } Utils::QtcProcess::addArgs(&args, m_userArgs); if (!isClean()) { if (!bc->defaultMakeTarget().isEmpty()) Utils::QtcProcess::addArg(&args, bc->defaultMakeTarget()); } // -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 if (toolchain && toolchain->targetAbi().binaryFormat() != ProjectExplorer::Abi::PEFormat && m_makeCmd.isEmpty()) Utils::QtcProcess::addArg(&args, QLatin1String("-w")); setEnabled(true); pp->setArguments(args); ProjectExplorer::IOutputParser *parser = 0; if (bc->qtVersion()) parser = bc->qtVersion()->createOutputParser(); if (parser) parser->appendOutputParser(new QtSupport::QtParser); else parser = new QtSupport::QtParser; if (toolchain) parser->appendOutputParser(toolchain->outputParser()); parser->setWorkingDirectory(workingDirectory); setOutputParser(parser); return AbstractProcessStep::init(); }
bool MakeStep::init(const QString &name) { m_buildConfiguration = name; ProjectExplorer::BuildConfiguration *bc = project()->buildConfiguration(name); Environment environment = project()->environment(bc); setEnvironment(name, environment); Qt4Project *qt4project = qobject_cast<Qt4Project *>(project()); QString workingDirectory = qt4project->buildDirectory(bc); setWorkingDirectory(name, workingDirectory); QString makeCmd = qt4project->makeCommand(bc); if (!value(name, "makeCmd").toString().isEmpty()) makeCmd = value(name, "makeCmd").toString(); if (!QFileInfo(makeCmd).isAbsolute()) { // Try to detect command in environment QString tmp = environment.searchInPath(makeCmd); if (tmp == QString::null) { 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"); } // 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); } // -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); ProjectExplorer::ToolChain::ToolChainType type = ProjectExplorer::ToolChain::UNKNOWN; if (toolchain) type = toolchain->type(); if (type != ProjectExplorer::ToolChain::MSVC && type != ProjectExplorer::ToolChain::WINCE) { if (value(name, "makeCmd").toString().isEmpty()) args << "-w"; } setEnabled(name, true); setArguments(name, args); if (type == ProjectExplorer::ToolChain::MSVC || type == ProjectExplorer::ToolChain::WINCE) setBuildParser(ProjectExplorer::Constants::BUILD_PARSER_MSVC); else setBuildParser(ProjectExplorer::Constants::BUILD_PARSER_GCC); return AbstractMakeStep::init(name); }
DebuggingHelperBuildTask::DebuggingHelperBuildTask(const BaseQtVersion *version, Tools tools) : m_tools(tools & availableTools(version)), m_invalidQt(false), m_showErrors(true) { if (!version || !version->isValid()) return; // allow type to be used in queued connections. qRegisterMetaType<DebuggingHelperBuildTask::Tools>("DebuggingHelperBuildTask::Tools"); // Print result in application ouptut Core::MessageManager *messageManager = Core::MessageManager::instance(); connect(this, SIGNAL(logOutput(QString,bool)), messageManager, SLOT(printToOutputPane(QString,bool)), Qt::QueuedConnection); // // Extract all information we need from version, such that we don't depend on the existence // of the version pointer while compiling // m_qtId = version->uniqueId(); m_qtInstallData = version->versionInfo().value("QT_INSTALL_DATA"); if (m_qtInstallData.isEmpty()) { const QString error = QCoreApplication::translate( "QtVersion", "Cannot determine the installation path for Qt version '%1'." ).arg(version->displayName()); log(QString(), error); m_invalidQt = true; return; } m_environment = Utils::Environment::systemEnvironment(); version->addToEnvironment(m_environment); // TODO: the debugging helper doesn't comply to actual tool chain yet QList<ProjectExplorer::ToolChain *> tcList = ProjectExplorer::ToolChainManager::instance()->findToolChains(version->qtAbis().at(0)); if (tcList.isEmpty()) { const QString error = QCoreApplication::translate( "QtVersion", "The Qt Version has no tool chain."); log(QString(), error); m_invalidQt = true; return; } ProjectExplorer::ToolChain *tc = tcList.at(0); tc->addToEnvironment(m_environment); if (tc->targetAbi().os() == ProjectExplorer::Abi::LinuxOS && ProjectExplorer::Abi::hostAbi().os() == ProjectExplorer::Abi::WindowsOS) m_target = QLatin1String("-unix"); m_qmakeCommand = version->qmakeCommand(); m_makeCommand = tc->makeCommand(); m_mkspec = version->mkspec(); // Make sure QtVersion cache is invalidated connect(this, SIGNAL(finished(int,QString,DebuggingHelperBuildTask::Tools)), QtVersionManager::instance(), SLOT(updateQtVersion(int)), Qt::QueuedConnection); }
void CMakeRunPage::initializePage() { if (m_mode == Initial) { m_complete = m_cmakeWizard->existsUpToDateXmlFile(); m_buildDirectory = m_cmakeWizard->buildDirectory(); if (m_cmakeWizard->existsUpToDateXmlFile()) { m_descriptionLabel->setText( tr("The directory %1 already contains a cbp file, which is recent enough. " "You can pass special arguments or change the used tool chain here and rerun CMake. " "Or simply finish the wizard directly.").arg(m_buildDirectory)); } else { m_descriptionLabel->setText( tr("The directory %1 does not contain a cbp file. Qt Creator needs to create this file by running CMake. " "Some projects require command line arguments to the initial CMake call.").arg(m_buildDirectory)); } } else if (m_mode == CMakeRunPage::NeedToUpdate) { m_descriptionLabel->setText(tr("The directory %1 contains an outdated .cbp file. Qt " "Creator needs to update this file by running CMake. " "If you want to add additional command line arguments, " "add them below. Note that CMake remembers command " "line arguments from the previous runs.").arg(m_buildDirectory)); } else if (m_mode == CMakeRunPage::Recreate) { m_descriptionLabel->setText(tr("The directory %1 specified in a build-configuration, " "does not contain a cbp file. Qt Creator needs to " "recreate this file, by running CMake. " "Some projects require command line arguments to " "the initial CMake call. Note that CMake remembers command " "line arguments from the previous runs.").arg(m_buildDirectory)); } else if (m_mode == CMakeRunPage::ChangeDirectory) { m_buildDirectory = m_cmakeWizard->buildDirectory(); m_descriptionLabel->setText(tr("Qt Creator needs to run CMake in the new build directory. " "Some projects require command line arguments to the " "initial CMake call.")); } else if (m_mode == CMakeRunPage::WantToUpdate) { m_descriptionLabel->setText(tr("Refreshing cbp file in %1.").arg(m_buildDirectory)); } // Try figuring out generator and toolchain from CMakeCache.txt QString cachedGenerator; QString cmakeCxxCompiler; QFile fi(m_buildDirectory + "/CMakeCache.txt"); if (fi.exists()) { // Cache exists, then read it... if (fi.open(QIODevice::ReadOnly | QIODevice::Text)) { while (!fi.atEnd()) { QString line = fi.readLine(); if (line.startsWith("CMAKE_GENERATOR:INTERNAL=")) { int splitpos = line.indexOf('='); if (splitpos != -1) cachedGenerator = line.mid(splitpos + 1).trimmed(); } if (line.startsWith("CMAKE_CXX_COMPILER:FILEPATH=")) { int splitpos = line.indexOf("="); if (splitpos != -1) cmakeCxxCompiler = line.mid(splitpos +1).trimmed(); } if (!cachedGenerator.isEmpty() && !cmakeCxxCompiler.isEmpty()) break; } } } // Build the list of generators/toolchains we want to offer // restrict toolchains based on CMAKE_CXX_COMPILER ? Q_UNUSED(cmakeCxxCompiler); m_generatorComboBox->clear(); bool hasCodeBlocksGenerator = m_cmakeWizard->cmakeManager()->hasCodeBlocksMsvcGenerator(); QList<ProjectExplorer::Profile *> profileList = ProjectExplorer::ProfileManager::instance()->profiles(); foreach (ProjectExplorer::Profile *p, profileList) { QVariant profileVariant = qVariantFromValue(static_cast<void *>(p)); ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainProfileInformation::toolChain(p); if (!tc) continue; ProjectExplorer::Abi targetAbi = tc->targetAbi(); if (targetAbi.os() == ProjectExplorer::Abi::WindowsOS) { if (targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2005Flavor || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2008Flavor || targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMsvc2010Flavor) { if (hasCodeBlocksGenerator && (cachedGenerator.isEmpty() || cachedGenerator == "NMake Makefiles")) m_generatorComboBox->addItem(tr("NMake Generator (%1)").arg(p->displayName()), profileVariant); } else if (targetAbi.osFlavor() == ProjectExplorer::Abi::WindowsMSysFlavor) { if (cachedGenerator.isEmpty() || cachedGenerator == "MinGW Makefiles") m_generatorComboBox->addItem(tr("MinGW Generator (%1)").arg(p->displayName()), profileVariant); } } else { // Non windows if (cachedGenerator.isEmpty() || cachedGenerator == "Unix Makefiles") m_generatorComboBox->addItem(tr("Unix Generator (%1)").arg(p->displayName()), profileVariant); } }
bool MakeStep::init() { Qt4BuildConfiguration *bc = qt4BuildConfiguration(); if (!bc) bc = qobject_cast<Qt4BuildConfiguration *>(target()->activeBuildConfiguration()); m_tasks.clear(); if (!bc) { m_tasks.append(ProjectExplorer::Task(ProjectExplorer::Task::Error, tr("Qt Creator needs a build configuration set up to build. Configure a tool chain in Project mode."), Utils::FileName(), -1, Core::Id(ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM))); return false; } ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainProfileInformation::toolChain(target()->profile()); if (!tc) { m_tasks.append(ProjectExplorer::Task(ProjectExplorer::Task::Error, tr("Qt Creator needs a tool chain set up to build. Configure a tool chain the profile options."), Utils::FileName(), -1, Core::Id(ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM))); return false; } ProjectExplorer::ProcessParameters *pp = processParameters(); pp->setMacroExpander(bc->macroExpander()); QString workingDirectory; if (bc->subNodeBuild()) workingDirectory = bc->subNodeBuild()->buildDir(); else workingDirectory = bc->buildDirectory(); pp->setWorkingDirectory(workingDirectory); QString makeCmd = tc->makeCommand(); if (!m_makeCmd.isEmpty()) makeCmd = m_makeCmd; pp->setCommand(makeCmd); // 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 already clean project setIgnoreReturnValue(m_clean); QString args; Qt4ProjectManager::Qt4ProFileNode *subNode = bc->subNodeBuild(); if (subNode) { QString makefile = subNode->makefile(); if (makefile.isEmpty()) makefile = QLatin1String("Makefile"); if (subNode->isDebugAndRelease()) { if (bc->buildType() == Qt4BuildConfiguration::Debug) makefile += QLatin1String(".Debug"); else makefile += QLatin1String(".Release"); } if (makefile != QLatin1String("Makefile")) { Utils::QtcProcess::addArg(&args, QLatin1String("-f")); Utils::QtcProcess::addArg(&args, makefile); } m_makeFileToCheck = QDir(workingDirectory).filePath(makefile); } else { if (!bc->makefile().isEmpty()) { Utils::QtcProcess::addArg(&args, QLatin1String("-f")); Utils::QtcProcess::addArg(&args, bc->makefile()); m_makeFileToCheck = QDir(workingDirectory).filePath(bc->makefile()); } else { m_makeFileToCheck = QDir(workingDirectory).filePath(QLatin1String("Makefile")); } } Utils::QtcProcess::addArgs(&args, m_userArgs); if (!isClean()) { if (!bc->defaultMakeTarget().isEmpty()) Utils::QtcProcess::addArg(&args, bc->defaultMakeTarget()); } if (bc->fileNodeBuild() && subNode) { QString objectsDir = subNode->objectsDirectory(); if (objectsDir.isEmpty()) { objectsDir = subNode->buildDir(bc); if (subNode->isDebugAndRelease()) { if (bc->buildType() == Qt4BuildConfiguration::Debug) objectsDir += QLatin1String("/debug"); else objectsDir += QLatin1String("/release"); } } QString relObjectsDir = QDir(pp->workingDirectory()).relativeFilePath(objectsDir); if (!relObjectsDir.isEmpty()) relObjectsDir += QLatin1Char('/'); QString objectFile = relObjectsDir + QFileInfo(bc->fileNodeBuild()->path()).baseName() + subNode->objectExtension(); Utils::QtcProcess::addArg(&args, objectFile); } Utils::Environment env = bc->environment(); // Force output to english for the parsers. Do this here and not in the toolchain's // addToEnvironment() to not screw up the users run environment. env.set(QLatin1String("LC_ALL"), QLatin1String("C")); // -w option enables "Enter"/"Leaving directory" messages, which we need for detecting the // absolute file path // 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 // We also prepend "L" to the MAKEFLAGS, so that nmake / jom are less verbose if (tc && m_makeCmd.isEmpty()) { if (tc->targetAbi().binaryFormat() != ProjectExplorer::Abi::PEFormat ) Utils::QtcProcess::addArg(&args, QLatin1String("-w")); if (tc->targetAbi().os() == ProjectExplorer::Abi::WindowsOS && tc->targetAbi().osFlavor() != ProjectExplorer::Abi::WindowsMSysFlavor) { const QString makeFlags = QLatin1String("MAKEFLAGS"); env.set(makeFlags, QLatin1Char('L') + env.value(makeFlags)); } } pp->setEnvironment(env); pp->setArguments(args); ProjectExplorer::IOutputParser *parser = 0; QtSupport::BaseQtVersion *version = QtSupport::QtProfileInformation::qtVersion(target()->profile()); if (version) parser = version->createOutputParser(); if (parser) parser->appendOutputParser(new QtSupport::QtParser); else parser = new QtSupport::QtParser; if (tc) parser->appendOutputParser(tc->outputParser()); parser->setWorkingDirectory(workingDirectory); setOutputParser(parser); m_scriptTarget = (static_cast<Qt4Project *>(bc->target()->project())->rootQt4ProjectNode()->projectType() == ScriptTemplate); return AbstractProcessStep::init(); }
bool MakeStep::init() { Qt4BuildConfiguration *bc = qt4BuildConfiguration(); Environment environment = bc->environment(); setEnvironment(environment); QString workingDirectory; if (bc->subNodeBuild()) workingDirectory = bc->subNodeBuild()->buildDir(); else workingDirectory = bc->buildDirectory(); setWorkingDirectory(workingDirectory); QString makeCmd = bc->makeCommand(); if (!m_makeCmd.isEmpty()) makeCmd = m_makeCmd; if (!QFileInfo(makeCmd).isAbsolute()) { // Try to detect command in environment const QString tmp = environment.searchInPath(makeCmd); if (tmp.isEmpty()) { QTextCharFormat textCharFormat; textCharFormat.setForeground(Qt::red); emit addOutput(tr("Could not find make command: %1 in the build environment").arg(makeCmd), textCharFormat); return false; } makeCmd = tmp; } setCommand(makeCmd); // 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 already clean project setIgnoreReturnValue(m_clean); QStringList args = m_userArgs; if (!m_clean) { if (!bc->defaultMakeTarget().isEmpty()) args << bc->defaultMakeTarget(); } // -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 = bc->toolChain(); if (toolchain) { if (toolchain->type() != ProjectExplorer::ToolChain::MSVC && toolchain->type() != ProjectExplorer::ToolChain::WINCE) { if (m_makeCmd.isEmpty()) args << "-w"; } } setEnabled(true); setArguments(args); setOutputParser(new ProjectExplorer::GnuMakeParser(workingDirectory)); if (toolchain) appendOutputParser(toolchain->outputParser()); return AbstractProcessStep::init(); }