void QmlProject::parseProject(RefreshOptions options)
{
Core::MessageManager *messageManager = Core::ICore::messageManager();
if (options & Files) {
if (options & ProjectFile)
delete m_projectItem.data();
if (!m_projectItem) {
Utils::FileReader reader;
if (reader.fetch(m_fileName)) {
QDeclarativeComponent *component = new QDeclarativeComponent(&m_engine, this);
component->setData(reader.data(), QUrl::fromLocalFile(m_fileName));
if (component->isReady()
&& qobject_cast<QmlProjectItem*>(component->create())) {
m_projectItem = qobject_cast<QmlProjectItem*>(component->create());
connect(m_projectItem.data(), SIGNAL(qmlFilesChanged(QSet<QString>,QSet<QString>)),
this, SLOT(refreshFiles(QSet<QString>,QSet<QString>)));
} else {
messageManager->printToOutputPane(tr("Error while loading project file %1.").arg(m_fileName), Core::MessageManager::NoModeSwitch);
messageManager->printToOutputPane(component->errorString(), Core::MessageManager::NoModeSwitch);
}
} else {
messageManager->printToOutputPane(tr("QML project: %1").arg(reader.errorString()), Core::MessageManager::NoModeSwitch);
}
}
if (m_projectItem) {
m_projectItem.data()->setSourceDirectory(projectDir().path());
m_modelManager->updateSourceFiles(m_projectItem.data()->files(), true);
QString mainFilePath = m_projectItem.data()->mainFile();
if (!mainFilePath.isEmpty()) {
mainFilePath = projectDir().absoluteFilePath(mainFilePath);
Utils::FileReader reader;
QString errorMessage;
if (!reader.fetch(mainFilePath, &errorMessage)) {
messageManager->printToOutputPane(
tr("Warning while loading project file %1.").arg(m_fileName),
Core::MessageManager::NoModeSwitch);
messageManager->printToOutputPane(errorMessage, Core::MessageManager::NoModeSwitch);
} else {
m_defaultImport = detectImport(QString::fromUtf8(reader.data()));
}
}
}
m_rootNode->refresh();
}
if (options & Configuration) {
// update configuration
}
if (options & Files)
emit fileListChanged();
}
MerDevicesXmlReader::MerDevicesXmlReader(const QString &fileName, QObject *parent)
: QObject(parent),
d(new MerDevicesXmlReaderPrivate)
{
Utils::FileReader reader;
d->error = !reader.fetch(fileName, QIODevice::ReadOnly);
if (d->error) {
d->errorString = reader.errorString();
return;
}
QXmlSchema schema;
schema.setMessageHandler(&d->messageHandler);
Utils::FileReader schemeReader;
d->error = !schemeReader.fetch(QString::fromLatin1("%1/mer/devices.xsd").arg(sharedDirPath()),
QIODevice::ReadOnly);
if (d->error) {
d->errorString = schemeReader.errorString();
return;
}
schema.load(schemeReader.data());
d->error = !schema.isValid();
if (d->error) {
d->errorString = d->messageHandler.errorString();
return;
}
QXmlSchemaValidator validator(schema);
validator.setMessageHandler(&d->messageHandler);
d->error = !validator.validate(reader.data());
if (d->error) {
d->errorString = d->messageHandler.errorString();
return;
}
d->query.setQuery(QString::fromLatin1("doc('%1')").arg(fileName));
d->query.setMessageHandler(&d->messageHandler);
d->error = !d->query.isValid();
if (d->error) {
d->errorString = d->messageHandler.errorString();
return;
}
d->error = !d->query.evaluateTo(d->receiver);
if (d->error)
d->errorString = d->messageHandler.errorString();
}
bool NickNameDialog::populateModelFromMailCapFile(const QString &fileName,
QStandardItemModel *model,
QString *errorMessage)
{
if (const int rowCount = model->rowCount())
model->removeRows(0, rowCount);
if (fileName.isEmpty())
return true;
Utils::FileReader reader;
if (!reader.fetch(fileName, QIODevice::Text, errorMessage))
return false;
// Split into lines and read
NickNameEntry entry;
const QStringList lines = QString::fromUtf8(reader.data()).trimmed().split(QLatin1Char('\n'));
const int count = lines.size();
for (int i = 0; i < count; i++) {
if (entry.parse(lines.at(i))) {
model->appendRow(entry.toModelRow());
} else {
qWarning("%s: Invalid mail cap entry at line %d: '%s'\n",
qPrintable(QDir::toNativeSeparators(fileName)),
i + 1, qPrintable(lines.at(i)));
}
}
model->sort(0);
return true;
}
bool AbstractMobileApp::readTemplate(int fileType, QByteArray *data, QString *errorMessage) const
{
Utils::FileReader reader;
if (!reader.fetch(path(fileType), errorMessage))
return false;
*data = reader.data();
return true;
}
static QByteArray getSourceForUrl(const QString &fileURl)
{
Utils::FileReader fileReader;
if (fileReader.fetch(fileURl))
return fileReader.data();
else
return Utils::FileReader::fetchQrc(fileURl);
}
ExternalTool * ExternalTool::createFromFile(const QString &fileName, QString *errorMessage, const QString &locale)
{
QString absFileName = QFileInfo(fileName).absoluteFilePath();
Utils::FileReader reader;
if (!reader.fetch(absFileName, errorMessage))
return 0;
ExternalTool *tool = ExternalTool::createFromXml(reader.data(), errorMessage, locale);
if (!tool)
return 0;
tool->m_fileName = absFileName;
return tool;
}
QByteArray QmlApp::readFile(const QString &filePath, bool &ok) const
{
Utils::FileReader reader;
if (!reader.fetch(filePath)) {
ok = false;
return QByteArray();
}
ok = true;
return reader.data();
}
static QString getSource(const QString &fileName,
const CppModelManagerInterface::WorkingCopy &workingCopy)
{
if (workingCopy.contains(fileName)) {
return workingCopy.source(fileName);
} else {
Utils::FileReader reader;
if (!reader.fetch(fileName, QFile::Text)) // ### FIXME error reporting
return QString();
return QString::fromLocal8Bit(reader.data()); // ### FIXME encoding
}
}
void BlackBerryDeployConfiguration::setupBarDescriptor()
{
Qt4ProjectManager::Qt4BuildConfiguration *bc = qobject_cast<Qt4ProjectManager::Qt4BuildConfiguration *>(target()->activeBuildConfiguration());
if (!bc || !target()->kit())
return;
Core::Id deviceType = ProjectExplorer::DeviceTypeKitInformation::deviceTypeId(target()->kit());
QString projectName = target()->project()->displayName();
if (deviceType == Constants::QNX_BB_OS_TYPE) {
const QLatin1String barDescriptorFileName("bar-descriptor.xml");
Utils::FileName barDescriptorPath = Utils::FileName::fromString(target()->project()->projectDirectory()).appendPath(barDescriptorFileName);
const QFile barDescriptorFile(barDescriptorPath.toString());
if (barDescriptorFile.exists())
return;
Utils::FileReader reader;
QString barDescriptorTemplate;
if (QDir(Utils::FileName::fromString(target()->project()->projectDirectory()).appendPath(QLatin1String("qml")).toString()).exists())
barDescriptorTemplate = Core::ICore::resourcePath()
+ QLatin1String("/templates/wizards/bb-quickapp/") + barDescriptorFileName;
else
barDescriptorTemplate = Core::ICore::resourcePath()
+ QLatin1String("/templates/wizards/bb-guiapp/") + barDescriptorFileName;
if (!reader.fetch(barDescriptorTemplate)) {
QMessageBox::warning(Core::ICore::mainWindow(),
tr("Error while setting up bar descriptor"),
tr("Reading bar descriptor template failed"),
QMessageBox::Ok);
return;
}
QString content = QString::fromUtf8(reader.data());
content.replace(QLatin1String("%ProjectName%"), projectName);
Utils::FileSaver writer(barDescriptorFile.fileName(), QIODevice::WriteOnly);
writer.write(content.toUtf8());
if (!writer.finalize()) {
QMessageBox::warning(Core::ICore::mainWindow(),
tr("Error while setting up bar descriptor"),
tr("Failure writing bar descriptor file."),
QMessageBox::Ok);
return;
}
// Add the Bar Descriptor to the existing project
if (target()->project()->rootProjectNode())
addBarDescriptorToProject(barDescriptorPath.toString());
}
}
void QmlProject::parseProject(RefreshOptions options)
{
if (options & Files) {
if (options & ProjectFile)
delete m_projectItem.data();
if (!m_projectItem) {
QString errorMessage;
m_projectItem = QmlProjectFileFormat::parseProjectFile(m_fileName, &errorMessage);
if (m_projectItem) {
connect(m_projectItem.data(), SIGNAL(qmlFilesChanged(QSet<QString>,QSet<QString>)),
this, SLOT(refreshFiles(QSet<QString>,QSet<QString>)));
} else {
MessageManager::write(tr("Error while loading project file %1.")
.arg(m_fileName.toUserOutput()),
MessageManager::NoModeSwitch);
MessageManager::write(errorMessage);
}
}
if (m_projectItem) {
m_projectItem.data()->setSourceDirectory(projectDir().path());
if (modelManager())
modelManager()->updateSourceFiles(m_projectItem.data()->files(), true);
QString mainFilePath = m_projectItem.data()->mainFile();
if (!mainFilePath.isEmpty()) {
mainFilePath = projectDir().absoluteFilePath(mainFilePath);
Utils::FileReader reader;
QString errorMessage;
if (!reader.fetch(mainFilePath, &errorMessage)) {
MessageManager::write(tr("Warning while loading project file %1.")
.arg(m_fileName.toUserOutput()));
MessageManager::write(errorMessage);
} else {
m_defaultImport = detectImport(QString::fromUtf8(reader.data()));
}
}
}
m_rootNode->refresh();
}
if (options & Configuration) {
// update configuration
}
if (options & Files)
emit fileListChanged();
}
QByteArray FileConverter::loadFileContent(const QString &filePath, QString &errorMessage)
{
QByteArray ret;
Utils::FileReader fr;
QString absFilePath = filePath;
if (!filePath.startsWith(QLatin1String(":/"))) {
const QString srcProjectPath = convertedProjectContext().srcProjectPath();
absFilePath = srcProjectPath + QLatin1Char('/') + filePath;
}
fr.fetch(absFilePath);
if (!fr.errorString().isEmpty())
errorMessage = fr.errorString();
else
ret = fr.data();
return ret;
}
bool GuiAppWizard::parametrizeTemplate(const QString &templatePath, const QString &templateName,
const GuiAppParameters ¶ms,
QString *target, QString *errorMessage)
{
QString fileName = templatePath;
fileName += QDir::separator();
fileName += templateName;
Utils::FileReader reader;
if (!reader.fetch(fileName, QIODevice::Text, errorMessage))
return false;
QString contents = QString::fromUtf8(reader.data());
contents.replace(QLatin1String("%QAPP_INCLUDE%"), QLatin1String("QApplication"));
contents.replace(QLatin1String("%INCLUDE%"), params.headerFileName);
contents.replace(QLatin1String("%CLASS%"), params.className);
contents.replace(QLatin1String("%BASECLASS%"), params.baseClassName);
contents.replace(QLatin1String("%WIDGET_HEIGHT%"), QString::number(params.widgetHeight));
contents.replace(QLatin1String("%WIDGET_WIDTH%"), QString::number(params.widgetWidth));
if (params.isMobileApplication)
contents.replace(QLatin1String("%SHOWMETHOD%"), QString::fromLatin1(mainSourceMobilityShowC));
else
contents.replace(QLatin1String("%SHOWMETHOD%"), QString::fromLatin1(mainSourceShowC));
const QChar dot = QLatin1Char('.');
QString preDef = params.headerFileName.toUpper();
preDef.replace(dot, QLatin1Char('_'));
contents.replace("%PRE_DEF%", preDef.toUtf8());
const QString uiFileName = params.formFileName;
QString uiHdr = QLatin1String("ui_");
uiHdr += uiFileName.left(uiFileName.indexOf(dot));
uiHdr += QLatin1String(".h");
contents.replace(QLatin1String("%UI_HDR%"), uiHdr);
if (params.baseClassName == QLatin1String("QMainWindow")) {
if (params.isMobileApplication)
contents.replace(QLatin1String("%CENTRAL_WIDGET%"), QLatin1String(mainWindowMobileUiContentsC));
else
contents.replace(QLatin1String("%CENTRAL_WIDGET%"), QLatin1String(mainWindowUiContentsC));
} else {
contents.remove(QLatin1String("%CENTRAL_WIDGET%"));
}
*target = contents;
return true;
}
bool VcsBaseSubmitEditor::open(QString *errorString, const QString &fileName, const QString &realFileName)
{
if (fileName.isEmpty())
return false;
Utils::FileReader reader;
if (!reader.fetch(realFileName, QIODevice::Text, errorString))
return false;
const QString text = QString::fromLocal8Bit(reader.data());
if (!setFileContents(text.toUtf8()))
return false;
d->m_file->setFilePath(QFileInfo(fileName).absoluteFilePath());
d->m_file->setModified(fileName != realFileName);
return true;
}
static Document::Ptr getParsedDocument(const QString &fileName,
CppTools::WorkingCopy &workingCopy,
Snapshot &snapshot)
{
QByteArray src;
if (workingCopy.contains(fileName)) {
src = workingCopy.source(fileName);
} else {
Utils::FileReader reader;
if (reader.fetch(fileName)) // ### FIXME error reporting
src = QString::fromLocal8Bit(reader.data()).toUtf8();
}
Document::Ptr doc = snapshot.preprocessedDocument(src, fileName);
doc->check();
snapshot.insert(doc);
return doc;
}
void VcsBaseSubmitEditor::createUserFields(const QString &fieldConfigFile)
{
Utils::FileReader reader;
if (!reader.fetch(fieldConfigFile, QIODevice::Text, Core::ICore::mainWindow()))
return;
// Parse into fields
const QStringList fields = fieldTexts(QString::fromUtf8(reader.data()));
if (fields.empty())
return;
// Create a completer on user names
const QStandardItemModel *nickNameModel = VcsPlugin::instance()->nickNameModel();
QCompleter *completer = new QCompleter(NickNameDialog::nickNameList(nickNameModel), this);
SubmitFieldWidget *fieldWidget = new SubmitFieldWidget;
connect(fieldWidget, SIGNAL(browseButtonClicked(int,QString)),
this, SLOT(slotSetFieldNickName(int)));
fieldWidget->setCompleter(completer);
fieldWidget->setAllowDuplicateFields(true);
fieldWidget->setHasBrowseButton(true);
fieldWidget->setFields(fields);
d->m_widget->addSubmitFieldWidget(fieldWidget);
}
bool MaemoDebianPackageCreationStep::adaptRulesFile(
const QString &templatePath, const QString &rulesFilePath)
{
Utils::FileReader reader;
if (!reader.fetch(templatePath)) {
raiseError(reader.errorString());
return false;
}
QByteArray content = reader.data();
// Always check for dependencies in release builds.
if (!m_debugBuild)
ensureShlibdeps(content);
Utils::FileSaver saver(rulesFilePath);
saver.write(content);
if (!saver.finalize()) {
raiseError(saver.errorString());
return false;
}
QFile rulesFile(rulesFilePath);
rulesFile.setPermissions(rulesFile.permissions() | QFile::ExeUser);
return true;
}
void PluginDumper::dump(const Plugin &plugin)
{
if (plugin.hasPredumpedQmlTypesFile()) {
const Snapshot snapshot = m_modelManager->snapshot();
LibraryInfo libraryInfo = snapshot.libraryInfo(plugin.qmldirPath);
if (!libraryInfo.isValid())
return;
const QString &path = plugin.predumpedQmlTypesFilePath();
Utils::FileReader reader;
if (!reader.fetch(path, QFile::Text)) {
libraryInfo.setPluginTypeInfoStatus(LibraryInfo::TypeInfoFileError, reader.errorString());
m_modelManager->updateLibraryInfo(plugin.qmldirPath, libraryInfo);
return;
}
QString error;
QString warning;
const QList<FakeMetaObject::ConstPtr> objectsList = parseHelper(reader.data(), &error, &warning);
if (error.isEmpty()) {
libraryInfo.setMetaObjects(objectsList);
libraryInfo.setPluginTypeInfoStatus(LibraryInfo::TypeInfoFileDone);
} else {
libraryInfo.setPluginTypeInfoStatus(LibraryInfo::TypeInfoFileError,
tr("Failed to parse '%1'.\nError: %2").arg(path, error));
}
if (!warning.isEmpty())
printParseWarnings(plugin.qmldirPath, warning);
m_modelManager->updateLibraryInfo(plugin.qmldirPath, libraryInfo);
return;
}
ProjectExplorer::Project *activeProject = ProjectExplorer::ProjectExplorerPlugin::instance()->startupProject();
if (!activeProject)
return;
ModelManagerInterface::ProjectInfo info = m_modelManager->projectInfo(activeProject);
if (info.qmlDumpPath.isEmpty()) {
const Snapshot snapshot = m_modelManager->snapshot();
LibraryInfo libraryInfo = snapshot.libraryInfo(plugin.qmldirPath);
if (!libraryInfo.isValid())
return;
libraryInfo.setPluginTypeInfoStatus(LibraryInfo::DumpError,
tr("Could not locate the helper application for dumping type information from C++ plugins.\n"
"Please build the debugging helpers on the Qt version options page."));
m_modelManager->updateLibraryInfo(plugin.qmldirPath, libraryInfo);
return;
}
QProcess *process = new QProcess(this);
process->setEnvironment(info.qmlDumpEnvironment.toStringList());
connect(process, SIGNAL(finished(int)), SLOT(qmlPluginTypeDumpDone(int)));
connect(process, SIGNAL(error(QProcess::ProcessError)), SLOT(qmlPluginTypeDumpError(QProcess::ProcessError)));
QStringList args;
if (plugin.importUri.isEmpty()) {
args << QLatin1String("--path");
args << plugin.importPath;
if (ComponentVersion(plugin.importVersion).isValid())
args << plugin.importVersion;
} else {
args << plugin.importUri;
args << plugin.importVersion;
args << plugin.importPath;
}
process->start(info.qmlDumpPath, args);
m_runningQmldumps.insert(process, plugin.qmldirPath);
}
bool MaemoDebianPackageCreationStep::copyDebianFiles(bool inSourceBuild)
{
const QString debianDirPath = cachedPackageDirectory() + QLatin1String("/debian");
const QString magicFilePath
= debianDirPath + QLatin1Char('/') + MagicFileName;
if (inSourceBuild && QFileInfo(debianDirPath).isDir()
&& !QFileInfo(magicFilePath).exists()) {
raiseError(tr("Packaging failed: Foreign debian directory detected. "
"You are not using a shadow build and there is a debian "
"directory in your project root ('%1'). Qt Creator will not "
"overwrite that directory. Please remove it or use the "
"shadow build feature.").arg(QDir::toNativeSeparators(debianDirPath)));
return false;
}
QString error;
if (!Utils::FileUtils::removeRecursively(debianDirPath, &error)) {
raiseError(tr("Packaging failed: Could not remove directory '%1': %2")
.arg(debianDirPath, error));
return false;
}
QDir buildDir(cachedPackageDirectory());
if (!buildDir.mkdir("debian")) {
raiseError(tr("Could not create Debian directory '%1'.").arg(debianDirPath));
return false;
}
QDir templatesDir(m_templatesDirPath);
const QStringList &files = templatesDir.entryList(QDir::Files);
foreach (const QString &fileName, files) {
const QString srcFile = m_templatesDirPath + QLatin1Char('/') + fileName;
QString newFileName = fileName;
if (newFileName == Qt4HarmattanTarget::aegisManifestFileName())
newFileName = m_packageName + QLatin1String(".aegis");
const QString destFile = debianDirPath + QLatin1Char('/') + newFileName;
if (fileName == QLatin1String("rules")) {
if (!adaptRulesFile(srcFile, destFile))
return false;
continue;
}
if (newFileName == maemoTarget()->packageName() + QLatin1String(".aegis")) {
Utils::FileReader reader;
if (!reader.fetch(srcFile)) {
raiseError(tr("Could not read manifest file '%1': %2.")
.arg(QDir::toNativeSeparators(srcFile), reader.errorString()));
return false;
}
if (reader.data().isEmpty() || reader.data().startsWith("AutoGenerateAegisFile"))
continue;
if (reader.data().startsWith("NoAegisFile")) {
QFile targetFile(destFile);
if (!targetFile.open(QIODevice::WriteOnly)) {
raiseError(tr("Could not write manifest file '%1': %2.")
.arg(QDir::toNativeSeparators(destFile), targetFile.errorString()));
return false;
}
continue;
}
}
if (!QFile::copy(srcFile, destFile)) {
raiseError(tr("Could not copy file '%1' to '%2'.")
.arg(QDir::toNativeSeparators(srcFile), QDir::toNativeSeparators(destFile)));
return false;
}
}
QFile magicFile(magicFilePath);
if (!magicFile.open(QIODevice::WriteOnly)) {
raiseError(tr("Error: Could not create file '%1'.")
.arg(QDir::toNativeSeparators(magicFilePath)));
return false;
}
return true;
}