errorString = "";
dependencies.clear();
QFile file(fileName);
- if (!file.exists())
- return reportError(tr("File does not exist: %1").arg(file.fileName()));
if (!file.open(QIODevice::ReadOnly))
- return reportError(tr("Could not open file for read: %1").arg(file.fileName()));
+ return reportError(tr("Could not open file %1 for read: %2")
+ .arg(QDir::toNativeSeparators(file.fileName()), file.errorString()));
QFileInfo fileInfo(file);
location = fileInfo.absolutePath();
filePath = fileInfo.absoluteFilePath();
#include "sshkeyexchange_p.h"
#include <utils/qtcassert.h>
+#include <utils/fileutils.h>
#include <botan/exceptn.h>
#include <botan/init.h>
m_sendFacility.sendUserAuthByPwdRequestPacket(m_connParams.userName.toUtf8(),
SshCapabilities::SshConnectionService, m_connParams.password.toUtf8());
} else {
- QFile privKeyFile(m_connParams.privateKeyFile);
- bool couldOpen = privKeyFile.open(QIODevice::ReadOnly);
- QByteArray contents;
- if (couldOpen)
- contents = privKeyFile.readAll();
- if (!couldOpen || privKeyFile.error() != QFile::NoError) {
+ Utils::FileReader reader;
+ if (!reader.fetch(m_connParams.privateKeyFile))
throw SshClientException(SshKeyFileError,
- tr("Could not read private key file: %1")
- .arg(privKeyFile.errorString()));
- }
+ tr("Private key error: %1").arg(reader.errorString()));
- m_sendFacility.createAuthenticationKey(contents);
+ m_sendFacility.createAuthenticationKey(reader.data());
m_sendFacility.sendUserAuthByKeyRequestPacket(m_connParams.userName.toUtf8(),
SshCapabilities::SshConnectionService);
}
#include <utils/qtcassert.h>
+#include <utils/fileutils.h>
+
#include <QtCore/QFile>
#include <QtCore/QXmlStreamAttributes>
#include <QtCore/QXmlStreamWriter>
{
const UniqueIDManager *idmanager = UniqueIDManager::instance();
- QFile file(m_filename);
- if (!file.open(QIODevice::WriteOnly|QIODevice::Text))
- return false;
-
- const Context ctx;
- QXmlStreamWriter w(&file);
- w.setAutoFormatting(true);
- w.setAutoFormattingIndent(1); // Historical, used to be QDom.
- w.writeStartDocument();
- w.writeDTD(QLatin1String("<!DOCTYPE KeyboardMappingScheme>"));
- w.writeComment(QString::fromAscii(" Written by Qt Creator %1, %2. ").
- arg(QLatin1String(Core::Constants::IDE_VERSION_LONG),
- QDateTime::currentDateTime().toString(Qt::ISODate)));
- w.writeStartElement(ctx.mappingElement);
- foreach (const ShortcutItem *item, items) {
- const QString id = idmanager->stringForUniqueIdentifier(item->m_cmd->id());
- if (item->m_key.isEmpty()) {
- w.writeEmptyElement(ctx.shortCutElement);
- w.writeAttribute(ctx.idAttribute, id);
- } else {
- w.writeStartElement(ctx.shortCutElement);
- w.writeAttribute(ctx.idAttribute, id);
- w.writeEmptyElement(ctx.keyElement);
- w.writeAttribute(ctx.valueAttribute, item->m_key.toString());
- w.writeEndElement(); // Shortcut
+ Utils::FileSaver saver(m_filename, QIODevice::Text);
+ if (!saver.hasError()) {
+ const Context ctx;
+ QXmlStreamWriter w(saver.file());
+ w.setAutoFormatting(true);
+ w.setAutoFormattingIndent(1); // Historical, used to be QDom.
+ w.writeStartDocument();
+ w.writeDTD(QLatin1String("<!DOCTYPE KeyboardMappingScheme>"));
+ w.writeComment(QString::fromAscii(" Written by Qt Creator %1, %2. ").
+ arg(QLatin1String(Core::Constants::IDE_VERSION_LONG),
+ QDateTime::currentDateTime().toString(Qt::ISODate)));
+ w.writeStartElement(ctx.mappingElement);
+ foreach (const ShortcutItem *item, items) {
+ const QString id = idmanager->stringForUniqueIdentifier(item->m_cmd->id());
+ if (item->m_key.isEmpty()) {
+ w.writeEmptyElement(ctx.shortCutElement);
+ w.writeAttribute(ctx.idAttribute, id);
+ } else {
+ w.writeStartElement(ctx.shortCutElement);
+ w.writeAttribute(ctx.idAttribute, id);
+ w.writeEmptyElement(ctx.keyElement);
+ w.writeAttribute(ctx.valueAttribute, item->m_key.toString());
+ w.writeEndElement(); // Shortcut
+ }
}
+ w.writeEndElement();
+ w.writeEndDocument();
+
+ saver.setResult(&w);
}
- w.writeEndElement();
- w.writeEndDocument();
- file.close();
- return true;
+ return saver.finalize();
}
} // namespace Internal
#include <utils/filewizarddialog.h>
#include <utils/qtcassert.h>
#include <utils/stringutils.h>
+#include <utils/fileutils.h>
#include <QtCore/QDir>
#include <QtCore/QFile>
return false;
}
}
- // Write out
- QFile file(m_d->path);
+ // Write out
QIODevice::OpenMode flags = QIODevice::WriteOnly|QIODevice::Truncate;
if (!isBinary())
flags |= QIODevice::Text;
- if (!file.open(flags)) {
- *errorMessage = BaseFileWizard::tr("Unable to open %1 for writing: %2").arg(m_d->path, file.errorString());
- return false;
- }
- if (file.write(m_d->contents) == -1) {
- *errorMessage = BaseFileWizard::tr("Error while writing to %1: %2").arg(m_d->path, file.errorString());
- return false;
- }
- file.close();
- return true;
+ Utils::FileSaver saver(m_d->path, flags);
+ saver.write(m_d->contents);
+ return saver.finalize(errorMessage);
}
GeneratedFile::Attributes GeneratedFile::attributes() const
#include <utils/qtcassert.h>
#include <utils/stringutils.h>
#include <utils/environment.h>
+#include <utils/fileutils.h>
#include <QtCore/QXmlStreamReader>
#include <QtCore/QXmlStreamWriter>
ExternalTool * ExternalTool::createFromFile(const QString &fileName, QString *errorMessage, const QString &locale)
{
- QFileInfo info(fileName);
- QFile file(info.absoluteFilePath());
- if (!file.open(QIODevice::ReadOnly)) {
- if (errorMessage)
- *errorMessage = tr("Could not open tool specification %1 for reading: %2").
- arg(fileName, file.errorString());
+ QString absFileName = QFileInfo(fileName).absoluteFilePath();
+ Utils::FileReader reader;
+ if (!reader.fetch(absFileName, errorMessage))
return 0;
- }
- const QByteArray &bytes = file.readAll();
- file.close();
- ExternalTool *tool = ExternalTool::createFromXml(bytes, errorMessage, locale);
+ ExternalTool *tool = ExternalTool::createFromXml(reader.data(), errorMessage, locale);
if (!tool) {
return 0;
}
- tool->m_fileName = file.fileName();
+ tool->m_fileName = absFileName;
return tool;
}
{
if (m_fileName.isEmpty())
return false;
- QFile file(m_fileName);
- if (!file.open(QIODevice::WriteOnly)) {
- if (errorMessage)
- *errorMessage = tr("Could not write tool specification %1: %2").
- arg(m_fileName, file.errorString());
- return false;
+ Utils::FileSaver saver(m_fileName);
+ if (!saver.hasError()) {
+ QXmlStreamWriter out(saver.file());
+ out.setAutoFormatting(true);
+ out.writeStartDocument(QLatin1String("1.0"));
+ out.writeComment(QString::fromLatin1("Written on %1 by Qt Creator %2")
+ .arg(QDateTime::currentDateTime().toString(), QLatin1String(Constants::IDE_VERSION_LONG)));
+ out.writeStartElement(QLatin1String(kExternalTool));
+ out.writeAttribute(QLatin1String(kId), m_id);
+ out.writeTextElement(QLatin1String(kDescription), m_description);
+ out.writeTextElement(QLatin1String(kDisplayName), m_displayName);
+ out.writeTextElement(QLatin1String(kCategory), m_displayCategory);
+ if (m_order != -1)
+ out.writeTextElement(QLatin1String(kOrder), QString::number(m_order));
+
+ out.writeStartElement(QLatin1String(kExecutable));
+ out.writeAttribute(QLatin1String(kOutput), stringForOutputHandling(m_outputHandling));
+ out.writeAttribute(QLatin1String(kError), stringForOutputHandling(m_errorHandling));
+ out.writeAttribute(QLatin1String(kModifiesDocument), m_modifiesCurrentDocument ? QLatin1String(kYes) : QLatin1String(kNo));
+ foreach (const QString &executable, m_executables)
+ out.writeTextElement(QLatin1String(kPath), executable);
+ if (!m_arguments.isEmpty())
+ out.writeTextElement(QLatin1String(kArguments), m_arguments);
+ if (!m_input.isEmpty())
+ out.writeTextElement(QLatin1String(kInput), m_input);
+ if (!m_workingDirectory.isEmpty())
+ out.writeTextElement(QLatin1String(kWorkingDirectory), m_workingDirectory);
+ out.writeEndElement();
+
+ out.writeEndDocument();
+
+ saver.setResult(&out);
}
- QXmlStreamWriter out(&file);
- out.setAutoFormatting(true);
- out.writeStartDocument(QLatin1String("1.0"));
- out.writeComment(QString::fromLatin1("Written on %1 by Qt Creator %2")
- .arg(QDateTime::currentDateTime().toString(), QLatin1String(Constants::IDE_VERSION_LONG)));
- out.writeStartElement(QLatin1String(kExternalTool));
- out.writeAttribute(QLatin1String(kId), m_id);
- out.writeTextElement(QLatin1String(kDescription), m_description);
- out.writeTextElement(QLatin1String(kDisplayName), m_displayName);
- out.writeTextElement(QLatin1String(kCategory), m_displayCategory);
- if (m_order != -1)
- out.writeTextElement(QLatin1String(kOrder), QString::number(m_order));
-
- out.writeStartElement(QLatin1String(kExecutable));
- out.writeAttribute(QLatin1String(kOutput), stringForOutputHandling(m_outputHandling));
- out.writeAttribute(QLatin1String(kError), stringForOutputHandling(m_errorHandling));
- out.writeAttribute(QLatin1String(kModifiesDocument), m_modifiesCurrentDocument ? QLatin1String(kYes) : QLatin1String(kNo));
- foreach (const QString &executable, m_executables)
- out.writeTextElement(QLatin1String(kPath), executable);
- if (!m_arguments.isEmpty())
- out.writeTextElement(QLatin1String(kArguments), m_arguments);
- if (!m_input.isEmpty())
- out.writeTextElement(QLatin1String(kInput), m_input);
- if (!m_workingDirectory.isEmpty())
- out.writeTextElement(QLatin1String(kWorkingDirectory), m_workingDirectory);
- out.writeEndElement();
-
- out.writeEndDocument();
- file.close();
- return true;
+ return saver.finalize(errorMessage);
}
bool ExternalTool::operator==(const ExternalTool &other) const
#include <coreplugin/icore.h>
#include <coreplugin/messagemanager.h>
#include <utils/qtcassert.h>
+#include <utils/fileutils.h>
#include <texteditor/basetexteditor.h>
#include <QtCore/QtPlugin>
return pattern;
}
-typedef QSharedPointer<QTemporaryFile> TemporaryFilePtr;
-
-// Write an a temporary file.
-TemporaryFilePtr writeTemporaryFile(const QString &namePattern,
- const QString &contents,
- QString *errorMessage)
-{
- TemporaryFilePtr tempFile(new QTemporaryFile(namePattern));
- if (!tempFile->open()) {
- *errorMessage = QString::fromLatin1("Unable to open temporary file %1").arg(tempFile->errorString());
- return TemporaryFilePtr();
- }
- tempFile->write(contents.toUtf8());
- tempFile->close();
- return tempFile;
-}
-
void CodepasterPlugin::finishFetch(const QString &titleDescription,
const QString &content,
bool error)
// for the user and also to be able to tell a patch or diff in the VCS plugins
// by looking at the file name of FileManager::currentFile() without expensive checking.
// Default to "txt".
+ QByteArray byteContent = content.toUtf8();
QString suffix;
- if (const Core::MimeType mimeType = Core::ICore::instance()->mimeDatabase()->findByData(content.toUtf8()))
+ if (const Core::MimeType mimeType = Core::ICore::instance()->mimeDatabase()->findByData(byteContent))
suffix = mimeType.preferredSuffix();
if (suffix.isEmpty())
suffix = QLatin1String("txt");
const QString filePrefix = filePrefixFromTitle(titleDescription);
- QString errorMessage;
- TemporaryFilePtr tempFile = writeTemporaryFile(tempFilePattern(filePrefix, suffix), content, &errorMessage);
- if (tempFile.isNull()) {
- messageManager->printToOutputPane(errorMessage);
+ Utils::TempFileSaver saver(tempFilePattern(filePrefix, suffix));
+ saver.setAutoRemove(false);
+ saver.write(byteContent);
+ if (!saver.finalize()) {
+ messageManager->printToOutputPane(saver.errorString());
return;
}
- // Keep the file and store in list of files to be removed.
- tempFile->setAutoRemove(false);
- const QString fileName = tempFile->fileName();
- // Discard to temporary file to make sure it is closed and no changes are triggered.
- tempFile = TemporaryFilePtr();
+ const QString fileName = saver.fileName();
m_fetchedSnippets.push_back(fileName);
// Open editor with title.
Core::IEditor* editor = EditorManager::instance()->openEditor(fileName, QString(), EditorManager::ModeSwitch);
#include <coreplugin/messageoutputwindow.h>
#include <utils/qtcassert.h>
+#include <utils/fileutils.h>
#include <QtCore/QXmlStreamReader>
#include <QtCore/QXmlStreamAttribute>
const QString &description)
{
// Write out temp XML file
- QTemporaryFile tempFile(m_settings->path + QLatin1Char('/') + QLatin1String(tempPatternC));
- tempFile.setAutoRemove(false);
- if (!tempFile.open()) {
- const QString msg = tr("Unable to open a file for writing in %1: %2").arg(m_settings->path, tempFile.errorString());
- Core::ICore::instance()->messageManager()->printToOutputPanePopup(msg);
+ Utils::TempFileSaver saver(m_settings->path + QLatin1Char('/') + QLatin1String(tempPatternC));
+ saver.setAutoRemove(false);
+ if (!saver.hasError()) {
+ // Flat text sections embedded into pasterElement
+ QXmlStreamWriter writer(saver.file());
+ writer.writeStartDocument();
+ writer.writeStartElement(QLatin1String(pasterElementC));
+
+ writer.writeTextElement(QLatin1String(userElementC), username);
+ writer.writeTextElement(QLatin1String(descriptionElementC), description);
+ writer.writeTextElement(QLatin1String(textElementC), text);
+
+ writer.writeEndElement();
+ writer.writeEndDocument();
+
+ saver.setResult(&writer);
+ }
+ if (!saver.finalize()) {
+ Core::ICore::instance()->messageManager()->printToOutputPanePopup(saver.errorString());
return;
}
- // Flat text sections embedded into pasterElement
- QXmlStreamWriter writer(&tempFile);
- writer.writeStartDocument();
- writer.writeStartElement(QLatin1String(pasterElementC));
-
- writer.writeTextElement(QLatin1String(userElementC), username);
- writer.writeTextElement(QLatin1String(descriptionElementC), description);
- writer.writeTextElement(QLatin1String(textElementC), text);
-
- writer.writeEndElement();
- writer.writeEndDocument();
- tempFile.close();
- const QString msg = tr("Pasted: %1").arg(tempFile.fileName());
+ const QString msg = tr("Pasted: %1").arg(saver.fileName());
Core::ICore::instance()->messageManager()->printToOutputPanePopup(msg);
}
} // namespace CodePaster
#include <extensionsystem/pluginmanager.h>
+#include <utils/fileutils.h>
+
#include <QtCore/QSettings>
#include <QtCore/QDebug>
#include <QtCore/QFile>
void CppFileSettingsWidget::slotEdit()
{
QString path = licenseTemplatePath();
- // Edit existing file with C++
- if (!path.isEmpty()) {
- Core::EditorManager::instance()->openEditor(path, QLatin1String(CppEditor::Constants::CPPEDITOR_ID),
- Core::EditorManager::ModeSwitch);
- return;
- }
- // Pick a file name and write new template, edit with C++
- path = QFileDialog::getSaveFileName(this, tr("Choose Location for New License Template File"));
- if (path.isEmpty())
- return;
- QFile file(path);
- if (!file.open(QIODevice::WriteOnly|QIODevice::Text|QIODevice::Truncate)) {
- QMessageBox::warning(this, tr("Template write error"),
- tr("Cannot write to %1: %2").arg(path, file.errorString()));
- return;
+ if (path.isEmpty()) {
+ // Pick a file name and write new template, edit with C++
+ path = QFileDialog::getSaveFileName(this, tr("Choose Location for New License Template File"));
+ if (path.isEmpty())
+ return;
+ Utils::FileSaver saver(path, QIODevice::Text);
+ saver.write(tr(licenseTemplateTemplate).toUtf8());
+ if (!saver.finalize(this))
+ return;
+ setLicenseTemplatePath(path);
}
- file.write(tr(licenseTemplateTemplate).toUtf8());
- file.close();
- setLicenseTemplatePath(path);
+ // Edit (now) existing file with C++
Core::EditorManager::instance()->openEditor(path, QLatin1String(CppEditor::Constants::CPPEDITOR_ID),
Core::EditorManager::ModeSwitch);
}
#include <find/searchresultwindow.h>
#include <extensionsystem/pluginmanager.h>
#include <utils/filesearch.h>
+#include <utils/fileutils.h>
#include <coreplugin/progressmanager/progressmanager.h>
#include <coreplugin/progressmanager/futureprogress.h>
#include <coreplugin/editormanager/editormanager.h>
if (workingCopy.contains(fileName)) {
return workingCopy.source(fileName);
} else {
- QFile file(fileName);
- if (! file.open(QFile::ReadOnly))
+ Utils::FileReader reader;
+ if (!reader.fetch(fileName)) // ### FIXME error reporting
return QString();
- return QTextStream(&file).readAll(); // ### FIXME
+ return QString::fromLocal8Bit(reader.data()); // ### FIXME encoding
}
}
#include <coreplugin/editormanager/editormanager.h>
#include <coreplugin/vcsmanager.h>
#include <utils/stringutils.h>
+#include <utils/fileutils.h>
#include <utils/qtcassert.h>
#include <QtCore/QDebug>
#include <QtCore/QFileInfo>
#include <QtCore/QTextCodec>
#include <QtCore/QtPlugin>
-#include <QtCore/QTemporaryFile>
#include <QtGui/QAction>
#include <QtGui/QMainWindow>
#include <QtGui/QMenu>
m_commitRepository = workingDir;
// Create a new submit change file containing the submit template
- QTemporaryFile changeTmpFile;
- changeTmpFile.setAutoRemove(false);
- if (!changeTmpFile.open()) {
- VCSBase::VCSBaseOutputWindow::instance()->appendError(tr("Cannot create temporary file: %1").arg(changeTmpFile.errorString()));
- return;
- }
+ Utils::TempFileSaver saver;
+ saver.setAutoRemove(false);
// TODO: Retrieve submit template from
const QString submitTemplate;
- m_commitMessageFileName = changeTmpFile.fileName();
// Create a submit
- changeTmpFile.write(submitTemplate.toUtf8());
- changeTmpFile.flush();
- changeTmpFile.close();
+ saver.write(submitTemplate.toUtf8());
+ if (!saver.finalize()) {
+ VCSBase::VCSBaseOutputWindow::instance()->appendError(saver.errorString());
+ return;
+ }
+ m_commitMessageFileName = saver.fileName();
// Create a submit editor and set file list
CVSSubmitEditor *editor = openCVSSubmitEditor(m_commitMessageFileName);
editor->setCheckScriptWorkingDirectory(m_commitRepository);
#include <utils/styledbar.h>
#include <utils/proxyaction.h>
#include <utils/statuslabel.h>
+#include <utils/fileutils.h>
#include <qml/scriptconsole.h>
tr("Save Debugger Log"), QDir::tempPath());
if (fileName.isEmpty())
return;
- QFile file(fileName);
- if (!file.open(QIODevice::WriteOnly))
- return;
- QTextStream ts(&file);
- ts << m_logWindow->inputContents();
- ts << "\n\n=======================================\n\n";
- ts << m_logWindow->combinedContents();
+ Utils::FileSaver saver(fileName);
+ if (!saver.hasError()) {
+ QTextStream ts(saver.file());
+ ts << m_logWindow->inputContents();
+ ts << "\n\n=======================================\n\n";
+ ts << m_logWindow->combinedContents();
+ saver.setResult(&ts);
+ }
+ saver.finalize(mainWindow());
}
/*! Activates the previous mode when the current mode is the debug mode. */
#include <utils/qtcassert.h>
#include <utils/savedaction.h>
+#include <utils/fileutils.h>
#include <QtCore/QFile>
#include <QtCore/QFileInfo>
PRECONDITION;
if (m_gdbAdapter->dumperHandling() == AbstractGdbAdapter::DumperNotAvailable) {
// Load at least gdb macro based dumpers.
- QFile file(_(":/gdb/gdbmacros.txt"));
- file.open(QIODevice::ReadOnly);
- QByteArray contents = file.readAll();
m_debuggingHelperState = DebuggingHelperLoadTried;
- postCommand(contents);
+ postCommand(Utils::FileReader::fetchQrc(_(":/gdb/gdbmacros.txt")));
return;
}
#include <find/basetextfind.h>
#include <utils/savedaction.h>
+#include <utils/fileutils.h>
namespace Debugger {
namespace Internal {
const QString fileName = QFileDialog::getSaveFileName(parent, tr("Log File"));
if (fileName.isEmpty())
break;
- QFile file(fileName);
- if (file.open(QIODevice::WriteOnly|QIODevice::Text|QIODevice::Truncate)) {
- file.write(editor->toPlainText().toUtf8());
- file.close();
+ Utils::FileSaver saver(fileName, QIODevice::Text);
+ saver.write(editor->toPlainText().toUtf8());
+ if (saver.finalize(parent))
success = true;
- } else {
- QMessageBox::warning(parent, tr("Write Failure"),
- tr("Unable to write log contents to '%1': %2").
- arg(fileName, file.errorString()));
- }
}
return success;
}
#include <projectexplorer/projectexplorer.h>
#include <projectexplorer/session.h>
#include <utils/qtcassert.h>
+#include <utils/fileutils.h>
#include <QtDesigner/QDesignerFormWindowInterface>
#include <QtDesigner/QDesignerFormEditorInterface>
if (workingCopy.contains(fileName)) {
src = workingCopy.source(fileName);
} else {
- QFile file(fileName);
- if (file.open(QFile::ReadOnly))
- src = QTextStream(&file).readAll(); // ### FIXME
+ Utils::FileReader reader;
+ if (reader.fetch(fileName)) // ### FIXME error reporting
+ src = QString::fromLocal8Bit(reader.data()); // ### FIXME encoding
}
QByteArray source = snapshot.preprocessedCode(src, fileName);
#include <extensionsystem/pluginmanager.h>
#include <utils/pathchooser.h>
#include <utils/qtcassert.h>
+#include <utils/fileutils.h>
#include <coreplugin/icore.h>
#include <coreplugin/icontext.h>
bool GenericProject::saveRawFileList(const QStringList &rawFileList)
{
// Make sure we can open the file for writing
- QFile file(filesFileName());
- if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
+ Utils::FileSaver saver(filesFileName(), QIODevice::Text);
+ if (!saver.hasError()) {
+ QTextStream stream(saver.file());
+ foreach (const QString &filePath, rawFileList)
+ stream << filePath << QLatin1Char('\n');
+ saver.setResult(&stream);
+ }
+ if (!saver.finalize(Core::ICore::instance()->mainWindow()))
return false;
-
- QTextStream stream(&file);
- foreach (const QString &filePath, rawFileList)
- stream << filePath << QLatin1Char('\n');
-
- file.close();
refresh(GenericProject::Files);
return true;
}
#include <utils/qtcprocess.h>
#include <utils/synchronousprocess.h>
#include <utils/environment.h>
+#include <utils/fileutils.h>
#include <vcsbase/vcsbaseeditor.h>
#include <vcsbase/vcsbaseoutputwindow.h>
#include <vcsbase/vcsbaseplugin.h>
// Read description
const QString descriptionFile = gitDir.absoluteFilePath(QLatin1String("description"));
if (QFileInfo(descriptionFile).isFile()) {
- QFile file(descriptionFile);
- if (file.open(QIODevice::ReadOnly|QIODevice::Text))
- commitData->panelInfo.description = commandOutputFromLocal8Bit(file.readAll()).trimmed();
+ Utils::FileReader reader;
+ if (!reader.fetch(descriptionFile, QIODevice::Text, errorMessage))
+ return false;
+ commitData->panelInfo.description = commandOutputFromLocal8Bit(reader.data()).trimmed();
}
// Run status. Note that it has exitcode 1 if there are no added files.
const QFileInfo templateFileInfo(templateFilename);
if (templateFileInfo.isRelative())
templateFilename = repoDirectory + QLatin1Char('/') + templateFilename;
- QFile templateFile(templateFilename);
- if (templateFile.open(QIODevice::ReadOnly|QIODevice::Text)) {
- *commitTemplate = QString::fromLocal8Bit(templateFile.readAll());
- } else {
- qWarning("Unable to read commit template %s: %s",
- qPrintable(templateFilename),
- qPrintable(templateFile.errorString()));
- }
+ Utils::FileReader reader;
+ if (!reader.fetch(templateFilename, QIODevice::Text, errorMessage))
+ return false;
+ *commitTemplate = QString::fromLocal8Bit(reader.data());
}
}
return true;
#include <utils/qtcassert.h>
#include <utils/parameteraction.h>
+#include <utils/fileutils.h>
#include <vcsbase/basevcseditorfactory.h>
#include <vcsbase/vcsbaseeditor.h>
qDebug() << Q_FUNC_INFO << data << commitTemplate;
// Start new temp file with message template
- QTemporaryFile changeTmpFile;
- changeTmpFile.setAutoRemove(false);
- if (!changeTmpFile.open()) {
- VCSBase::VCSBaseOutputWindow::instance()->append(tr("Cannot create temporary file: %1").arg(changeTmpFile.errorString()));
+ Utils::TempFileSaver saver;
+ // Keep the file alive, else it removes self and forgets its name
+ saver.setAutoRemove(false);
+ saver.write(commitTemplate.toLocal8Bit());
+ if (!saver.finalize()) {
+ VCSBase::VCSBaseOutputWindow::instance()->append(saver.errorString());
return;
}
- m_commitMessageFileName = changeTmpFile.fileName();
- changeTmpFile.write(commitTemplate.toLocal8Bit());
- changeTmpFile.flush();
- // Keep the file alive, else it removes self and forgets
- // its name
- changeTmpFile.close();
+ m_commitMessageFileName = saver.fileName();
openSubmitEditor(m_commitMessageFileName, data, amend);
}
#include <coreplugin/helpmanager.h>
#include <coreplugin/icore.h>
+#include <utils/fileutils.h>
+
#include <QtCore/QCoreApplication>
#include <QtCore/QSettings>
#include <QtCore/QTextStream>
if (!fileName.endsWith(suffix))
fileName.append(suffix);
- QFile file(fileName);
- if (file.open(QIODevice::WriteOnly)) {
+ Utils::FileSaver saver(fileName);
+ if (!saver.hasError()) {
XbelWriter writer(LocalHelpManager::bookmarkManager().treeBookmarkModel());
- writer.writeToFile(&file);
+ writer.writeToFile(saver.file());
+ saver.setResult(&writer);
+ }
+ if (!saver.finalize()) {
+ m_ui->errorLabel->setVisible(true);
+ m_ui->errorLabel->setText(saver.errorString());
}
}
#include "helpconstants.h"
#include "localhelpmanager.h"
+#include <coreplugin/icore.h>
+
+#include <utils/fileutils.h>
+
#include <QtCore/QFileInfo>
#include <QtCore/QStringBuilder>
-#include <QtCore/QTemporaryFile>
+#include <QtCore/QDir>
#include <QtCore/QUrl>
#include <QtGui/QApplication>
#include <QtGui/QDesktopServices>
+#include <QtGui/QMainWindow>
#include <QtGui/QMouseEvent>
#include <QtHelp/QHelpEngine>
const QString& path = resolvedUrl.path();
if (!canOpenPage(path)) {
- QTemporaryFile tmpTmpFile;
- if (!tmpTmpFile.open())
- return false;
-
- const QString &extension = QFileInfo(path).completeSuffix();
- QFile actualTmpFile(tmpTmpFile.fileName() % QLatin1String(".")
- % extension);
- if (!actualTmpFile.open(QIODevice::ReadWrite | QIODevice::Truncate))
- return false;
-
- actualTmpFile.write(helpEngine.fileData(resolvedUrl));
- actualTmpFile.close();
- return QDesktopServices::openUrl(QUrl(actualTmpFile.fileName()));
+ Utils::TempFileSaver saver(QDir::tempPath()
+ + QLatin1String("/qtchelp_XXXXXX.") + QFileInfo(path).completeSuffix());
+ if (!saver.hasError())
+ saver.write(helpEngine.fileData(resolvedUrl));
+ if (saver.finalize(Core::ICore::instance()->mainWindow()))
+ return QDesktopServices::openUrl(QUrl(saver.fileName()));
}
}
return false;
#include <coreplugin/coreconstants.h>
+#include <utils/fileutils.h>
+
#include <QtCore/QFileInfo>
#include <QtCore/QDataStream>
return *this;
}
-void Macro::load(QString fileName)
+bool Macro::load(QString fileName)
{
if (d->events.count())
- return; // the macro is not empty
+ return true; // the macro is not empty
// Take the current filename if the parameter is null
if (fileName.isNull())
macroEvent.load(stream);
append(macroEvent);
}
+ return true;
}
+ return false;
}
-void Macro::loadHeader(const QString &fileName)
+bool Macro::loadHeader(const QString &fileName)
{
d->fileName = fileName;
QFile file(fileName);
QDataStream stream(&file);
stream >> d->version;
stream >> d->description;
+ return true;
}
+ return false;
}
-void Macro::save(const QString &fileName)
+bool Macro::save(const QString &fileName, QWidget *parent)
{
- QFile file(fileName);
- if (file.open(QFile::WriteOnly)) {
- QDataStream stream(&file);
+ Utils::FileSaver saver(fileName);
+ if (!saver.hasError()) {
+ QDataStream stream(saver.file());
stream << d->version;
stream << d->description;
foreach (const MacroEvent &event, d->events) {
event.save(stream);
}
- d->fileName = fileName;
+ saver.setResult(&stream);
}
+ if (!saver.finalize(parent))
+ return false;
+ d->fileName = fileName;
+ return true;
}
QString Macro::displayName() const
#include <QtCore/QList>
#include <QtCore/QString>
+QT_BEGIN_NAMESPACE
+class QWidget;
+QT_END_NAMESPACE
+
namespace Macros {
class MacroEvent;
~Macro();
Macro& operator=(const Macro& other);
- void load(QString fileName = QString());
- void loadHeader(const QString &fileName);
- void save(const QString &fileName);
+ bool load(QString fileName = QString());
+ bool loadHeader(const QString &fileName);
+ bool save(const QString &fileName, QWidget *parent);
const QString &description() const;
void setDescription(const QString &text);
foreach (const QString &name, files) {
QString fileName = dir.absolutePath() + '/' + name;
Macro *macro = new Macro;
- macro->loadHeader(fileName);
- addMacro(macro);
+ if (macro->loadHeader(fileName))
+ addMacro(macro);
+ else
+ delete macro;
}
}
void MacroManager::MacroManagerPrivate::changeMacroDescription(Macro *macro, const QString &description)
{
- macro->load();
+ if (!macro->load())
+ return;
macro->setDescription(description);
- macro->save(macro->fileName());
+ macro->save(macro->fileName(), Core::ICore::instance()->mainWindow());
// Change shortcut what's this
Core::ICore *core = Core::ICore::instance();
bool MacroManager::MacroManagerPrivate::executeMacro(Macro *macro)
{
- macro->load();
- bool error = false;
+ bool error = !macro->load();
foreach (const MacroEvent ¯oEvent, macro->events()) {
+ if (error)
+ break;
foreach (IMacroHandler *handler, handlers) {
if (handler->canExecuteEvent(macroEvent)) {
if (!handler->executeEvent(macroEvent))
break;
}
}
- if (error)
- break;
}
if (error) {
QString fileName = q->macrosDirectory() + '/' + dialog.name()
+ '.' + Constants::M_EXTENSION;
currentMacro->setDescription(dialog.description());
- currentMacro->save(fileName);
+ currentMacro->save(fileName, mainWindow);
addMacro(currentMacro);
}
}
#include <projectexplorer/projectnodes.h>
#include <utils/pathchooser.h>
+#include <utils/fileutils.h>
#include <utils/qtcassert.h>
#include <QtCore/QFile>
QTC_ASSERT(!path.isEmpty(), return);
QTC_ASSERT(!m_ui->suppressionEdit->toPlainText().trimmed().isEmpty(), return);
- QFile file(path);
- bool opened = file.open(QIODevice::WriteOnly | QIODevice::Append);
- QTC_ASSERT(opened, return);
-
- QTextStream stream(&file);
+ Utils::FileSaver saver(path, QIODevice::Append);
+ QTextStream stream(saver.file());
stream << m_ui->suppressionEdit->toPlainText();
- file.close();
+ saver.setResult(&stream);
+ if (!saver.finalize(this))
+ return;
// add file to project (if there is a project that contains this file on the file system)
ProjectExplorer::SessionManager *session = ProjectExplorer::ProjectExplorerPlugin::instance()->session();
#include <vcsbase/vcsbaseeditorparameterwidget.h>
#include <vcsbase/vcsjobrunner.h>
#include <utils/synchronousprocess.h>
+#include <utils/fileutils.h>
#include <utils/qtcassert.h>
#include <QtCore/QDir>
}
// By now, there is no hgrc file -> create it
- QFile hgrc(workingDirectory.path()+"/.hg/hgrc");
- hgrc.open(QIODevice::WriteOnly);
- hgrc.write(QString("[paths]\ndefault = %1\n").arg(dstLocation).toUtf8());
- hgrc.close();
+ Utils::FileSaver saver(workingDirectory.path()+"/.hg/hgrc");
+ saver.write(QString("[paths]\ndefault = %1\n").arg(dstLocation).toUtf8());
+ if (!saver.finalize()) {
+ VCSBase::VCSBaseOutputWindow::instance()->appendError(saver.errorString());
+ return false;
+ }
// And last update repository
arguments.clear();
#include <utils/qtcassert.h>
#include <utils/synchronousprocess.h>
#include <utils/parameteraction.h>
+#include <utils/fileutils.h>
#include <vcsbase/basevcseditorfactory.h>
#include <vcsbase/basevcssubmiteditorfactory.h>
#include <vcsbase/vcsbaseeditor.h>
#include <QtCore/QDir>
#include <QtCore/QFileInfo>
#include <QtCore/QSettings>
-#include <QtCore/QTemporaryFile>
#include <QtCore/QTextCodec>
#include <QtGui/QAction>
const VCSBase::VCSBasePluginState state = currentState();
QTC_ASSERT(state.hasProject(), return)
- QTemporaryFile changeTmpFile;
- changeTmpFile.setAutoRemove(false);
- if (!changeTmpFile.open()) {
- VCSBase::VCSBaseOutputWindow::instance()->appendError(tr("Cannot create temporary file."));
- cleanCommitMessageFile();
- return;
- }
// Revert all unchanged files.
if (!revertProject(state.currentProjectTopLevel(), perforceRelativeProjectDirectory(state), true))
return;
return;
}
- m_commitMessageFileName = changeTmpFile.fileName();
- changeTmpFile.write(result.stdOut.toAscii());
- changeTmpFile.close();
+ Utils::TempFileSaver saver;
+ saver.setAutoRemove(false);
+ saver.write(result.stdOut.toAscii());
+ if (!saver.finalize()) {
+ VCSBase::VCSBaseOutputWindow::instance()->appendError(saver.errorString());
+ cleanCommitMessageFile();
+ return;
+ }
+ m_commitMessageFileName = saver.fileName();
args.clear();
args << QLatin1String("fstat");
}
// Write extra args to temporary file
-QSharedPointer<QTemporaryFile>
- PerforcePlugin::createTemporaryArgumentFile(const QStringList &extraArgs) const
+QSharedPointer<Utils::TempFileSaver>
+ PerforcePlugin::createTemporaryArgumentFile(const QStringList &extraArgs,
+ QString *errorString) const
{
if (extraArgs.isEmpty())
- return QSharedPointer<QTemporaryFile>();
+ return QSharedPointer<Utils::TempFileSaver>();
// create pattern
if (m_tempFilePattern.isEmpty()) {
m_tempFilePattern = QDir::tempPath();
m_tempFilePattern += QDir::separator();
m_tempFilePattern += QLatin1String("qtc_p4_XXXXXX.args");
}
- QSharedPointer<QTemporaryFile> rc(new QTemporaryFile(m_tempFilePattern));
+ QSharedPointer<Utils::TempFileSaver> rc(new Utils::TempFileSaver(m_tempFilePattern));
rc->setAutoRemove(true);
- if (!rc->open()) {
- qWarning("Could not create temporary file: %s. Appending all file names to command line.",
- qPrintable(rc->errorString()));
- return QSharedPointer<QTemporaryFile>();
- }
const int last = extraArgs.size() - 1;
for (int i = 0; i <= last; i++) {
rc->write(extraArgs.at(i).toLocal8Bit());
if (i != last)
- rc->write("\n");
+ rc->write("\n", 1);
}
- rc->close();
+ if (!rc->finalize(errorString))
+ return QSharedPointer<Utils::TempFileSaver>();
return rc;
}
return invalidConfigResponse;
}
QStringList actualArgs = m_settings.commonP4Arguments(workingDir);
- QSharedPointer<QTemporaryFile> tempFile = createTemporaryArgumentFile(extraArgs);
- if (!tempFile.isNull())
+ QString errorMessage;
+ QSharedPointer<Utils::TempFileSaver> tempFile = createTemporaryArgumentFile(extraArgs, &errorMessage);
+ if (!tempFile.isNull()) {
actualArgs << QLatin1String("-x") << tempFile->fileName();
+ } else if (!errorMessage.isEmpty()) {
+ PerforceResponse tempFailResponse;
+ tempFailResponse.error = true;
+ tempFailResponse.message = errorMessage;
+ return tempFailResponse;
+ }
actualArgs.append(args);
if (flags & CommandToWindow)
return true;
}
// Pipe file into p4 submit -i
- QFile commitMessageFile(m_commitMessageFileName);
- if (!commitMessageFile.open(QIODevice::ReadOnly|QIODevice::Text)) {
- VCSBase::VCSBaseOutputWindow::instance()->appendError(tr("Cannot open temporary file."));
+ Utils::FileReader reader;
+ if (!reader.fetch(m_commitMessageFileName, QIODevice::Text)) {
+ VCSBase::VCSBaseOutputWindow::instance()->appendError(reader.errorString());
return false;
}
- const QByteArray changeDescription = commitMessageFile.readAll();
- commitMessageFile.close();
QStringList submitArgs;
submitArgs << QLatin1String("submit") << QLatin1String("-i");
const PerforceResponse submitResponse = runP4Cmd(m_settings.topLevelSymLinkTarget(), submitArgs,
LongTimeOut|RunFullySynchronous|CommandToWindow|StdErrToWindow|ErrorToWindow|ShowBusyCursor,
- QStringList(), changeDescription);
+ QStringList(), reader.data());
if (submitResponse.error) {
VCSBase::VCSBaseOutputWindow::instance()->appendError(tr("p4 submit failed: %1").arg(submitResponse.message));
return false;
namespace Utils {
class ParameterAction;
+ class TempFileSaver;
}
namespace Locator {
bool enableAnnotationContextMenu = false);
void cleanCommitMessageFile();
bool isCommitEditorOpen() const;
- QSharedPointer<QTemporaryFile> createTemporaryArgumentFile(const QStringList &extraArgs) const;
+ QSharedPointer<Utils::TempFileSaver> createTemporaryArgumentFile(const QStringList &extraArgs,
+ QString *errorString) const;
void getTopLevel();
QString pendingChangesData();
#include <coreplugin/icore.h>
#include <coreplugin/messagemanager.h>
#include <extensionsystem/pluginmanager.h>
+#include <utils/fileutils.h>
#include <utils/qtcassert.h>
#include <QtCore/QDebug>
// Read contents of source file
const QFile::OpenMode openMode
= cwFile.binary ? QIODevice::ReadOnly : (QIODevice::ReadOnly|QIODevice::Text);
- QFile file(sourcePath);
- if (!file.open(openMode)) {
- *errorMessage = QString::fromLatin1("Cannot open %1: %2").arg(sourcePath, file.errorString());
+ Utils::FileReader reader;
+ if (!reader.fetch(sourcePath, openMode, errorMessage))
return false;
- }
- const QByteArray contentData = file.readAll();
- file.close();
Core::GeneratedFile generatedFile;
generatedFile.setPath(targetPath);
if (cwFile.binary) {
// Binary file: Set data.
generatedFile.setBinary(true);
- generatedFile.setBinaryContents(contentData);
+ generatedFile.setBinaryContents(reader.data());
} else {
// Template file: Preprocess.
- const QString contentsIn = QString::fromLocal8Bit(contentData);
+ const QString contentsIn = QString::fromLocal8Bit(reader.data());
generatedFile.setContents(Internal::CustomWizardContext::processFile(fm, contentsIn));
}
#include <projectexplorer/projectexplorer.h>
#include <projectexplorer/projectexplorersettings.h>
+#include <utils/fileutils.h>
#include <utils/qtcprocess.h>
#include <utils/qtcassert.h>
#include <utils/synchronousprocess.h>
"#define __ptr32\n"
"#define __ptr64\n";
- QString tmpFilePath;
- {
- // QTemporaryFile is buggy and will not unlock the file for cl.exe
- QTemporaryFile tmpFile(QDir::tempPath()+"/envtestXXXXXX.cpp");
- tmpFile.setAutoRemove(false);
- if (!tmpFile.open())
- return predefinedMacros;
- tmpFilePath = QFileInfo(tmpFile).canonicalFilePath();
- tmpFile.write(msvcCompilationFile());
- tmpFile.close();
+ Utils::TempFileSaver saver(QDir::tempPath()+"/envtestXXXXXX.cpp");
+ saver.write(msvcCompilationFile());
+ if (!saver.finalize()) {
+ qWarning("%s: %s", Q_FUNC_INFO, qPrintable(saver.errorString()));
+ return predefinedMacros;
}
QProcess cpp;
cpp.setEnvironment(env.toStringList());
return predefinedMacros;
}
- arguments << QLatin1String("/EP") << QDir::toNativeSeparators(tmpFilePath);
+ arguments << QLatin1String("/EP") << QDir::toNativeSeparators(saver.fileName());
cpp.start(binary, arguments);
if (!cpp.waitForStarted()) {
qWarning("%s: Cannot start '%s': %s", Q_FUNC_INFO, qPrintable(binary),
predefinedMacros += '\n';
}
}
- QFile::remove(tmpFilePath);
if (debug)
qDebug() << "msvcPredefinedMacros" << predefinedMacros;
return predefinedMacros;
return result;
const QString tempOutputFileName = QDir::tempPath() + QLatin1String("\\qtcreator-msvc-environment.txt");
- QTemporaryFile tf(QDir::tempPath() + "\\XXXXXX.bat");
- tf.setAutoRemove(true);
- if (!tf.open())
- return result;
-
- const QString filename = tf.fileName();
-
+ Utils::TempFileSaver saver(QDir::tempPath() + "\\XXXXXX.bat");
QByteArray call = "call ";
call += Utils::QtcProcess::quoteArg(varsBat).toLocal8Bit();
if (!args.isEmpty()) {
call += args.toLocal8Bit();
}
call += "\r\n";
- tf.write(call);
+ saver.write(call);
const QByteArray redirect = "set > " + Utils::QtcProcess::quoteArg(
QDir::toNativeSeparators(tempOutputFileName)).toLocal8Bit() + "\r\n";
- tf.write(redirect);
- tf.flush();
- tf.waitForBytesWritten(30000);
+ saver.write(redirect);
+ if (!saver.finalize()) {
+ qWarning("%s: %s", Q_FUNC_INFO, qPrintable(saver.errorString()));
+ return result;
+ }
Utils::QtcProcess run;
run.setEnvironment(env);
const QString cmdPath = QString::fromLocal8Bit(qgetenv("COMSPEC"));
// Windows SDK setup scripts require command line switches for environment expansion.
QString cmdArguments = QLatin1String(" /E:ON /V:ON /c \"");
- cmdArguments += QDir::toNativeSeparators(filename);
+ cmdArguments += QDir::toNativeSeparators(saver.fileName());
cmdArguments += QLatin1Char('"');
run.setCommand(cmdPath, cmdArguments);
if (debug)
Utils::SynchronousProcess::stopProcess(run);
return result;
}
- tf.close();
QFile varsFile(tempOutputFileName);
if (!varsFile.open(QIODevice::ReadOnly|QIODevice::Text))
#include <coreplugin/coreconstants.h>
+#include <utils/fileutils.h>
+
#include <QtCore/QDebug>
#include <QtCore/QFile>
#include <QtCore/QVariant>
m_valueMap.insert(variable, value);
}
-bool PersistentSettingsWriter::save(const QString & fileName, const QString &docType) const
+bool PersistentSettingsWriter::save(const QString & fileName, const QString &docType,
+ QWidget *parent) const
{
- QFile file(fileName);
- if (!file.open(QIODevice::WriteOnly|QIODevice::Text))
- return false;
+ Utils::FileSaver saver(fileName, QIODevice::Text);
+ if (!saver.hasError()) {
+ const Context ctx;
+ QXmlStreamWriter w(saver.file());
+ w.setAutoFormatting(true);
+ w.setAutoFormattingIndent(1); // Historical, used to be QDom.
+ w.writeStartDocument();
+ w.writeDTD(QLatin1String("<!DOCTYPE ") + docType + QLatin1Char('>'));
+ w.writeComment(QString::fromAscii(" Written by Qt Creator %1, %2. ").
+ arg(QLatin1String(Core::Constants::IDE_VERSION_LONG),
+ QDateTime::currentDateTime().toString(Qt::ISODate)));
+ w.writeStartElement(ctx.qtCreatorElement);
+ const QVariantMap::const_iterator cend = m_valueMap.constEnd();
+ for (QVariantMap::const_iterator it = m_valueMap.constBegin(); it != cend; ++it) {
+ w.writeStartElement(ctx.dataElement);
+ w.writeTextElement(ctx.variableElement, it.key());
+ writeVariantValue(w, ctx, it.value());
+ w.writeEndElement();
+ }
+ w.writeEndDocument();
- const Context ctx;
- QXmlStreamWriter w(&file);
- w.setAutoFormatting(true);
- w.setAutoFormattingIndent(1); // Historical, used to be QDom.
- w.writeStartDocument();
- w.writeDTD(QLatin1String("<!DOCTYPE ") + docType + QLatin1Char('>'));
- w.writeComment(QString::fromAscii(" Written by Qt Creator %1, %2. ").
- arg(QLatin1String(Core::Constants::IDE_VERSION_LONG),
- QDateTime::currentDateTime().toString(Qt::ISODate)));
- w.writeStartElement(ctx.qtCreatorElement);
- const QVariantMap::const_iterator cend = m_valueMap.constEnd();
- for (QVariantMap::const_iterator it = m_valueMap.constBegin(); it != cend; ++it) {
- w.writeStartElement(ctx.dataElement);
- w.writeTextElement(ctx.variableElement, it.key());
- writeVariantValue(w, ctx, it.value());
- w.writeEndElement();
+ saver.setResult(&w);
}
- w.writeEndDocument();
- file.close();
- return true;
+ return saver.finalize(parent);
}
} // namespace ProjectExplorer
#include <QtCore/QMap>
#include <QtCore/QVariant>
+QT_BEGIN_NAMESPACE
+class QWidget;
+QT_END_NAMESPACE
+
namespace ProjectExplorer {
class PROJECTEXPLORER_EXPORT PersistentSettingsReader
public:
PersistentSettingsWriter();
void saveValue(const QString & variable, const QVariant &value);
- bool save(const QString & fileName, const QString & docType) const;
+ bool save(const QString &fileName, const QString &docType, QWidget *parent) const;
private:
QMap<QString, QVariant> m_valueMap;
writer.saveValue("valueKeys", keys);
- if (writer.save(m_fileName, "QtCreatorSession"))
+ if (writer.save(m_fileName, "QtCreatorSession", Core::ICore::instance()->mainWindow()))
return true;
return false;
#include <QtCore/QCoreApplication>
#include <QtCore/QDir>
#include <QtCore/QSettings>
+#include <QtGui/QMainWindow>
static const char *const TOOLCHAIN_DATA_KEY = "ToolChain.";
static const char *const TOOLCHAIN_COUNT_KEY = "ToolChain.Count";
}
}
writer.saveValue(QLatin1String(TOOLCHAIN_COUNT_KEY), count);
- writer.save(settingsFileName(), "QtCreatorToolChains");
+ writer.save(settingsFileName(), "QtCreatorToolChains", Core::ICore::instance()->mainWindow());
// Do not save default debuggers! Those are set by the SDK!
}
QString fileName = project->property(USERFILE_PROP).toString();
return writer.save(fileName.isEmpty() ? fileNameFor(project->file()->fileName()) : fileName,
- "QtCreatorProject");
+ "QtCreatorProject", Core::ICore::instance()->mainWindow());
}
void UserFileAccessor::addVersionHandler(UserFileVersionHandler *handler)
#include <formeditorview.h>
#include <lineeditaction.h>
+#include <utils/fileutils.h>
+
namespace QmlDesigner {
FormEditorWidget::FormEditorWidget(FormEditorView *view)
: QWidget(),
m_formEditorView(view)
{
- QFile file(":/qmldesigner/formeditorstylesheet.css");
- file.open(QFile::ReadOnly);
- QString styleSheet = QLatin1String(file.readAll());
- setStyleSheet(styleSheet);
+ setStyleSheet(QLatin1String(Utils::FileReader::fetchQrc(":/qmldesigner/formeditorstylesheet.css")));
QVBoxLayout *fillLayout = new QVBoxLayout(this);
fillLayout->setMargin(0);
m_graphicsView = new FormEditorGraphicsView(this);
fillLayout->addWidget(m_graphicsView.data());
- {
- QFile file(":/qmldesigner/scrollbar.css");
- file.open(QFile::ReadOnly);
- m_graphicsView.data()->setStyleSheet(file.readAll());
- }
+ m_graphicsView.data()->setStyleSheet(
+ QLatin1String(Utils::FileReader::fetchQrc(":/qmldesigner/scrollbar.css")));
QList<QAction*> lowerActions;
#include <variantproperty.h>
#include <rewritingexception.h>
+#include <utils/fileutils.h>
+
#include <QtCore/QCoreApplication>
#include <QtCore/QDir>
#include <QtCore/QFile>
saveAs(parent);
return true;
}
- QFile file(m_d->fileName);
- if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
- showError(tr("Cannot write file: \"%1\".").arg(m_d->fileName), parent);
+ Utils::FileSaver saver(m_d->fileName, QIODevice::Text);
+ if (m_d->model)
+ saver.write(m_d->textEdit->toPlainText().toLatin1());
+ if (!saver.finalize()) {
+ showError(saver.errorString(), parent);
return false;
}
-
- QString errorMessage;
- bool result = save(&file, &errorMessage);
- if (!result)
- showError(errorMessage, parent);
- return result;
-}
-
-bool DesignDocumentController::save(QIODevice *device, QString * /*errorMessage*/)
-{
- if (m_d->model) {
- QByteArray data = m_d->textEdit->toPlainText().toLatin1();
- device->write(data);
+ if (m_d->model)
m_d->textEdit->setPlainText(m_d->textEdit->toPlainText()); // clear undo/redo history
- }
- return false;
+
+ return true;
}
void attachNodeInstanceView();
QWidget *centralWidget() const;
class DesignDocumentControllerPrivate *m_d;
- bool save(QIODevice *device, QString *errorMessage);
};
} // namespace QmlDesigner
#include "itemlibrarywidget.h"
#include <utils/filterlineedit.h>
+#include <utils/fileutils.h>
#include <coreplugin/coreconstants.h>
#include "itemlibrarycomponents.h"
#include "itemlibrarymodel.h"
setSearchFilter(QString());
/* style sheets */
- {
- QFile file(":/qmldesigner/stylesheet.css");
- file.open(QFile::ReadOnly);
- QString styleSheet = QLatin1String(file.readAll());
- setStyleSheet(styleSheet);
- }
-
- {
- QFile file(":/qmldesigner/scrollbar.css");
- file.open(QFile::ReadOnly);
- QString styleSheet = QLatin1String(file.readAll());
- m_d->m_resourcesView->setStyleSheet(styleSheet);
- }
+ setStyleSheet(QLatin1String(Utils::FileReader::fetchQrc(":/qmldesigner/stylesheet.css")));
+ m_d->m_resourcesView->setStyleSheet(
+ QLatin1String(Utils::FileReader::fetchQrc(":/qmldesigner/scrollbar.css")));
}
ItemLibraryWidget::~ItemLibraryWidget()
#include <QtGui/QBoxLayout>
#include <QtGui/QTreeView>
#include <QtGui/QHeaderView>
-#include <QFile>
#include <model.h>
#include "navigatorwidget.h"
+#include <utils/fileutils.h>
+
namespace QmlDesigner {
setWindowTitle(tr("Navigator", "Title of navigator view"));
- {
- QFile file(":/qmldesigner/stylesheet.css");
- file.open(QFile::ReadOnly);
- setStyleSheet(file.readAll());
- }
-
- {
- QFile file(":/qmldesigner/scrollbar.css");
- file.open(QFile::ReadOnly);
- m_treeView->setStyleSheet(file.readAll());
- }
+ setStyleSheet(QLatin1String(Utils::FileReader::fetchQrc(":/qmldesigner/stylesheet.css")));
+ m_treeView->setStyleSheet(
+ QLatin1String(Utils::FileReader::fetchQrc(":/qmldesigner/scrollbar.css")));
}
NavigatorWidget::~NavigatorWidget()
**************************************************************************/
#include "basicwidgets.h"
+#include <utils/fileutils.h>
#include <qlayoutobject.h>
#include <QDeclarativeContext>
#include <QDeclarativeEngine>
fileName = (QLatin1Char(':') + _styleSheetFile.toLocalFile().split(QLatin1Char(':')).last()); //try if it is a resource
else
fileName = (_styleSheetFile.toLocalFile());
- QFile file(fileName);
- if (file.open(QIODevice::ReadOnly)) {
- QString styleSheet(file.readAll());
- q->setStyleSheet(styleSheet);
- } else {
- qWarning() << QString::fromLatin1("setStyleSheetFile: %1: %2").arg(fileName, file.errorString());
- }
+ Utils::FileReader reader;
+ if (reader.fetch(fileName))
+ q->setStyleSheet(QString::fromLatin1(reader.data()));
+ else
+ qWarning() << QString::fromLatin1("setStyleSheetFile: %1").arg(reader.errorString());
}
#include "propertyeditortransaction.h"
#include "originwidget.h"
+#include <utils/fileutils.h>
+
#include <QtCore/QCoreApplication>
#include <QtCore/QDir>
#include <QtCore/QFileSystemWatcher>
m_updateShortcut = new QShortcut(QKeySequence("F5"), m_stackedWidget);
connect(m_updateShortcut, SIGNAL(activated()), this, SLOT(reloadQml()));
- QFile file(":/qmldesigner/stylesheet.css");
- file.open(QFile::ReadOnly);
- QString styleSheet = QLatin1String(file.readAll());
- m_stackedWidget->setStyleSheet(styleSheet);
+ m_stackedWidget->setStyleSheet(
+ QLatin1String(Utils::FileReader::fetchQrc(":/qmldesigner/stylesheet.css")));
m_stackedWidget->setMinimumWidth(300);
m_stackedWidget->move(0, 0);
connect(m_stackedWidget, SIGNAL(resized()), this, SLOT(updateSize()));
#include <extensionsystem/pluginmanager.h>
#include <utils/parameteraction.h>
+#include <utils/fileutils.h>
#include <utils/qtcassert.h>
#include <QtCore/QSettings>
}
if (navigationView.widget)
- {
- QFile file(":/qmldesigner/stylesheet.css");
- file.open(QFile::ReadOnly);
- QFile file2(":/qmldesigner/scrollbar.css");
- file2.open(QFile::ReadOnly);
-
- QString labelStyle = QLatin1String("QLabel { background-color: #4f4f4f; }");
-
- QString styleSheet = file.readAll() + file2.readAll() + labelStyle;
- navigationView.widget->setStyleSheet(styleSheet);
- }
+ navigationView.widget->setStyleSheet(QLatin1String(
+ Utils::FileReader::fetchQrc(":/qmldesigner/stylesheet.css")
+ + Utils::FileReader::fetchQrc(":/qmldesigner/scrollbar.css")
+ + "QLabel { background-color: #4f4f4f; }"));
}
m_nodeInstanceView = new NodeInstanceView(this);
#include "styledoutputpaneplaceholder.h"
+#include <utils/fileutils.h>
+
#include <QtCore/QChildEvent>
#include <QtCore/QFile>
#include <QtGui/QTabWidget>
StyledOutputpanePlaceHolder::StyledOutputpanePlaceHolder(Core::IMode *mode, QSplitter *parent) : Core::OutputPanePlaceHolder(mode, parent)
{
- QFile file(":/qmldesigner/outputpane-style.css");
- file.open(QFile::ReadOnly);
- QFile file2(":/qmldesigner/scrollbar.css");
- file2.open(QFile::ReadOnly);
- m_customStylesheet = file.readAll() + file2.readAll();
- file.close();
- file2.close();
+ m_customStylesheet = QString::fromLatin1(
+ Utils::FileReader::fetchQrc(":/qmldesigner/outputpane-style.css")
+ + Utils::FileReader::fetchQrc(":/qmldesigner/scrollbar.css"));
}
void StyledOutputpanePlaceHolder::childEvent(QChildEvent *event)
#include <projectexplorer/projectexplorer.h>
#include <coreplugin/messagemanager.h>
#include <utils/filesystemwatcher.h>
+#include <utils/fileutils.h>
#include <QtCore/QDir>
return;
const QString &path = plugin.predumpedQmlTypesFilePath();
- QFile libraryQmlTypesFile(path);
- if (!libraryQmlTypesFile.open(QFile::ReadOnly | QFile::Text)) {
- libraryInfo.setDumpStatus(LibraryInfo::DumpError,
- tr("Could not open file '%1' for reading.").arg(path));
+ Utils::FileReader reader;
+ if (!reader.fetch(path, QFile::Text)) {
+ libraryInfo.setDumpStatus(LibraryInfo::DumpError, reader.errorString());
m_modelManager->updateLibraryInfo(plugin.qmldirPath, libraryInfo);
return;
}
- const QByteArray qmlTypeDescriptions = libraryQmlTypesFile.readAll();
- libraryQmlTypesFile.close();
-
QString error;
- const QList<FakeMetaObject::ConstPtr> objectsList = parseHelper(qmlTypeDescriptions, &error);
+ const QList<FakeMetaObject::ConstPtr> objectsList = parseHelper(reader.data(), &error);
if (error.isEmpty()) {
libraryInfo.setMetaObjects(objectsList);
#include <qt4projectmanager/qmldumptool.h>
#include <qt4projectmanager/qtversionmanager.h>
#include <qmljs/qmljsmodelmanagerinterface.h>
+#include <utils/fileutils.h>
#include <utils/filesystemwatcher.h>
if (options & ProjectFile)
delete m_projectItem.data();
if (!m_projectItem) {
- QFile file(m_fileName);
- if (file.open(QFile::ReadOnly)) {
+ Utils::FileReader reader;
+ if (reader.fetch(m_fileName)) {
QDeclarativeComponent *component = new QDeclarativeComponent(&m_engine, this);
- component->setData(file.readAll(), QUrl::fromLocalFile(m_fileName));
+ component->setData(reader.data(), QUrl::fromLocalFile(m_fileName));
if (component->isReady()
&& qobject_cast<QmlProjectItem*>(component->create())) {
m_projectItem = qobject_cast<QmlProjectItem*>(component->create());
messageManager->printToOutputPane(component->errorString(), true);
}
} else {
- messageManager->printToOutputPane(tr("Error while loading project file %1.").arg(m_fileName), true);
+ messageManager->printToOutputPane(tr("QML project: %1").arg(reader.errorString()), true);
}
}
if (m_projectItem) {
#include <coreplugin/basefilewizard.h>
+#include <utils/fileutils.h>
+
#include <cpptools/abstracteditorsupport.h>
#include <QtCore/QFileInfo>
static inline Core::GeneratedFile generateIconFile(const QString &source, const QString &target, QString *errorMessage)
{
// Read out source
- QFile iconFile(source);
- if (!iconFile.open(QIODevice::ReadOnly)) {
- *errorMessage = PluginGenerator::tr("Cannot open icon file %1.").arg(source);
+ Utils::FileReader reader;
+ if (!reader.fetch(source, errorMessage))
return Core::GeneratedFile();
- }
- const QByteArray iconData = iconFile.readAll();
Core::GeneratedFile rc(target);
- rc.setBinaryContents(iconData);
+ rc.setBinaryContents(reader.data());
rc.setBinary(true);
return rc;
}
const SubstitutionMap &substMap,
QString *errorMessage)
{
- QFile tpl(tmpl);
- if (!tpl.open(QIODevice::ReadOnly|QIODevice::Text)) {
- *errorMessage = tr("Cannot open %1: %2").arg(tmpl, tpl.errorString());
+ Utils::FileReader reader;
+ if (!reader.fetch(tmpl, errorMessage))
return QString();
- }
- QString cont = QString::fromUtf8(tpl.readAll());
+ QString cont = QString::fromUtf8(reader.data());
const QChar atChar = QLatin1Char('@');
int offset = 0;
for (;;) {
#include "maemodeviceconfigurations.h"
#include "maemokeydeployer.h"
+#include <utils/fileutils.h>
#include <utils/ssh/sshkeygenerator.h>
#include <QtCore/QDir>
bool saveFile(const QString &filePath, const QByteArray &data)
{
- QFile file(filePath);
- const bool canOpen = file.open(QIODevice::WriteOnly);
- if (canOpen)
- file.write(data);
- if (!canOpen || file.error() != QFile::NoError) {
- QMessageBox::critical(this, tr("Could Not Save File"),
- tr("Failed to save key file %1: %2").arg(filePath, file.errorString()));
+ Utils::FileSaver saver(filePath);
+ saver.write(data);
+ if (!saver.finalize()) {
+ QMessageBox::critical(this, tr("Could Not Save Key File"), saver.errorString());
return false;
}
return true;
#include "maemokeydeployer.h"
#include <utils/ssh/sshremoteprocessrunner.h>
+#include <utils/fileutils.h>
#include <QtCore/QFile>
cleanup();
m_deployProcess = SshRemoteProcessRunner::create(sshParams);
- QFile keyFile(keyFilePath);
- QByteArray key;
- const bool keyFileAccessible = keyFile.open(QIODevice::ReadOnly);
- if (keyFileAccessible)
- key = keyFile.readAll();
- if (!keyFileAccessible || keyFile.error() != QFile::NoError) {
- emit error(tr("Could not read public key file '%1'.").arg(keyFilePath));
+ Utils::FileReader reader;
+ if (!reader.fetch(keyFilePath)) {
+ emit error(tr("Public key error: %1").arg(reader.errorString()));
return;
}
SLOT(handleKeyUploadFinished(int)));
const QByteArray command = "test -d .ssh "
"|| mkdir .ssh && chmod 0700 .ssh && echo '"
- + key + "' >> .ssh/authorized_keys && chmod 0600 .ssh/authorized_keys";
+ + reader.data() + "' >> .ssh/authorized_keys && chmod 0600 .ssh/authorized_keys";
m_deployProcess->run(command);
}
#include "maemodeviceconfigurations.h"
#include <utils/ssh/sshkeygenerator.h>
+#include <utils/fileutils.h>
#include <QtCore/QDir>
#include <QtGui/QApplication>
if (fileName.isEmpty())
return;
- QFile file(fileName);
- const bool canOpen = file.open(QIODevice::WriteOnly);
- if (canOpen)
- file.write(publicKey
+ Utils::FileSaver saver(fileName);
+ saver.write(publicKey
? m_keyGenerator->publicKey()
: m_keyGenerator->privateKey());
- if (!canOpen || file.error() != QFile::NoError) {
- QMessageBox::critical(this, tr("Error writing file"),
- tr("Could not write file '%1':\n %2")
- .arg(fileName, file.errorString()));
- } else if (!publicKey) {
+ if (saver.finalize(this) && !publicKey)
emit privateKeyGenerated(fileName);
- }
}
#include <projectexplorer/projectnodes.h>
#include <projectexplorer/toolchain.h>
#include <qt4projectmanager/qt4project.h>
+#include <utils/fileutils.h>
#include <utils/filesystemwatcher.h>
{
if (QFileInfo(specFilePath()).exists())
return NoActionRequired;
- QSharedPointer<QFile> specFile
- = openFile(specFilePath(), QIODevice::WriteOnly, 0);
- if (!specFile)
- return ActionFailed;
QByteArray initialContent(
"Name: %%name%%\n"
"Summary: <insert short description here>\n"
"# Add post-uninstall scripts here."
);
initialContent.replace("%%name%%", project()->displayName().toUtf8());
- return specFile->write(initialContent) == initialContent.count()
- ? ActionSuccessful : ActionFailed;
+ Utils::FileSaver saver(specFilePath());
+ saver.write(initialContent);
+ return saver.finalize() ? ActionSuccessful : ActionFailed;
}
void AbstractRpmBasedQt4MaemoTarget::handleTargetAddedSpecial()
#include <coreplugin/coreconstants.h>
#include <utils/checkablemessagebox.h>
+#include <utils/fileutils.h>
#include <projectexplorer/buildconfiguration.h>
#include <projectexplorer/buildsteplist.h>
if (keyPath.isEmpty())
return QString();
- QFile file(keyPath);
- if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
+ Utils::FileReader reader;
+ if (!reader.fetch(keyPath, QIODevice::Text)) {
+ emit addOutput(reader.errorString(), BuildStep::ErrorOutput);
return QString();
+ }
//key file is quite small in size
- return QCryptographicHash::hash(file.readAll(),
+ return QCryptographicHash::hash(reader.data(),
QCryptographicHash::Md5).toHex();
}
#include <projectexplorer/buildstep.h>
#include <utils/qtcassert.h>
+#include <utils/fileutils.h>
#include <QtCore/QProcess>
QStringList lines;
ProFile *profile = m_reader->parsedProFile(m_qt4project->rootProjectNode()->path());
- QFile qfile(m_qt4project->rootProjectNode()->path());
- if (qfile.open(QIODevice::ReadOnly | QIODevice::Text)) {
- lines = QString::fromLocal8Bit(qfile.readAll()).split(QLatin1Char('\n'));
- qfile.close();
- while (!lines.isEmpty() && lines.last().isEmpty())
- lines.removeLast();
- } else {
- m_qt4project->proFileParseError(tr("Error while reading .pro file %1: %2").arg(m_qt4project->rootProjectNode()->path(), qfile.errorString()));
+ Utils::FileReader reader;
+ if (!reader.fetch(m_qt4project->rootProjectNode()->path(), QIODevice::Text)) {
+ emit progressReport(reader.errorString(), m_errorColor);
return;
}
+ lines = QString::fromLocal8Bit(reader.data()).split(QLatin1Char('\n'));
+ while (!lines.isEmpty() && lines.last().isEmpty())
+ lines.removeLast();
ProWriter::putVarValues(profile, &lines, QStringList() << values, var,
ProWriter::ReplaceValues | ProWriter::OneLine | ProWriter::AppendOperator,
"symbian");
- if (qfile.open(QIODevice::WriteOnly | QIODevice::Text)) {
- qfile.write(lines.join("\n").toLocal8Bit());
- qfile.close();
- }
+ Utils::FileSaver saver(m_qt4project->rootProjectNode()->path(), QIODevice::Text);
+ saver.write(lines.join("\n").toLocal8Bit());
+ if (!saver.finalize())
+ emit progressReport(saver.errorString(), m_errorColor);
}
void S60PublisherOvi::updateProFile()
#include <utils/qtcassert.h>
#include <utils/stringutils.h>
+#include <utils/fileutils.h>
#include <algorithm>
#include <QtCore/QDebug>
{
QString contents;
{
- QFile qfile(m_projectFilePath);
- if (qfile.open(QIODevice::ReadOnly | QIODevice::Text)) {
- contents = QString::fromLocal8Bit(qfile.readAll());
- qfile.close();
- lines = contents.split(QLatin1Char('\n'));
- while (!lines.isEmpty() && lines.last().isEmpty())
- lines.removeLast();
- } else {
- m_project->proFileParseError(tr("Error while reading .pro file %1: %2")
- .arg(m_projectFilePath, qfile.errorString()));
+ Utils::FileReader reader;
+ if (!reader.fetch(m_projectFilePath, QIODevice::Text)) {
+ m_project->proFileParseError(reader.errorString());
return;
}
+ contents = QString::fromLocal8Bit(reader.data());
+ lines = contents.split(QLatin1Char('\n'));
+ while (!lines.isEmpty() && lines.last().isEmpty())
+ lines.removeLast();
}
ProMessageHandler handler;
void Qt4PriFileNode::save(const QStringList &lines)
{
- QFile qfile(m_projectFilePath);
- if (qfile.open(QIODevice::WriteOnly | QIODevice::Text)) {
- foreach (const QString &str, lines) {
- qfile.write(str.toLocal8Bit());
- qfile.write("\n");
- }
- qfile.close();
+ Utils::FileSaver saver(m_projectFilePath, QIODevice::Text);
+ foreach (const QString &str, lines) {
+ saver.write(str.toLocal8Bit());
+ saver.write("\n", 1);
}
+ saver.finalize(Core::ICore::instance()->mainWindow());
m_project->qt4ProjectManager()->notifyChanged(m_projectFilePath);
}
#include <coreplugin/icore.h>
#endif // CREATORLESSTEST
+#include <utils/fileutils.h>
+
namespace Qt4ProjectManager {
AbstractGeneratedFileInfo::AbstractGeneratedFileInfo()
return QString();
}
+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;
+}
+
QByteArray AbstractMobileApp::generateDesktopFile(QString *errorMessage) const
{
- QFile desktopTemplate(path(DesktopOrigin));
- if (!desktopTemplate.open(QIODevice::ReadOnly)) {
- *errorMessage = QCoreApplication::translate("Qt4ProjectManager::AbstractMobileApp",
- "Could not open desktop file template");
+ QByteArray desktopFileContent;
+ if (!readTemplate(DesktopOrigin, &desktopFileContent, errorMessage))
return QByteArray();
- }
- QByteArray desktopFileContent = desktopTemplate.readAll();
return desktopFileContent.replace("thisApp", projectName().toUtf8());
}
QByteArray AbstractMobileApp::generateMainCpp(QString *errorMessage) const
{
- QFile sourceFile(path(MainCppOrigin));
- if (!sourceFile.open(QIODevice::ReadOnly)) {
- *errorMessage = QCoreApplication::translate("Qt4ProjectManager::AbstractMobileApp",
- "Could not open main.cpp template '%1'.")
- .arg(sourceFile.fileName());
+ QByteArray mainCppInput;
+ if (!readTemplate(MainCppOrigin, &mainCppInput, errorMessage))
return QByteArray();
- }
- QTextStream in(&sourceFile);
+ QTextStream in(&mainCppInput);
QByteArray mainCppContent;
QTextStream out(&mainCppContent, QIODevice::WriteOnly);
QByteArray AbstractMobileApp::generateProFile(QString *errorMessage) const
{
const QChar comment = QLatin1Char('#');
- QFile proFile(path(AppProOrigin));
- if (!proFile.open(QIODevice::ReadOnly)) {
- *errorMessage = QCoreApplication::translate("Qt4ProjectManager::AbstractMobileApp",
- "Could not open project file template '%1'.")
- .arg(proFile.fileName());
+ QByteArray proFileInput;
+ if (!readTemplate(AppProOrigin, &proFileInput, errorMessage))
return QByteArray();
- }
- QTextStream in(&proFile);
+ QTextStream in(&proFileInput);
QByteArray proFileContent;
QTextStream out(&proFileContent, QIODevice::WriteOnly);
const QByteArray data = generateFile(info.fileType, &error);
if (!error.isEmpty())
return false;
- QFile file(info.fileInfo.absoluteFilePath());
- if (!file.open(QIODevice::WriteOnly) || file.write(data) == -1) {
- error = QCoreApplication::translate(
- "Qt4ProjectManager::Internal::QtQuickApp",
- "Could not write file '%1'.").
- arg(QDir::toNativeSeparators(info.fileInfo.canonicalFilePath()));
+ Utils::FileSaver saver(QDir::cleanPath(info.fileInfo.absoluteFilePath()));
+ saver.write(data);
+ if (!saver.finalize(&error))
return false;
- }
}
return true;
}
QByteArray AbstractMobileApp::readBlob(const QString &filePath,
QString *errorMsg) const
{
- QFile sourceFile(filePath);
- if (!sourceFile.open(QIODevice::ReadOnly)) {
- *errorMsg = QCoreApplication::translate("Qt4ProjectManager::AbstractMobileApp",
- "Could not open template file '%1'.").arg(filePath);
+ Utils::FileReader reader;
+ if (!reader.fetch(filePath, errorMsg))
return QByteArray();
- }
- return sourceFile.readAll();
+ return reader.data();
}
QByteArray AbstractMobileApp::generateFile(int fileType,
static void insertParameter(QString &line, const QString ¶meter);
QByteArray readBlob(const QString &filePath, QString *errorMsg) const;
+ bool readTemplate(int fileType, QByteArray *data, QString *errorMessage) const;
QByteArray generateFile(int fileType, QString *errorMessage) const;
QString outputPathBase() const;
#include <extensionsystem/pluginmanager.h>
#include <extensionsystem/invoker.h>
+#include <utils/fileutils.h>
+
#include <QtCore/QDir>
#include <QtCore/QFile>
#include <QtCore/QTextStream>
QString fileName = templatePath;
fileName += QDir::separator();
fileName += templateName;
- QFile inFile(fileName);
- if (!inFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
- *errorMessage = tr("The template file '%1' could not be opened for reading: %2").arg(fileName, inFile.errorString());
+ Utils::FileReader reader;
+ if (!reader.fetch(fileName, QIODevice::Text, errorMessage))
return false;
- }
- QString contents = QString::fromUtf8(inFile.readAll());
+ QString contents = QString::fromUtf8(reader.data());
contents.replace(QLatin1String("%QAPP_INCLUDE%"), QLatin1String("QtGui/QApplication"));
contents.replace(QLatin1String("%INCLUDE%"), params.headerFileName);
#include "ui_mobileappwizardmaemooptionspage.h"
#include "ui_mobileappwizardsymbianoptionspage.h"
#include <coreplugin/coreconstants.h>
+#include <utils/fileutils.h>
#include <QtCore/QTemporaryFile>
#include <QtGui/QDesktopServices>
if (button != QMessageBox::Ok)
return;
iconPixmap = iconPixmap.scaled(iconSize);
- QTemporaryFile tmpFile;
- tmpFile.setAutoRemove(false);
- const char * const format = QFileInfo(icon).suffix().toAscii().data();
- if (!tmpFile.open() || !iconPixmap.save(&tmpFile, format)) {
+ Utils::TempFileSaver saver;
+ saver.setAutoRemove(false);
+ if (!saver.hasError())
+ saver.setResult(iconPixmap.save(
+ saver.file(), QFileInfo(icon).suffix().toAscii().constData()));
+ if (!saver.finalize()) {
QMessageBox::critical(this, tr("File Error"),
- tr("Could not copy icon file."));
+ tr("Could not copy icon file: %1").arg(saver.errorString()));
return;
}
- actualIconPath = tmpFile.fileName();
+ actualIconPath = saver.fileName();
}
m_d->ui.pngIconButton->setIcon(iconPixmap);
#include <coreplugin/icore.h>
#include <coreplugin/editormanager/editormanager.h>
#include <utils/reloadpromptutils.h>
+#include <utils/fileutils.h>
#include <QtCore/QTemporaryFile>
#include <QtCore/QFileInfo>
bool ResourceEditorW::createNew(const QString &contents)
{
- QTemporaryFile tempFile(0);
- tempFile.setAutoRemove(true);
- if (!tempFile.open())
+ Utils::TempFileSaver saver;
+ saver.write(contents.toUtf8());
+ if (!saver.finalize(Core::ICore::instance()->mainWindow()))
return false;
- const QString tempFileName = tempFile.fileName();
- tempFile.write(contents.toUtf8());
- tempFile.close();
- const bool rc = m_resourceEditor->load(tempFileName);
+ const bool rc = m_resourceEditor->load(saver.fileName());
m_resourceEditor->setFileName(QString());
if (debugResourceEditorW)
- qDebug() << "ResourceEditorW::createNew: " << contents << " (" << tempFileName << ") returns " << rc;
+ qDebug() << "ResourceEditorW::createNew: " << contents << " (" << saver.fileName() << ") returns " << rc;
return rc;
}
#include <vcsbase/vcsbaseeditorparameterwidget.h>
#include <utils/synchronousprocess.h>
#include <utils/parameteraction.h>
+#include <utils/fileutils.h>
#include <coreplugin/icore.h>
#include <coreplugin/coreconstants.h>
}
m_commitRepository = workingDir;
// Create a new submit change file containing the submit template
- QTemporaryFile changeTmpFile;
- changeTmpFile.setAutoRemove(false);
- if (!changeTmpFile.open()) {
- VCSBase::VCSBaseOutputWindow::instance()->appendError(tr("Cannot create temporary file: %1").arg(changeTmpFile.errorString()));
- return;
- }
- m_commitMessageFileName = changeTmpFile.fileName();
- // TODO: Regitctrieve submit template from
+ Utils::TempFileSaver saver;
+ saver.setAutoRemove(false);
+ // TODO: Retrieve submit template from
const QString submitTemplate;
// Create a submit
- changeTmpFile.write(submitTemplate.toUtf8());
- changeTmpFile.flush();
- changeTmpFile.close();
+ saver.write(submitTemplate.toUtf8());
+ if (!saver.finalize()) {
+ VCSBase::VCSBaseOutputWindow::instance()->appendError(saver.errorString());
+ return;
+ }
+ m_commitMessageFileName = saver.fileName();
// Create a submit editor and set file list
SubversionSubmitEditor *editor = openSubversionSubmitEditor(m_commitMessageFileName);
editor->setStatusList(statusOutput);
#include <texteditor/itexteditor.h>
#include <texteditor/basetexteditor.h>
#include <utils/stylehelper.h>
+#include <utils/fileutils.h>
#include <QtCore/QDebug>
#include <QtCore/QDirIterator>
#include <QtGui/QCheckBox>
#include <QtGui/QComboBox>
#include <QtGui/QLabel>
+#include <QtGui/QMainWindow>
#include <QtGui/QPushButton>
#include <QtGui/QTextBlock>
applyChanges(textEditor->document(), text, changeItems);
tc.endEditBlock();
} else {
- QFile file(fileName);
-
- if (file.open(QFile::ReadOnly)) {
- QTextStream stream(&file);
- // ### set the encoding
- const QString plainText = stream.readAll();
- file.close();
-
+ Utils::FileReader reader;
+ if (reader.fetch(fileName, Core::ICore::instance()->mainWindow())) {
QTextDocument doc;
- doc.setPlainText(plainText);
+ // ### set the encoding
+ doc.setPlainText(QString::fromLocal8Bit(reader.data()));
applyChanges(&doc, text, changeItems);
- QFile newFile(fileName);
- if (newFile.open(QFile::WriteOnly)) {
- QTextStream stream(&newFile);
+ Utils::FileSaver saver(fileName);
+ if (!saver.hasError()) {
+ QTextStream stream(saver.file());
// ### set the encoding
stream << doc.toPlainText();
+ saver.setResult(&stream);
}
+ saver.finalize(Core::ICore::instance()->mainWindow());
}
}
}
#include "texteditorconstants.h"
+#include <utils/fileutils.h>
+
#include <QtCore/QFile>
#include <QtCore/QCoreApplication>
#include <QtXml/QXmlStreamWriter>
m_formats.clear();
}
-bool ColorScheme::save(const QString &fileName) const
+bool ColorScheme::save(const QString &fileName, QWidget *parent) const
{
- QFile file(fileName);
- if (!file.open(QIODevice::WriteOnly))
- return false;
+ Utils::FileSaver saver(fileName);
+ if (!saver.hasError()) {
+ QXmlStreamWriter w(saver.file());
+ w.setAutoFormatting(true);
+ w.setAutoFormattingIndent(2);
+
+ w.writeStartDocument();
+ w.writeStartElement(QLatin1String("style-scheme"));
+ w.writeAttribute(QLatin1String("version"), QLatin1String("1.0"));
+ if (!m_displayName.isEmpty())
+ w.writeAttribute(QLatin1String("name"), m_displayName);
+
+ QMapIterator<QString, Format> i(m_formats);
+ while (i.hasNext()) {
+ const Format &format = i.next().value();
+ w.writeStartElement(QLatin1String("style"));
+ w.writeAttribute(QLatin1String("name"), i.key());
+ if (format.foreground().isValid())
+ w.writeAttribute(QLatin1String("foreground"), format.foreground().name().toLower());
+ if (format.background().isValid())
+ w.writeAttribute(QLatin1String("background"), format.background().name().toLower());
+ if (format.bold())
+ w.writeAttribute(QLatin1String("bold"), QLatin1String(trueString));
+ if (format.italic())
+ w.writeAttribute(QLatin1String("italic"), QLatin1String(trueString));
+ w.writeEndElement();
+ }
- QXmlStreamWriter w(&file);
- w.setAutoFormatting(true);
- w.setAutoFormattingIndent(2);
-
- w.writeStartDocument();
- w.writeStartElement(QLatin1String("style-scheme"));
- w.writeAttribute(QLatin1String("version"), QLatin1String("1.0"));
- if (!m_displayName.isEmpty())
- w.writeAttribute(QLatin1String("name"), m_displayName);
-
- QMapIterator<QString, Format> i(m_formats);
- while (i.hasNext()) {
- const Format &format = i.next().value();
- w.writeStartElement(QLatin1String("style"));
- w.writeAttribute(QLatin1String("name"), i.key());
- if (format.foreground().isValid())
- w.writeAttribute(QLatin1String("foreground"), format.foreground().name().toLower());
- if (format.background().isValid())
- w.writeAttribute(QLatin1String("background"), format.background().name().toLower());
- if (format.bold())
- w.writeAttribute(QLatin1String("bold"), QLatin1String(trueString));
- if (format.italic())
- w.writeAttribute(QLatin1String("italic"), QLatin1String(trueString));
w.writeEndElement();
- }
+ w.writeEndDocument();
- w.writeEndElement();
- w.writeEndDocument();
-
- return true;
+ saver.setResult(&w);
+ }
+ return saver.finalize(parent);
}
namespace {
#include <QtCore/QString>
#include <QtGui/QColor>
+QT_BEGIN_NAMESPACE
+class QWidget;
+QT_END_NAMESPACE
+
namespace TextEditor {
/*! Format for a particular piece of text (text/comment, etc). */
void clear();
- bool save(const QString &fileName) const;
+ bool save(const QString &fileName, QWidget *parent) const;
bool load(const QString &fileName);
inline bool equals(const ColorScheme &cs) const
#include <QtCore/QCoreApplication>
#include <QtGui/QTextCharFormat>
#include <QtGui/QFont>
+#include <QtGui/QMainWindow>
static const char *fontFamilyKey = "FontFamily";
static const char *fontSizeKey = "FontSize";
bool FontSettings::saveColorScheme(const QString &fileName)
{
- const bool saved = m_scheme.save(fileName);
+ const bool saved = m_scheme.save(fileName, Core::ICore::instance()->mainWindow());
if (saved)
m_schemeFileName = fileName;
return saved;
#include <QtGui/QInputDialog>
#include <QtGui/QListWidget>
#include <QtGui/QMessageBox>
+#include <QtGui/QMainWindow>
#include <QtGui/QPalette>
#include <QtGui/QTextCharFormat>
#include <QtGui/QTextEdit>
ColorScheme scheme = d_ptr->m_value.colorScheme();
scheme.setDisplayName(name);
- scheme.save(fileName);
- d_ptr->m_value.setColorSchemeFileName(fileName);
+ if (scheme.save(fileName, Core::ICore::instance()->mainWindow()))
+ d_ptr->m_value.setColorSchemeFileName(fileName);
refreshColorSchemeList();
}
if (messageBox->exec() == QMessageBox::Save) {
const ColorScheme &scheme = d_ptr->m_ui->schemeEdit->colorScheme();
- scheme.save(d_ptr->m_value.colorSchemeFileName());
+ scheme.save(d_ptr->m_value.colorSchemeFileName(), Core::ICore::instance()->mainWindow());
}
}
// Update the scheme and save it under the name it already has
d_ptr->m_value.setColorScheme(d_ptr->m_ui->schemeEdit->colorScheme());
const ColorScheme &scheme = d_ptr->m_value.colorScheme();
- scheme.save(d_ptr->m_value.colorSchemeFileName());
+ scheme.save(d_ptr->m_value.colorSchemeFileName(), Core::ICore::instance()->mainWindow());
}
int index = d_ptr->m_ui->schemeComboBox->currentIndex();
#include "definitiondownloader.h"
+#include <utils/fileutils.h>
+
#include <QtCore/QLatin1Char>
#include <QtCore/QEventLoop>
#include <QtCore/QFile>
const QString &urlPath = m_url.path();
const QString &fileName =
urlPath.right(urlPath.length() - urlPath.lastIndexOf(QLatin1Char('/')) - 1);
- QFile file(m_localPath + fileName);
- if (file.open(QIODevice::Text | QIODevice::WriteOnly)) {
- file.write(reply->readAll());
- file.close();
- m_status = Ok;
- } else {
- m_status = WriteError;
- }
+ Utils::FileSaver saver(m_localPath + fileName, QIODevice::Text);
+ saver.write(reply->readAll());
+ m_status = saver.finalize() ? Ok: WriteError;
}
DefinitionDownloader::Status DefinitionDownloader::status() const
#include "refactoringchanges.h"
#include "basetexteditor.h"
+#include <coreplugin/icore.h>
#include <coreplugin/editormanager/editormanager.h>
#include <extensionsystem/pluginmanager.h>
+#include <utils/fileutils.h>
+
#include <QtCore/QFile>
#include <QtCore/QSet>
+#include <QtGui/QMainWindow>
#include <QtGui/QTextBlock>
#include <QtGui/QTextCursor>
#include <QtGui/QTextDocument>
}
if (!editor) {
- QFile file(fileName);
- file.open(QFile::WriteOnly);
- file.write(document->toPlainText().toUtf8());
+ Utils::FileSaver saver(fileName);
+ saver.write(document->toPlainText().toUtf8());
delete document;
+ if (!saver.finalize(Core::ICore::instance()->mainWindow()))
+ return false;
}
fileChanged(fileName);
// if this document doesn't have an editor, write the result to a file
if (!m_editor && !m_fileName.isEmpty()) {
- const QByteArray &newContents = doc->toPlainText().toUtf8();
- QFile file(m_fileName);
- file.open(QFile::WriteOnly);
- file.write(newContents);
+ Utils::FileSaver saver(m_fileName);
+ saver.write(doc->toPlainText().toUtf8());
+ saver.finalize(Core::ICore::instance()->mainWindow());
}
if (!m_fileName.isEmpty())
else if (!m_document) {
QString fileContents;
if (!m_fileName.isEmpty()) {
- QFile file(m_fileName);
- if (file.open(QIODevice::ReadOnly))
- fileContents = file.readAll();
+ Utils::FileReader reader;
+ if (reader.fetch(m_fileName, Core::ICore::instance()->mainWindow()))
+ fileContents = QString::fromUtf8(reader.data());
}
m_document = new QTextDocument(fileContents);
}
#include <coreplugin/icore.h>
#include <extensionsystem/pluginmanager.h>
+#include <utils/fileutils.h>
#include <QtCore/QLatin1String>
#include <QtCore/QFile>
insertSnippet(snippet);
}
-void SnippetsCollection::synchronize()
+bool SnippetsCollection::synchronize(QString *errorString)
{
- if (QFile::exists(m_userSnippetsPath) || QDir().mkpath(m_userSnippetsPath)) {
- QFile file(m_userSnippetsPath + m_userSnippetsFile);
- if (file.open(QFile::WriteOnly | QFile::Truncate)) {
- QXmlStreamWriter writer(&file);
- writer.setAutoFormatting(true);
- writer.writeStartDocument();
- writer.writeStartElement(kSnippets);
- foreach (const QString &groupId, m_groupIndexById.keys()) {
- const int size = m_snippets.at(groupIndex(groupId)).size();
- for (int i = 0; i < size; ++i) {
- const Snippet ¤t = snippet(i, groupId);
- if (!current.isBuiltIn() || current.isRemoved() || current.isModified())
- writeSnippetXML(current, &writer);
- }
+ if (!QFile::exists(m_userSnippetsPath) && !QDir().mkpath(m_userSnippetsPath)) {
+ *errorString = tr("Cannot create user snippet directory %1").arg(
+ QDir::toNativeSeparators(m_userSnippetsPath));
+ return false;
+ }
+ Utils::FileSaver saver(m_userSnippetsPath + m_userSnippetsFile);
+ if (!saver.hasError()) {
+ QXmlStreamWriter writer(saver.file());
+ writer.setAutoFormatting(true);
+ writer.writeStartDocument();
+ writer.writeStartElement(kSnippets);
+ foreach (const QString &groupId, m_groupIndexById.keys()) {
+ const int size = m_snippets.at(groupIndex(groupId)).size();
+ for (int i = 0; i < size; ++i) {
+ const Snippet ¤t = snippet(i, groupId);
+ if (!current.isBuiltIn() || current.isRemoved() || current.isModified())
+ writeSnippetXML(current, &writer);
}
- writer.writeEndElement();
- writer.writeEndDocument();
- file.close();
}
+ writer.writeEndElement();
+ writer.writeEndDocument();
+
+ saver.setResult(&writer);
}
+ if (!saver.finalize(errorString))
+ return false;
reload();
+ return true;
}
void SnippetsCollection::writeSnippetXML(const Snippet &snippet, QXmlStreamWriter *writer) const
QList<QString> groupIds() const;
void reload();
- void synchronize();
+ bool synchronize(QString *errorString);
private slots:
void identifyGroups();
#include <QtCore/QTextStream>
#include <QtCore/QHash>
#include <QtGui/QMessageBox>
+#include <QtGui/QMainWindow>
namespace TextEditor {
namespace Internal {
setSnippetContent();
if (m_snippetsCollectionChanged) {
- SnippetsCollection::instance()->synchronize();
- m_snippetsCollectionChanged = false;
+ QString errorString;
+ if (SnippetsCollection::instance()->synchronize(&errorString))
+ m_snippetsCollectionChanged = false;
+ else
+ QMessageBox::critical(Core::ICore::instance()->mainWindow(),
+ tr("Error While Saving Snippet Collection"), errorString);
}
}
#include "nicknamedialog.h"
#include "ui_nicknamedialog.h"
+#include <utils/fileutils.h>
+
#include <QtCore/QDebug>
#include <QtCore/QFile>
#include <QtCore/QDir>
model->removeRows(0, rowCount);
if (fileName.isEmpty())
return true;
- QFile file(fileName);
- if (!file.open(QIODevice::ReadOnly|QIODevice::Text)) {
- *errorMessage = tr("Cannot open '%1': %2").
- arg(QDir::toNativeSeparators(fileName), file.errorString());
+ Utils::FileReader reader;
+ if (!reader.fetch(fileName, QIODevice::Text, errorMessage))
return false;
- }
// Split into lines and read
NickNameEntry entry;
- const QStringList lines = QString::fromUtf8(file.readAll()).trimmed().split(QLatin1Char('\n'));
+ 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))) {
void VCSBaseSubmitEditor::createUserFields(const QString &fieldConfigFile)
{
- QFile fieldFile(fieldConfigFile);
- if (!fieldFile.open(QIODevice::ReadOnly|QIODevice::Text)) {
- qWarning("%s: Unable to open %s: %s", Q_FUNC_INFO, qPrintable(fieldConfigFile), qPrintable(fieldFile.errorString()));
+ Utils::FileReader reader;
+ if (!reader.fetch(fieldConfigFile, QIODevice::Text, Core::ICore::instance()->mainWindow()))
return;
- }
// Parse into fields
- const QStringList fields = fieldTexts(QString::fromUtf8(fieldFile.readAll()));
+ const QStringList fields = fieldTexts(QString::fromUtf8(reader.data()));
if (fields.empty())
return;
// Create a completer on user names
if (!tempFilePattern.endsWith(QDir::separator()))
tempFilePattern += QDir::separator();
tempFilePattern += QLatin1String("msgXXXXXX.txt");
- QTemporaryFile messageFile(tempFilePattern);
- messageFile.setAutoRemove(true);
- if (!messageFile.open()) {
- *errorMessage = tr("Unable to open '%1': %2").
- arg(QDir::toNativeSeparators(messageFile.fileName()),
- messageFile.errorString());
+ Utils::TempFileSaver saver(tempFilePattern);
+ saver.write(fileContents().toUtf8());
+ if (!saver.finalize(errorMessage))
return false;
- }
- const QString messageFileName = messageFile.fileName();
- messageFile.write(fileContents().toUtf8());
- messageFile.close();
// Run check process
VCSBaseOutputWindow *outputWindow = VCSBaseOutputWindow::instance();
outputWindow->appendCommand(msgCheckScript(m_d->m_checkScriptWorkingDirectory, checkScript));
QProcess checkProcess;
if (!m_d->m_checkScriptWorkingDirectory.isEmpty())
checkProcess.setWorkingDirectory(m_d->m_checkScriptWorkingDirectory);
- checkProcess.start(checkScript, QStringList(messageFileName));
+ checkProcess.start(checkScript, QStringList(saver.fileName()));
checkProcess.closeWriteChannel();
if (!checkProcess.waitForStarted()) {
*errorMessage = tr("The check script '%1' could not be started: %2").arg(checkScript, checkProcess.errorString());
OSDN Git Service
