void QmakeManager::runQMake(ProjectExplorer::Project *p, ProjectExplorer::Node *node) { if (!ProjectExplorerPlugin::saveModifiedFiles()) return; QmakeProject *qmakeProject = qobject_cast<QmakeProject *>(p); QTC_ASSERT(qmakeProject, return); if (!qmakeProject->activeTarget() || !qmakeProject->activeTarget()->activeBuildConfiguration()) return; QmakeBuildConfiguration *bc = static_cast<QmakeBuildConfiguration *>(qmakeProject->activeTarget()->activeBuildConfiguration()); QMakeStep *qs = bc->qmakeStep(); if (!qs) return; //found qmakeStep, now use it qs->setForced(true); if (node != 0 && node != qmakeProject->rootProjectNode()) if (QmakeProFileNode *profile = dynamic_cast<QmakeProFileNode *>(node)) bc->setSubNodeBuild(profile); BuildManager::appendStep(qs, tr("QMake")); bc->setSubNodeBuild(0); }
bool DesktopQmakeRunConfigurationFactory::canCreate(Target *parent, const Core::Id id) const { if (!canHandle(parent)) return false; QmakeProject *project = static_cast<QmakeProject *>(parent->project()); return project->hasApplicationProFile(pathFromId(id)); }
QmakeProFileNode *DesktopQmakeRunConfiguration::projectNode() const { QmakeProject *project = qmakeProject(); QTC_ASSERT(project, return nullptr); QmakeProFileNode *rootNode = project->rootProjectNode(); QTC_ASSERT(rootNode, return nullptr); return rootNode->findProFileFor(m_proFilePath); }
QString DesktopQmakeRunConfiguration::baseWorkingDirectory() const { // if the user overrode us, then return his working directory if (!m_userWorkingDirectory.isEmpty()) return m_userWorkingDirectory; // else what the pro file reader tells us QmakeProject *pro = static_cast<QmakeProject *>(target()->project()); const QmakeProFileNode *node = pro->rootQmakeProjectNode()->findProFileFor(m_proFilePath); return extractWorkingDirAndExecutable(node).first; }
QList<Core::Id> DesktopQmakeRunConfigurationFactory::availableCreationIds(Target *parent, CreationMode mode) const { if (!canHandle(parent)) return QList<Core::Id>(); QmakeProject *project = static_cast<QmakeProject *>(parent->project()); QList<QmakeProFileNode *> nodes = project->applicationProFiles(); if (mode == AutoCreate) nodes = QmakeProject::nodesWithQtcRunnable(nodes); return QmakeProject::idsForNodes(Core::Id(QMAKE_RC_PREFIX), nodes); }
QList<Core::Id> DesktopQmakeRunConfigurationFactory::availableCreationIds(Target *parent) const { QList<Core::Id> result; if (!canHandle(parent)) return result; QmakeProject *project = static_cast<QmakeProject *>(parent->project()); QStringList proFiles = project->applicationProFilePathes(QLatin1String(QMAKE_RC_PREFIX)); foreach (const QString &pf, proFiles) result << Core::Id::fromString(pf); return result; }
void QmakeManager::handleSubDirContextMenu(QmakeManager::Action action, bool isFileBuild, ProjectExplorer::Project *contextProject, ProjectExplorer::Node *contextNode, ProjectExplorer::FileNode *contextFile) { QmakeProject *qmakeProject = qobject_cast<QmakeProject *>(contextProject); QTC_ASSERT(qmakeProject, return); if (!qmakeProject->activeTarget() || !qmakeProject->activeTarget()->activeBuildConfiguration()) return; if (!contextNode || !contextFile) isFileBuild = false; QmakeBuildConfiguration *bc = qobject_cast<QmakeBuildConfiguration *>(qmakeProject->activeTarget()->activeBuildConfiguration()); if (!bc) return; if (contextNode) { if (QmakePriFileNode *prifile = dynamic_cast<QmakePriFileNode *>(contextNode)) { if (QmakeProFileNode *profile = prifile->proFileNode()) { if (profile != qmakeProject->rootProjectNode() || isFileBuild) bc->setSubNodeBuild(profile); } } } if (isFileBuild) bc->setFileNodeBuild(contextFile); if (ProjectExplorerPlugin::saveModifiedFiles()) { const Core::Id buildStep = ProjectExplorer::Constants::BUILDSTEPS_BUILD; const Core::Id cleanStep = ProjectExplorer::Constants::BUILDSTEPS_CLEAN; if (action == BUILD) { const QString name = ProjectExplorerPlugin::displayNameForStepId(buildStep); BuildManager::buildList(bc->stepList(buildStep), name); } else if (action == CLEAN) { const QString name = ProjectExplorerPlugin::displayNameForStepId(cleanStep); BuildManager::buildList(bc->stepList(cleanStep), name); } else if (action == REBUILD) { QStringList names; names << ProjectExplorerPlugin::displayNameForStepId(cleanStep) << ProjectExplorerPlugin::displayNameForStepId(buildStep); QList<ProjectExplorer::BuildStepList *> stepLists; stepLists << bc->stepList(cleanStep) << bc->stepList(buildStep); BuildManager::buildLists(stepLists, names); } } bc->setSubNodeBuild(0); bc->setFileNodeBuild(0); }
void IosRunConfiguration::init() { QmakeProject *project = static_cast<QmakeProject *>(target()->project()); m_parseSuccess = project->validParse(m_profilePath); m_parseInProgress = project->parseInProgress(m_profilePath); m_lastIsEnabled = isEnabled(); m_lastDisabledReason = disabledReason(); connect(DeviceManager::instance(), SIGNAL(updated()), SLOT(deviceChanges())); connect(KitManager::instance(), SIGNAL(kitsChanged()), SLOT(deviceChanges())); connect(target()->project(), SIGNAL(proFileUpdated(QmakeProjectManager::QmakeProFileNode*,bool,bool)), this, SLOT(proFileUpdated(QmakeProjectManager::QmakeProFileNode*,bool,bool))); }
QString IosRunConfiguration::appName() const { QmakeProject *pro = qobject_cast<QmakeProject *>(target()->project()); if (pro) { const QmakeProFileNode *node = pro->rootQmakeProjectNode()->findProFileFor(profilePath()); if (node) { TargetInformation ti = node->targetInformation(); if (ti.valid) return ti.target; } } qDebug() << "IosRunConfiguration::appName failed"; return QString(); }
QString IosRunConfiguration::applicationName() const { QmakeProject *pro = qobject_cast<QmakeProject *>(target()->project()); const QmakeProFileNode *node = 0; if (pro) node = pro->rootProjectNode(); if (node) node = node->findProFileFor(profilePath()); if (node) { TargetInformation ti = node->targetInformation(); if (ti.valid) return ti.target; } return QString(); }
FileName IosRunConfiguration::bundleDirectory() const { FileName res; Core::Id devType = DeviceTypeKitInformation::deviceTypeId(target()->kit()); bool isDevice = (devType == Constants::IOS_DEVICE_TYPE); if (!isDevice && devType != Constants::IOS_SIMULATOR_TYPE) { qCWarning(iosLog) << "unexpected device type in bundleDirForTarget: " << devType.toString(); return res; } QmakeBuildConfiguration *bc = qobject_cast<QmakeBuildConfiguration *>(target()->activeBuildConfiguration()); if (bc) { QmakeProject *pro = qobject_cast<QmakeProject *>(target()->project()); const QmakeProFileNode *node = 0; if (pro) node = pro->rootProjectNode(); if (node) node = node->findProFileFor(profilePath()); if (node) { TargetInformation ti = node->targetInformation(); if (ti.valid) res = FileName::fromString(ti.buildDir); } if (res.isEmpty()) res = bc->buildDirectory(); switch (bc->buildType()) { case BuildConfiguration::Debug : case BuildConfiguration::Unknown : if (isDevice) res.appendPath(QLatin1String("Debug-iphoneos")); else res.appendPath(QLatin1String("Debug-iphonesimulator")); break; case BuildConfiguration::Profile : case BuildConfiguration::Release : if (isDevice) res.appendPath(QLatin1String("Release-iphoneos")); else res.appendPath(QLatin1String("Release-iphonesimulator")); break; default: qCWarning(iosLog) << "IosBuildStep had an unknown buildType " << target()->activeBuildConfiguration()->buildType(); } } res.appendPath(applicationName() + QLatin1String(".app")); return res; }
// // CreateAndroidManifestWizard // CreateAndroidManifestWizard::CreateAndroidManifestWizard(ProjectExplorer::Target *target) : m_target(target), m_node(0) { setWindowTitle(tr("Create Android Manifest Wizard")); QmakeProject *project = static_cast<QmakeProject *>(target->project()); QList<QmakeProFileNode *> nodes = project->applicationProFiles(); if (nodes.isEmpty()) { // oh uhm can't create anything addPage(new NoApplicationProFilePage(this)); } else if (nodes.size() == 1) { setNode(nodes.first()); addPage(new ChooseDirectoryPage(this)); } else { addPage(new ChooseProFilePage(this, nodes)); addPage(new ChooseDirectoryPage(this)); } }
QStringList QmakeAndroidSupport::projectTargetApplications(const ProjectExplorer::Target *target) const { QStringList apps; QmakeProject *qmakeProject = qobject_cast<QmakeProject *>(target->project()); if (!qmakeProject) return apps; for (QmakeProFile *proFile : qmakeProject->applicationProFiles()) { if (proFile->projectType() == ProjectType::ApplicationTemplate) { if (proFile->targetInformation().target.startsWith(QLatin1String("lib")) && proFile->targetInformation().target.endsWith(QLatin1String(".so"))) apps << proFile->targetInformation().target.mid(3, proFile->targetInformation().target.lastIndexOf(QLatin1Char('.')) - 3); else apps << proFile->targetInformation().target; } } apps.sort(); return apps; }
void QmakeProjectConfigWidget::updateProblemLabel() { m_ui->shadowBuildDirEdit->triggerChanged(); ProjectExplorer::Kit *k = m_buildConfiguration->target()->kit(); const QString proFileName = m_buildConfiguration->target()->project()->projectFilePath().toString(); // Check for Qt version: QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(k); if (!version) { setProblemLabel(tr("This kit cannot build this project since it does not define a Qt version.")); return; } QmakeProject *p = static_cast<QmakeProject *>(m_buildConfiguration->target()->project()); if (p->rootProjectNode()->parseInProgress() || !p->rootProjectNode()->validParse()) { setProblemLabel(QString()); return; } bool targetMismatch = false; bool incompatibleBuild = false; bool allGood = false; // we only show if we actually have a qmake and makestep QString errorString; if (m_buildConfiguration->qmakeStep() && m_buildConfiguration->makeStep()) { QString makefile = m_buildConfiguration->buildDirectory().toString() + QLatin1Char('/'); if (m_buildConfiguration->makefile().isEmpty()) makefile.append(QLatin1String("Makefile")); else makefile.append(m_buildConfiguration->makefile()); switch (m_buildConfiguration->compareToImportFrom(makefile, &errorString)) { case QmakeBuildConfiguration::MakefileMatches: allGood = true; break; case QmakeBuildConfiguration::MakefileMissing: allGood = true; break; case QmakeBuildConfiguration::MakefileIncompatible: incompatibleBuild = true; break; case QmakeBuildConfiguration::MakefileForWrongProject: targetMismatch = true; break; } } if (allGood) { QString buildDirectory = m_buildConfiguration->target()->project()->projectDirectory().toString(); if (m_buildConfiguration->isShadowBuild()) buildDirectory = m_buildConfiguration->buildDirectory().toString(); QList<ProjectExplorer::Task> issues; issues = version->reportIssues(proFileName, buildDirectory); Utils::sort(issues); if (!issues.isEmpty()) { QString text = QLatin1String("<nobr>"); foreach (const ProjectExplorer::Task &task, issues) { QString type; switch (task.type) { case ProjectExplorer::Task::Error: type = tr("Error:"); type += QLatin1Char(' '); break; case ProjectExplorer::Task::Warning: type = tr("Warning:"); type += QLatin1Char(' '); break; case ProjectExplorer::Task::Unknown: default: break; } if (!text.endsWith(QLatin1String("br>"))) text.append(QLatin1String("<br>")); text.append(type + task.description); } setProblemLabel(text); return; }
QString DesktopQmakeRunConfiguration::executable() const { QmakeProject *pro = static_cast<QmakeProject *>(target()->project()); const QmakeProFileNode *node = pro->rootQmakeProjectNode()->findProFileFor(m_proFilePath); return extractWorkingDirAndExecutable(node).second; }
RunControl *IosDebugSupport::createDebugRunControl(IosRunConfiguration *runConfig, QString *errorMessage) { Target *target = runConfig->target(); if (!target) return 0; ProjectExplorer::IDevice::ConstPtr device = DeviceKitInformation::device(target->kit()); if (device.isNull()) return 0; QmakeProject *project = static_cast<QmakeProject *>(target->project()); Kit *kit = target->kit(); DebuggerStartParameters params; if (device->type() == Core::Id(Ios::Constants::IOS_DEVICE_TYPE)) { params.startMode = AttachToRemoteProcess; params.platform = QLatin1String("remote-ios"); IosDevice::ConstPtr iosDevice = device.dynamicCast<const IosDevice>(); if (iosDevice.isNull()) return 0; QString osVersion = iosDevice->osVersion(); Utils::FileName deviceSdk1 = Utils::FileName::fromString(QDir::homePath() + QLatin1String("/Library/Developer/Xcode/iOS DeviceSupport/") + osVersion + QLatin1String("/Symbols")); QString deviceSdk; if (deviceSdk1.toFileInfo().isDir()) { deviceSdk = deviceSdk1.toString(); } else { Utils::FileName deviceSdk2 = IosConfigurations::developerPath() .appendPath(QLatin1String("Platforms/iPhoneOS.platform/DeviceSupport/")) .appendPath(osVersion).appendPath(QLatin1String("Symbols")); if (deviceSdk2.toFileInfo().isDir()) { deviceSdk = deviceSdk2.toString(); } else { TaskHub::addTask(Task::Warning, tr( "Could not find device specific debug symbols at %1. " "Debugging initialization will be slow until you open the Organizer window of " "Xcode with the device connected to have the symbols generated.") .arg(deviceSdk1.toUserOutput()), ProjectExplorer::Constants::TASK_CATEGORY_DEPLOYMENT); } } params.deviceSymbolsRoot = deviceSdk; } else { params.startMode = AttachExternal; params.platform = QLatin1String("ios-simulator"); } params.displayName = runConfig->applicationName(); params.remoteSetupNeeded = true; if (!params.breakOnMain) params.continueAfterAttach = true; Debugger::DebuggerRunConfigurationAspect *aspect = runConfig->extraAspect<Debugger::DebuggerRunConfigurationAspect>(); bool cppDebug = aspect->useCppDebugger(); bool qmlDebug = aspect->useQmlDebugger(); if (cppDebug) { params.languages |= CppLanguage; params.sysRoot = SysRootKitInformation::sysRoot(kit).toString(); params.debuggerCommand = DebuggerKitInformation::debuggerCommand(kit).toString(); if (ToolChain *tc = ToolChainKitInformation::toolChain(kit)) params.toolChainAbi = tc->targetAbi(); params.executable = runConfig->localExecutable().toString(); params.remoteChannel = QLatin1String("connect://localhost:0"); Utils::FileName xcodeInfo = IosConfigurations::developerPath().parentDir() .appendPath(QLatin1String("Info.plist")); bool buggyLldb = false; if (xcodeInfo.toFileInfo().exists()) { QSettings settings(xcodeInfo.toString(), QSettings::NativeFormat); QStringList version = settings.value(QLatin1String("CFBundleShortVersionString")).toString() .split(QLatin1Char('.')); if (version.value(0).toInt() == 5 && version.value(1, QString::number(1)).toInt() == 0) buggyLldb = true; } QString bundlePath = runConfig->bundleDirectory().toString(); bundlePath.chop(4); Utils::FileName dsymPath = Utils::FileName::fromString( bundlePath.append(QLatin1String(".dSYM"))); if (!dsymPath.toFileInfo().exists()) { if (buggyLldb) TaskHub::addTask(Task::Warning, tr("Debugging with Xcode 5.0.x can be unreliable without a dSYM. " "To create one, add a dsymutil deploystep."), ProjectExplorer::Constants::TASK_CATEGORY_DEPLOYMENT); } else if (dsymPath.toFileInfo().lastModified() < QFileInfo(runConfig->localExecutable().toUserOutput()).lastModified()) { TaskHub::addTask(Task::Warning, tr("The dSYM %1 seems to be outdated, it might confuse the debugger.") .arg(dsymPath.toUserOutput()), ProjectExplorer::Constants::TASK_CATEGORY_DEPLOYMENT); } } if (qmlDebug) { params.languages |= QmlLanguage; params.projectSourceDirectory = project->projectDirectory().toString(); params.projectSourceFiles = project->files(QmakeProject::ExcludeGeneratedFiles); params.projectBuildDirectory = project->rootQmakeProjectNode()->buildDir(); if (!cppDebug) params.startMode = AttachToRemoteServer; } DebuggerRunControl * const debuggerRunControl = DebuggerPlugin::createDebugger(params, runConfig, errorMessage); if (debuggerRunControl) new IosDebugSupport(runConfig, debuggerRunControl, cppDebug, qmlDebug); return debuggerRunControl; }