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