static bool addFilesToResource(const Utils::FileName &resourceFile,
const QStringList &filePaths,
QStringList *notAdded,
const QString &prefix,
const QString &lang)
{
if (notAdded)
*notAdded = filePaths;
ResourceFile file(resourceFile.toString());
if (file.load() != Core::IDocument::OpenResult::Success)
return false;
int index = file.indexOfPrefix(prefix, lang);
if (index == -1)
index = file.addPrefix(prefix, lang);
if (notAdded)
notAdded->clear();
foreach (const QString &path, filePaths) {
if (file.contains(index, path)) {
if (notAdded)
*notAdded << path;
} else {
file.addFile(index, path);
}
}
Core::DocumentManager::expectFileChange(resourceFile.toString());
file.save();
Core::DocumentManager::unexpectFileChange(resourceFile.toString());
return true;
}
void GccToolChain::addToEnvironment(Utils::Environment &env) const
{
if (!m_compilerCommand.isEmpty()) {
Utils::FileName path = m_compilerCommand.parentDir();
env.prependOrSetPath(path.toString());
}
}
bool QMakeStep::init()
{
Qt4BuildConfiguration *qt4bc = qt4BuildConfiguration();
const QtSupport::BaseQtVersion *qtVersion = QtSupport::QtProfileInformation::qtVersion(target()->profile());
if (!qtVersion)
return false;
QString args = allArguments();
QString workingDirectory;
if (qt4bc->subNodeBuild())
workingDirectory = qt4bc->subNodeBuild()->buildDir();
else
workingDirectory = qt4bc->buildDirectory();
Utils::FileName program = qtVersion->qmakeCommand();
QString makefile = workingDirectory;
if (qt4bc->subNodeBuild()) {
if (!qt4bc->subNodeBuild()->makefile().isEmpty())
makefile.append(qt4bc->subNodeBuild()->makefile());
else
makefile.append(QLatin1String("/Makefile"));
} else if (!qt4bc->makefile().isEmpty()) {
makefile.append(QLatin1Char('/'));
makefile.append(qt4bc->makefile());
} else {
makefile.append(QLatin1String("/Makefile"));
}
// Check whether we need to run qmake
bool makefileOutDated = (qt4bc->compareToImportFrom(makefile) != Qt4BuildConfiguration::MakefileMatches);
if (m_forced || makefileOutDated)
m_needToRunQMake = true;
m_forced = false;
ProcessParameters *pp = processParameters();
pp->setMacroExpander(qt4bc->macroExpander());
pp->setWorkingDirectory(workingDirectory);
pp->setCommand(program.toString());
pp->setArguments(args);
pp->setEnvironment(qt4bc->environment());
setOutputParser(new QMakeParser);
Qt4ProFileNode *node = static_cast<Qt4Project *>(qt4bc->target()->project())->rootQt4ProjectNode();
if (qt4bc->subNodeBuild())
node = qt4bc->subNodeBuild();
QString proFile = node->path();
m_tasks = qtVersion->reportIssues(proFile, workingDirectory);
qSort(m_tasks);
m_scriptTemplate = node->projectType() == ScriptTemplate;
return AbstractProcessStep::init();
}
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();
}
bool BazaarControl::isConfigured() const
{
const Utils::FileName binary = m_bazaarClient->vcsBinary();
if (binary.isEmpty())
return false;
QFileInfo fi = binary.toFileInfo();
return fi.exists() && fi.isFile() && fi.isExecutable();
}
void AndroidBuildApkWidget::updateKeyStorePath(const QString &path)
{
Utils::FileName file = Utils::FileName::fromString(path);
m_step->setKeystorePath(file);
m_ui->signPackageCheckBox->setChecked(!file.isEmpty());
if (!file.isEmpty())
setCertificates();
}
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();
}
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::ndkLocationEditingFinished()
{
Utils::FileName location = Utils::FileName::fromUserInput(m_ui->NDKLocationLineEdit->text());
m_androidConfig.toolchainHost.clear(); // force toolchain host detection
if (!checkNDK(location))
return;
searchForAnt(location.toString());
saveSettings(true);
}
bool BlackBerryDeviceConfigurationWizardConfigPage::isComplete() const
{
bool configurationNameComplete = !m_ui->configurationNameField->text().isEmpty();
Utils::FileName fileName = Utils::FileName::fromString(m_ui->debugTokenCombo->currentText());
bool debugTokenComplete = m_holder.isSimulator || !m_holder.isProductionDevice
|| (!fileName.isEmpty() && fileName.toFileInfo().exists());
return configurationNameComplete && debugTokenComplete;
}
Utils::FileName AndroidManager::manifestSourcePath(ProjectExplorer::Target *target)
{
if (AndroidQtSupport *androidQtSupport = AndroidManager::androidQtSupport(target)) {
Utils::FileName source = androidQtSupport->manifestSourcePath(target);
if (!source.isEmpty())
return source;
}
return manifestPath(target);
}
void NimRunConfiguration::updateConfiguration()
{
auto buildConfiguration = qobject_cast<NimBuildConfiguration*>(activeBuildConfiguration());
Q_ASSERT(buildConfiguration);
Utils::FileName outFile = buildConfiguration->outFilePath();
QFileInfo outFileInfo = outFile.toFileInfo();
setExecutable(outFileInfo.absoluteFilePath());
setWorkingDirectory(outFileInfo.absoluteDir().absolutePath());
}
Utils::FileName CMakeTool::cmakeExecutable() const
{
if (Utils::HostOsInfo::isMacHost() && m_executable.endsWith(".app")) {
Utils::FileName toTest = m_executable;
toTest = toTest.appendPath("Contents/bin/cmake");
if (toTest.exists())
return toTest;
}
return m_executable;
}
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;
}
bool TreeScanner::isWellKnownBinary(const Utils::MimeType & /*mdb*/, const Utils::FileName &fn)
{
return fn.endsWith(QLatin1String(".a")) ||
fn.endsWith(QLatin1String(".o")) ||
fn.endsWith(QLatin1String(".d")) ||
fn.endsWith(QLatin1String(".exe")) ||
fn.endsWith(QLatin1String(".dll")) ||
fn.endsWith(QLatin1String(".obj")) ||
fn.endsWith(QLatin1String(".elf"));
}
QStringList QmlProject::makeAbsolute(const Utils::FileName &path, const QStringList &relativePaths)
{
if (path.isEmpty())
return relativePaths;
const QDir baseDir(path.toString());
return Utils::transform(relativePaths, [&baseDir](const QString &path) {
return QDir::cleanPath(baseDir.absoluteFilePath(path));
});
}
bool AndroidManager::checkForQt51Files(Utils::FileName fileName)
{
fileName.appendPath(QLatin1String("android")).appendPath(QLatin1String("version.xml"));
if (!fileName.exists())
return false;
QDomDocument dstVersionDoc;
if (!openXmlFile(dstVersionDoc, fileName))
return false;
return dstVersionDoc.documentElement().attribute(QLatin1String("value")).toDouble() < 5.2;
}
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;
}
QString CreateAndroidManifestWizard::sourceFileName() const
{
QString result;
QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(m_target->kit());
if (!version)
return result;
Utils::FileName srcPath
= Utils::FileName::fromString(version->qmakeProperty("QT_INSTALL_PREFIX"))
.appendPath(QLatin1String("src/android/java"));
srcPath.appendPath(QLatin1String("AndroidManifest.xml"));
return srcPath.toString();
}
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);
}
QmakeBuildInfo *QmakeBuildConfigurationFactory::createBuildInfo(const Kit *k,
const QString &projectPath,
BuildConfiguration::BuildType type) const
{
QtSupport::BaseQtVersion *version = QtSupport::QtKitInformation::qtVersion(k);
QmakeBuildInfo *info = new QmakeBuildInfo(this);
QString suffix;
if (type == BuildConfiguration::Release) {
//: The name of the release build configuration created by default for a qmake project.
info->displayName = tr("Release");
//: Non-ASCII characters in directory suffix may cause build issues.
suffix = tr("Release", "Shadow build directory suffix");
if (version && version->isQtQuickCompilerSupported())
info->config.useQtQuickCompiler = true;
} else {
if (type == BuildConfiguration::Debug) {
//: The name of the debug build configuration created by default for a qmake project.
info->displayName = tr("Debug");
//: Non-ASCII characters in directory suffix may cause build issues.
suffix = tr("Debug", "Shadow build directory suffix");
} else if (type == BuildConfiguration::Profile) {
//: The name of the profile build configuration created by default for a qmake project.
info->displayName = tr("Profile");
//: Non-ASCII characters in directory suffix may cause build issues.
suffix = tr("Profile", "Shadow build directory suffix");
info->config.separateDebugInfo = true;
if (version && version->isQtQuickCompilerSupported())
info->config.useQtQuickCompiler = true;
}
if (version && version->isQmlDebuggingSupported())
info->config.linkQmlDebuggingQQ2 = true;
}
info->typeName = info->displayName;
// Leave info->buildDirectory unset;
info->kitId = k->id();
// check if this project is in the source directory:
Utils::FileName projectFilePath = Utils::FileName::fromString(projectPath);
if (version && version->isInSourceDirectory(projectFilePath)) {
// assemble build directory
QString projectDirectory = projectFilePath.toFileInfo().absolutePath();
QDir qtSourceDir = QDir(version->sourcePath().toString());
QString relativeProjectPath = qtSourceDir.relativeFilePath(projectDirectory);
QString qtBuildDir = version->versionInfo().value(QStringLiteral("QT_INSTALL_PREFIX"));
QString absoluteBuildPath = QDir::cleanPath(qtBuildDir + QLatin1Char('/') + relativeProjectPath);
info->buildDirectory = Utils::FileName::fromString(absoluteBuildPath);
} else {
info->buildDirectory = defaultBuildDirectory(projectPath, k, suffix, type);
}
info->buildType = type;
return info;
}
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);
}
void BuildConfiguration::prependCompilerPathToEnvironment(Kit *k, Utils::Environment &env)
{
const ToolChain *tc
= ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
if (!tc)
return;
const Utils::FileName compilerDir = tc->compilerCommand().parentDir();
if (!compilerDir.isEmpty())
env.prependOrSetPath(compilerDir.toString());
}
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 IosDeployStep::checkProvisioningProfile()
{
IosDevice::ConstPtr device = iosdevice();
if (device.isNull())
return;
Utils::FileName provisioningFilePath = Utils::FileName::fromString(appBundle());
provisioningFilePath.appendPath(QLatin1String("embedded.mobileprovision"));
// the file is a signed plist stored in DER format
// we simply search for start and end of the plist instead of decoding the DER payload
if (!provisioningFilePath.exists())
return;
QFile provisionFile(provisioningFilePath.toString());
if (!provisionFile.open(QIODevice::ReadOnly))
return;
QByteArray provisionData = provisionFile.readAll();
int start = provisionData.indexOf("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
int end = provisionData.indexOf("</plist>");
if (start == -1 || end == -1)
return;
end += 8;
QTemporaryFile f;
if (!f.open())
return;
f.write(provisionData.mid(start, end - start));
f.flush();
QSettings provisionPlist(f.fileName(), QSettings::NativeFormat);
if (!provisionPlist.contains(QLatin1String("ProvisionedDevices")))
return;
QStringList deviceIds = provisionPlist.value(QLatin1String("ProvisionedDevices")).toStringList();
QString targetId = device->uniqueDeviceID();
foreach (const QString &deviceId, deviceIds) {
if (deviceId == targetId)
return;
}
m_expectFail = true;
QString provisioningProfile = provisionPlist.value(QLatin1String("Name")).toString();
QString provisioningUid = provisionPlist.value(QLatin1String("UUID")).toString();
Task task(Task::Warning,
tr("The provisioning profile \"%1\" (%2) used to sign the application "
"does not cover the device %3 (%4). Deployment to it will fail.")
.arg(provisioningProfile, provisioningUid, device->displayName(),
targetId),
Utils::FileName(), /* filename */
-1, /* line */
ProjectExplorer::Constants::TASK_CATEGORY_COMPILE);
emit addTask(task);
}
void AndroidSettingsWidget::sdkLocationEditingFinished()
{
Utils::FileName location = Utils::FileName::fromUserInput(m_ui->SDKLocationLineEdit->text());
if (!checkSDK(location)) {
m_ui->AVDManagerFrame->setEnabled(false);
return;
}
m_androidConfig.sdkLocation = location;
searchForAnt(location.toString());
saveSettings(true);
m_AVDModel.setAvdList(AndroidConfigurations::instance().androidVirtualDevices());
m_ui->AVDManagerFrame->setEnabled(true);
}
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());
}
void ModelManagerSupportClang::onCurrentEditorChanged(Core::IEditor *editor)
{
m_communicator.updateTranslationUnitVisiblity();
// Update task hub issues for current CppEditorDocument
ClangEditorDocumentProcessor::clearTaskHubIssues();
if (!editor || !editor->document() || !cppModelManager()->isCppEditor(editor))
return;
const ::Utils::FileName filePath = editor->document()->filePath();
if (auto processor = ClangEditorDocumentProcessor::get(filePath.toString()))
processor->generateTaskHubIssues();
}
void Project::readProjectSettings(const Utils::FileName &fileName)
{
QString base = fileName.toFileInfo().absoluteDir().absolutePath();
base.append("/");
QSettings settings(fileName.toString(), QSettings::IniFormat);
settings.beginGroup("Config");
for (const QString &path : settings.value("Ignore").toStringList()) {
if (path.isEmpty())
continue;
m_ignoredDirectories << base + path;
}
settings.endGroup();
}
bool ROSUtils::generateCodeBlocksProjectFile(QProcess *process, const Utils::FileName &sourceDir, const Utils::FileName &buildDir)
{
QString cmd = QLatin1String("cmake ") + sourceDir.toString() + QLatin1String(" -G \"CodeBlocks - Unix Makefiles\"");
bool results = false;
process->setWorkingDirectory(buildDir.toString());
process->start(QLatin1String("bash"), QStringList() << QLatin1String("-c") << cmd);
process->waitForFinished();
if (process->exitStatus() != QProcess::CrashExit)
{
results = true;
}
return results;
}