void BaseCheckoutWizardFactory::runWizard(const QString &path, QWidget *parent, const QString &platform,
const QVariantMap &extraValues)
{
Q_UNUSED(platform);
Q_UNUSED(extraValues);
// Create dialog and launch
Utils::FileName checkoutPath;
{
QScopedPointer<BaseCheckoutWizard> wizard(m_wizardCreator(Utils::FileName::fromString(path), parent));
wizard->setWindowTitle(displayName());
checkoutPath = wizard->run();
}
if (checkoutPath.isEmpty())
return;
// Now try to find the project file and open
QString errorMessage;
const QString projectFile = openProject(checkoutPath, &errorMessage);
if (projectFile.isEmpty()) {
QMessageBox msgBox(QMessageBox::Warning, tr("Cannot Open Project"),
tr("Failed to open project in \"%1\".").arg(checkoutPath.toUserOutput()));
msgBox.setDetailedText(errorMessage);
msgBox.addButton(QMessageBox::Ok);
msgBox.exec();
}
}
/*!
\class ProjectExplorer::FolderNode
In-memory presentation of a folder. Note that the node itself + all children (files and folders) are "managed" by the owning project.
\sa ProjectExplorer::FileNode, ProjectExplorer::ProjectNode
*/
FolderNode::FolderNode(const Utils::FileName &folderPath, NodeType nodeType, const QString &displayName) :
Node(nodeType, folderPath),
m_displayName(displayName)
{
if (m_displayName.isEmpty())
m_displayName = folderPath.toUserOutput();
}
void AndroidSettingsWidget::browseNDKLocation()
{
Utils::FileName dir = Utils::FileName::fromString(QFileDialog::getExistingDirectory(this, tr("Select Android NDK folder")));
if (!checkNDK(dir))
return;
m_ui->NDKLocationLineEdit->setText(dir.toUserOutput());
ndkLocationEditingFinished();
}
void AndroidSettingsWidget::browseOpenJDKLocation()
{
Utils::FileName openJDKPath = AndroidConfigurations::instance().openJDKPath();
Utils::FileName file = Utils::FileName::fromString(QFileDialog::getExistingDirectory(this, tr("Select OpenJDK Path"), openJDKPath.toString()));
if (file.isEmpty())
return;
m_ui->OpenJDKLocationLineEdit->setText(file.toUserOutput());
openJDKLocationEditingFinished();
}
void AndroidSettingsWidget::browseGdbserverLocationX86()
{
Utils::FileName gdbserverPath = AndroidConfigurations::instance().gdbServerPath(ProjectExplorer::Abi::X86Architecture);
Utils::FileName file = Utils::FileName::fromString(QFileDialog::getOpenFileName(this, tr("Select gdbserver android executable"), gdbserverPath.toString()));
if (file.isEmpty())
return;
m_ui->GdbserverLocationLineEditx86->setText(file.toUserOutput());
gdbserverLocationX86EditingFinished();
}
QList<Task> SysRootKitInformation::validate(Kit *k) const
{
QList<Task> result;
const Utils::FileName dir = SysRootKitInformation::sysRoot(k);
if (!dir.toFileInfo().isDir() && SysRootKitInformation::hasSysRoot(k)) {
result << Task(Task::Error, tr("Sys Root \"%1\" is not a directory.").arg(dir.toUserOutput()),
Utils::FileName(), -1, Core::Id(Constants::TASK_CATEGORY_BUILDSYSTEM));
}
return result;
}
QString VcsOutputWindow::msgExecutionLogEntry(const QString &workingDir,
const Utils::FileName &executable,
const QStringList &arguments)
{
const QString args = formatArguments(arguments);
const QString nativeExecutable = executable.toUserOutput();
if (workingDir.isEmpty())
return tr("Executing: %1 %2").arg(nativeExecutable, args) + QLatin1Char('\n');
return tr("Executing in %1: %2 %3").
arg(QDir::toNativeSeparators(workingDir), nativeExecutable, args) + QLatin1Char('\n');
}
static bool openXmlFile(QDomDocument &doc, const Utils::FileName &fileName)
{
QFile f(fileName.toString());
if (!f.open(QIODevice::ReadOnly))
return false;
if (!doc.setContent(f.readAll())) {
raiseError(AndroidManager::tr("Cannot parse \"%1\".").arg(fileName.toUserOutput()));
return false;
}
return true;
}
void AndroidPackageCreationWidget::on_KeystoreLocationPushButton_clicked()
{
Utils::FileName keystorePath = m_step->keystorePath();
if (keystorePath.isEmpty())
keystorePath = Utils::FileName::fromString(QDir::homePath());
Utils::FileName file = Utils::FileName::fromString(QFileDialog::getOpenFileName(this, tr("Select keystore file"), keystorePath.toString(), tr("Keystore files (*.keystore *.jks)")));
if (file.isEmpty())
return;
m_ui->KeystoreLocationLineEdit->setText(file.toUserOutput());
m_step->setKeystorePath(file);
m_ui->signPackageCheckBox->setChecked(false);
}
ProjectExplorer::Project *CMakeManager::openProject(const QString &fileName, QString *errorString)
{
Utils::FileName file = Utils::FileName::fromString(fileName);
if (!file.toFileInfo().isFile()) {
if (errorString)
*errorString = tr("Failed opening project \"%1\": Project is not a file")
.arg(file.toUserOutput());
return 0;
}
return new CMakeProject(this, file);
}
ResourceTopLevelNode::ResourceTopLevelNode(const Utils::FileName &filePath, FolderNode *parent)
: ProjectExplorer::FolderNode(filePath)
{
setIcon(Core::FileIconProvider::icon(filePath.toString()));
m_document = new ResourceFileWatcher(this);
Core::DocumentManager::addDocument(m_document);
Utils::FileName base = parent->filePath();
if (filePath.isChildOf(base))
setDisplayName(filePath.relativeChildPath(base).toUserOutput());
else
setDisplayName(filePath.toUserOutput());
}
QStringList IosDsymBuildStep::defaultCmdList() const
{
QString dsymutilCmd = "dsymutil";
Utils::FileName dsymUtilPath = IosConfigurations::developerPath()
.appendPath("Toolchains/XcodeDefault.xctoolchain/usr/bin/dsymutil");
if (dsymUtilPath.exists())
dsymutilCmd = dsymUtilPath.toUserOutput();
IosRunConfiguration *runConf =
qobject_cast<IosRunConfiguration *>(target()->activeRunConfiguration());
QTC_ASSERT(runConf, return QStringList("echo"));
QString dsymPath = runConf->bundleDirectory().toUserOutput();
dsymPath.chop(4);
dsymPath.append(".dSYM");
return QStringList({dsymutilCmd, "-o", dsymPath, runConf->localExecutable().toUserOutput()});
}
void AndroidSettingsWidget::searchForAnt(const QString &location)
{
if (!m_androidConfig.antLocation.isEmpty())
return;
if (location.isEmpty())
return;
QDir parentFolder = QFileInfo(location).absoluteDir();
foreach (const QString &file, parentFolder.entryList()) {
if (file.startsWith(QLatin1String("apache-ant"))) {
Utils::FileName ant = Utils::FileName::fromString(parentFolder.absolutePath());
ant.appendPath(file).appendPath(QLatin1String("bin")).appendPath(QLatin1String("ant.bat"));
if (ant.toFileInfo().exists()) {
m_androidConfig.antLocation = ant;
m_ui->AntLocationLineEdit->setText(ant.toUserOutput());
}
}
}
}
ProjectExplorer::Project *DubProjectManager::openProject(const QString &fileName, QString *errorString)
{
Utils::FileName file = Utils::FileName::fromString(fileName);
if (!file.toFileInfo().isFile()) {
if (errorString)
*errorString = tr("Failed opening project \"%1\": Project is not a file")
.arg(file.toUserOutput());
return 0;
}
DubProject* retval = nullptr;
try {
retval = new DubProject(this, file);
} catch (const std::exception& ex) {
*errorString = QString::fromUtf8(ex.what());
}
return retval;
}
QString BaseCheckoutWizardFactory::openProject(const Utils::FileName &path, QString *errorMessage)
{
// Search the directory for project files
const QDir dir(path.toString());
if (!dir.exists()) {
*errorMessage = tr("\"%1\" does not exist.").
arg(path.toUserOutput()); // Should not happen
return QString();
}
QFileInfoList projectFiles = findProjectFiles(dir, errorMessage);
if (projectFiles.empty())
return QString();
// Open. Do not use a busy cursor here as additional wizards might pop up
const QString projectFile = projectFiles.front().absoluteFilePath();
if (!ProjectExplorer::ProjectExplorerPlugin::instance()->openProject(projectFile, errorMessage))
return QString();
return projectFile;
}
bool BlackBerryCreatePackageStep::doUpdateAppDescriptorFile(const Utils::FileName &appDescriptorPath,
QFlags<EditMode> types,
bool skipConfirmation)
{
Core::FileChangeBlocker fb(appDescriptorPath.toString());
BarDescriptorDocument doc;
QString errorString;
if (!doc.open(&errorString, appDescriptorPath.toString())) {
raiseError(tr("Error opening BAR application descriptor file \"%1\" - %2")
.arg(appDescriptorPath.toUserOutput())
.arg(errorString));
return false;
}
BarDescriptorAssetList assetList = doc.value(BarDescriptorDocument::asset)
.value<BarDescriptorAssetList>();
bool updated = false;
if (types.testFlag(PlaceHolders)) {
foreach (const BarDescriptorAsset &a, assetList) {
if (a.source.contains(QLatin1String("%SRC_DIR%"))) {
// Keep backward compatibility with older templates
QHash<QString, QString> placeHoldersHash;
placeHoldersHash[QLatin1String("%SRC_DIR%")] = QString();
doc.expandPlaceHolders(placeHoldersHash);
updated = true;
}
// Update the entry point source path to make use of the BUILD_DIR variable
// if not set
if (a.entry) {
BarDescriptorAsset asset = a;
if (asset.source.contains(QLatin1String("${BUILD_DIR}/")))
break;
asset.source = QLatin1String("${BUILD_DIR}/") + asset.destination;
assetList.removeOne(a);
assetList << asset;
updated = true;
break;
}
}
}
///
/// Returns all arguments
/// That is: possbile subpath
/// spec
/// config arguemnts
/// moreArguments
/// user arguments
QString QMakeStep::allArguments(bool shorted)
{
Qt4BuildConfiguration *bc = qt4BuildConfiguration();
QStringList arguments;
if (bc->subNodeBuild())
arguments << QDir::toNativeSeparators(bc->subNodeBuild()->path());
else if (shorted)
arguments << QDir::toNativeSeparators(QFileInfo(project()->document()->fileName()).fileName());
else
arguments << QDir::toNativeSeparators(project()->document()->fileName());
arguments << QLatin1String("-r");
bool userProvidedMkspec = false;
for (Utils::QtcProcess::ConstArgIterator ait(m_userArgs); ait.next(); ) {
if (ait.value() == QLatin1String("-spec")) {
if (ait.next()) {
userProvidedMkspec = true;
break;
}
}
}
Utils::FileName specArg = mkspec();
if (!userProvidedMkspec && !specArg.isEmpty())
arguments << QLatin1String("-spec") << specArg.toUserOutput();
// Find out what flags we pass on to qmake
arguments << bc->configCommandLineArguments();
arguments << deducedArguments();
QString args = Utils::QtcProcess::joinArgs(arguments);
// User arguments
Utils::QtcProcess::addArgs(&args, m_userArgs);
// moreArgumentsAfter
foreach (const QString &arg, deducedArgumentsAfter())
Utils::QtcProcess::addArg(&args, arg);
return args;
}
bool AndroidSettingsWidget::checkNDK(const Utils::FileName &location)
{
if (location.isEmpty()) {
m_ui->ndkWarningIconLabel->setVisible(false);
m_ui->toolchainFoundLabel->setVisible(false);
m_ui->kitWarningIconLabel->setVisible(false);
m_ui->kitWarningLabel->setVisible(false);
return false;
}
Utils::FileName platformPath = location;
Utils::FileName toolChainPath = location;
Utils::FileName sourcesPath = location;
if (!platformPath.appendPath(QLatin1String("platforms")).toFileInfo().exists()
|| !toolChainPath.appendPath(QLatin1String("toolchains")).toFileInfo().exists()
|| !sourcesPath.appendPath(QLatin1String("sources/cxx-stl")).toFileInfo().exists()) {
m_ui->toolchainFoundLabel->setText(tr("\"%1\" does not seem to be an Android NDK top folder.").arg(location.toUserOutput()));
m_ui->toolchainFoundLabel->setVisible(true);
m_ui->ndkWarningIconLabel->setVisible(true);
return false;
}
// Check how many toolchains we could add...
QList<AndroidToolChainFactory::AndroidToolChainInformation> compilerPaths = AndroidToolChainFactory::toolchainPathsForNdk(location);
if (compilerPaths.isEmpty()) {
m_ui->ndkWarningIconLabel->setVisible(false);
m_ui->toolchainFoundLabel->setVisible(false);
} else {
m_ui->ndkWarningIconLabel->setVisible(false);
m_ui->toolchainFoundLabel->setText(tr("Found %n toolchains for this NDK.", 0, compilerPaths.count()));
m_ui->toolchainFoundLabel->setVisible(true);
}
// See if we have qt versions for those toolchains
QSet<ProjectExplorer::Abi::Architecture> toolchainsForArch;
foreach (const AndroidToolChainFactory::AndroidToolChainInformation &ati, compilerPaths)
toolchainsForArch.insert(ati.architecture);
QSet<ProjectExplorer::Abi::Architecture> qtVersionsForArch;
foreach (QtSupport::BaseQtVersion *qtVersion, QtSupport::QtVersionManager::versions()) {
if (qtVersion->type() != QLatin1String(Constants::ANDROIDQT) || qtVersion->qtAbis().isEmpty())
continue;
qtVersionsForArch.insert(qtVersion->qtAbis().first().architecture());
}
QSet<ProjectExplorer::Abi::Architecture> missingQtArchs = toolchainsForArch.subtract(qtVersionsForArch);
if (missingQtArchs.isEmpty()) {
m_ui->kitWarningIconLabel->setVisible(false);
m_ui->kitWarningLabel->setVisible(false);
} else {
m_ui->kitWarningIconLabel->setVisible(true);
m_ui->kitWarningLabel->setVisible(true);
if (missingQtArchs.count() == 1) {
m_ui->kitWarningLabel->setText(tr("Qt version for architecture %1 is missing.\n To add the Qt version, select Options > Build & Run > Qt Versions.")
.arg(ProjectExplorer::Abi::toString((*missingQtArchs.constBegin()))));
} else {
QStringList missingArchs;
foreach (ProjectExplorer::Abi::Architecture arch, missingQtArchs)
missingArchs.append(ProjectExplorer::Abi::toString(arch));
m_ui->kitWarningLabel->setText(tr("Qt versions for architectures %1 are missing.\n To add the Qt versions, select Options > Build & Run > Qt Versions.")
.arg(missingArchs.join(QLatin1String(", "))));
}
}
m_androidConfig.ndkLocation = location;
return true;
}
void PathChooser::setFileName(const Utils::FileName &fn)
{
d->m_lineEdit->setText(fn.toUserOutput());
}
bool AndroidSettingsWidget::checkSDK(const Utils::FileName &location)
{
if (location.isEmpty()) {
m_ui->sdkWarningIconLabel->setVisible(false);
m_ui->sdkWarningLabel->setVisible(false);
return false;
}
Utils::FileName adb = location;
Utils::FileName androidExe = location;
Utils::FileName androidBat = location;
Utils::FileName emulator = location;
if (!adb.appendPath(QLatin1String("platform-tools/adb" QTC_HOST_EXE_SUFFIX)).toFileInfo().exists()
|| (!androidExe.appendPath(QLatin1String("/tools/android" QTC_HOST_EXE_SUFFIX)).toFileInfo().exists()
&& !androidBat.appendPath(QLatin1String("/tools/android" ANDROID_BAT_SUFFIX)).toFileInfo().exists())
|| !emulator.appendPath(QLatin1String("/tools/emulator" QTC_HOST_EXE_SUFFIX)).toFileInfo().exists()) {
m_ui->sdkWarningIconLabel->setVisible(true);
m_ui->sdkWarningLabel->setVisible(true);
m_ui->sdkWarningLabel->setText(tr("\"%1\" does not seem to be an Android SDK top folder.").arg(location.toUserOutput()));
return false;
} else {
m_ui->sdkWarningIconLabel->setVisible(false);
m_ui->sdkWarningLabel->setVisible(false);
}
return true;
}
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;
}
bool AndroidSettingsWidget::checkSDK(const Utils::FileName &location)
{
if (location.isEmpty())
return false;
Utils::FileName adb = location;
Utils::FileName androidExe = location;
Utils::FileName androidBat = location;
Utils::FileName emulator = location;
if (!adb.appendPath(QLatin1String("platform-tools/adb" ANDROID_EXE_SUFFIX)).toFileInfo().exists()
|| (!androidExe.appendPath(QLatin1String("/tools/android" ANDROID_EXE_SUFFIX)).toFileInfo().exists()
&& !androidBat.appendPath(QLatin1String("/tools/android" ANDROID_BAT_SUFFIX)).toFileInfo().exists())
|| !emulator.appendPath(QLatin1String("/tools/emulator" ANDROID_EXE_SUFFIX)).toFileInfo().exists()) {
QMessageBox::critical(this, tr("Android SDK Folder"), tr("\"%1\" doesn't seem to be an Android SDK top folder").arg(location.toUserOutput()));
return false;
}
return true;
}
bool AndroidSettingsWidget::checkNDK(const Utils::FileName &location)
{
m_ui->toolchainVersionComboBox->setEnabled(false);
m_ui->GdbLocationLineEdit->setEnabled(false);
m_ui->GdbLocationPushButton->setEnabled(false);
m_ui->GdbserverLocationLineEdit->setEnabled(false);
m_ui->GdbserverLocationPushButton->setEnabled(false);
if (location.isEmpty())
return false;
Utils::FileName platformPath = location;
Utils::FileName toolChainPath = location;
Utils::FileName sourcesPath = location;
if (!platformPath.appendPath(QLatin1String("platforms")).toFileInfo().exists()
|| !toolChainPath.appendPath(QLatin1String("toolchains")).toFileInfo().exists()
|| !sourcesPath.appendPath(QLatin1String("sources/cxx-stl")).toFileInfo().exists()) {
QMessageBox::critical(this, tr("Android SDK Folder"), tr("\"%1\" doesn't seem to be an Android NDK top folder").arg(location.toUserOutput()));
return false;
}
m_androidConfig.ndkLocation = location;
m_ui->toolchainVersionComboBox->setEnabled(true);
m_ui->GdbLocationLineEdit->setEnabled(true);
m_ui->GdbLocationPushButton->setEnabled(true);
m_ui->GdbserverLocationLineEdit->setEnabled(true);
m_ui->GdbserverLocationPushButton->setEnabled(true);
return true;
}
bool BlackBerryCreatePackageStep::init()
{
if (!BlackBerryAbstractDeployStep::init())
return false;
const Utils::FileName packageCmd =
target()->activeBuildConfiguration()->environment().searchInPath(QLatin1String(PACKAGER_CMD));
if (packageCmd.isEmpty()) {
raiseError(tr("Could not find packager command \"%1\" in the build environment.")
.arg(QLatin1String(PACKAGER_CMD)));
return false;
}
BlackBerryDeployConfiguration *deployConfig = qobject_cast<BlackBerryDeployConfiguration *>(deployConfiguration());
QTC_ASSERT(deployConfig, return false);
QList<BarPackageDeployInformation> packagesToDeploy = deployConfig->deploymentInfo()->enabledPackages();
if (packagesToDeploy.isEmpty()) {
raiseError(tr("No packages enabled for deployment."));
return false;
}
foreach (const BarPackageDeployInformation &info, packagesToDeploy) {
if (info.appDescriptorPath().isEmpty()) {
raiseError(tr("BAR application descriptor file not specified. Check deployment settings."));
return false;
}
if (info.packagePath().isEmpty()) {
raiseError(tr("No package specified. Check deployment settings."));
return false;
}
const QString buildDir = info.packagePath().toFileInfo().absolutePath();
QDir dir(buildDir);
if (!dir.exists()) {
if (!dir.mkpath(buildDir)) {
raiseError(tr("Could not create build directory \"%1\".").arg(buildDir));
return false;
}
}
const Utils::FileName appDescriptorPath = info.appDescriptorPath();
if (!doUpdateAppDescriptorFile(appDescriptorPath, PlaceHolders))
// If there is an error, prepareAppDescriptorFile() will raise it
return false;
QStringList args;
if (m_packageMode == DevelopmentMode) {
args << QLatin1String("-devMode");
if (!debugToken().isEmpty())
args << QLatin1String("-debugToken") << QnxUtils::addQuotes(QDir::toNativeSeparators(debugToken()));
} else if (m_packageMode == SigningPackageMode) {
if (m_cskPassword.isEmpty() || m_keystorePassword.isEmpty()) {
BlackBerrySigningPasswordsDialog dlg;
dlg.setCskPassword(m_cskPassword);
dlg.setStorePassword(m_keystorePassword);
if (dlg.exec() == QDialog::Rejected) {
raiseError(tr("Missing passwords for signing packages."));
return false;
}
m_cskPassword = dlg.cskPassword();
m_keystorePassword = dlg.storePassword();
emit cskPasswordChanged(m_cskPassword);
emit keystorePasswordChanged(m_keystorePassword);
}
args << QLatin1String("-sign");
args << QLatin1String("-cskpass");
args << m_cskPassword;
args << QLatin1String("-storepass");
args << m_keystorePassword;
}
args << QLatin1String("-package") << QnxUtils::addQuotes(info.packagePath().toUserOutput());
args << QnxUtils::addQuotes(appDescriptorPath.toUserOutput());
addCommand(packageCmd.toString(), args);
}
return true;
}
void AndroidSettingsWidget::applyToUi(AndroidSettingsWidget::Mode mode)
{
if (mode & Sdk) {
if (m_sdkState == Error) {
m_ui->sdkWarningIconLabel->setVisible(true);
m_ui->sdkWarningLabel->setVisible(true);
Utils::FileName location = Utils::FileName::fromUserInput(m_ui->SDKLocationLineEdit->text());
if (sdkLocationIsValid())
m_ui->sdkWarningLabel->setText(tr("The Platform tools are missing. Please use the Android SDK Manager to install them."));
else
m_ui->sdkWarningLabel->setText(tr("\"%1\" does not seem to be an Android SDK top folder.").arg(location.toUserOutput()));
} else {
m_ui->sdkWarningIconLabel->setVisible(false);
m_ui->sdkWarningLabel->setVisible(false);
}
}
if (mode & Ndk) {
if (m_ndkState == NotSet) {
m_ui->ndkWarningIconLabel->setVisible(false);
m_ui->toolchainFoundLabel->setVisible(false);
m_ui->kitWarningIconLabel->setVisible(false);
m_ui->kitWarningLabel->setVisible(false);
} else if (m_ndkState == Error) {
m_ui->toolchainFoundLabel->setText(m_ndkErrorMessage);
m_ui->toolchainFoundLabel->setVisible(true);
m_ui->ndkWarningIconLabel->setVisible(true);
m_ui->kitWarningIconLabel->setVisible(false);
m_ui->kitWarningLabel->setVisible(false);
} else {
if (m_ndkCompilerCount > 0) {
m_ui->ndkWarningIconLabel->setVisible(false);
m_ui->toolchainFoundLabel->setText(tr("Found %n toolchains for this NDK.", 0, m_ndkCompilerCount));
m_ui->toolchainFoundLabel->setVisible(true);
} else {
m_ui->ndkWarningIconLabel->setVisible(false);
m_ui->toolchainFoundLabel->setVisible(false);
}
if (m_ndkMissingQtArchs.isEmpty()) {
m_ui->kitWarningIconLabel->setVisible(false);
m_ui->kitWarningLabel->setVisible(false);
} else {
m_ui->kitWarningIconLabel->setVisible(true);
m_ui->kitWarningLabel->setVisible(true);
m_ui->kitWarningLabel->setText(m_ndkMissingQtArchs);
}
}
}
if (mode & Java) {
Utils::FileName location = m_androidConfig.openJDKLocation();
bool error = m_javaState == Error;
m_ui->jdkWarningIconLabel->setVisible(error);
m_ui->jdkWarningLabel->setVisible(error);
if (error)
m_ui->jdkWarningLabel->setText(tr("\"%1\" does not seem to be a JDK folder.").arg(location.toUserOutput()));
}
if (mode & Sdk || mode & Java) {
if (m_sdkState == Okay && m_javaState == Okay) {
m_ui->AVDManagerFrame->setEnabled(true);
} else {
m_ui->AVDManagerFrame->setEnabled(false);
}
m_AVDModel.setAvdList(m_androidConfig.androidVirtualDevices());
}
}
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);
}
RvctToolChain::RvctVersion RvctToolChain::version(const Utils::FileName &rvctPath)
{
RvctToolChain::RvctVersion v;
QProcess armcc;
armcc.start(rvctPath.toString(), QStringList(QLatin1String("--version_number")));
if (!armcc.waitForStarted()) {
qWarning("Unable to run rvct binary '%s' when trying to determine version.", qPrintable(rvctPath.toUserOutput()));
return v;
}
armcc.closeWriteChannel();
if (!armcc.waitForFinished()) {
Utils::SynchronousProcess::stopProcess(armcc);
qWarning("Timeout running rvct binary '%s' trying to determine version.", qPrintable(rvctPath.toUserOutput()));
return v;
}
if (armcc.exitStatus() != QProcess::NormalExit) {
qWarning("A crash occurred when running rvct binary '%s' trying to determine version.", qPrintable(rvctPath.toUserOutput()));
return v;
}
QString versionLine = QString::fromLocal8Bit(armcc.readAllStandardOutput());
versionLine += QString::fromLocal8Bit(armcc.readAllStandardError());
QRegExp versionRegExp(QLatin1String("^(\\d)(\\d)0*([1-9]\\d*)"), Qt::CaseInsensitive);
Q_ASSERT(versionRegExp.isValid());
if (versionRegExp.indexIn(versionLine) != -1) {
v.majorVersion = versionRegExp.cap(1).toInt();
v.minorVersion = versionRegExp.cap(2).toInt();
v.build = versionRegExp.cap(3).toInt();
}
return v;
}