qtextdocumentwriter.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qtextdocumentwriter.h"
 
#include <QtCore/qfile.h>
#include <QtCore/qbytearray.h>
#include <QtCore/qfileinfo.h>
#include <QtCore/qtextstream.h>
#include <QtCore/qdebug.h>
#include "qtextdocument.h"
#include "qtextdocumentfragment.h"
 
#include "qtextdocumentfragment_p.h"
#include "qtextodfwriter_p.h"
#if QT_CONFIG(textmarkdownwriter)
#include "qtextmarkdownwriter_p.h"
#endif
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
class QTextDocumentWriterPrivate
{
public:
    QTextDocumentWriterPrivate(QTextDocumentWriter* qq);
 
    // device
    QByteArray format;
    QIODevice *device;
    bool deleteDevice;
 
    QTextDocumentWriter *q;
};
 
QTextDocumentWriterPrivate::QTextDocumentWriterPrivate(QTextDocumentWriter *qq)
    : device(nullptr),
    deleteDevice(false),
    q(qq)
{
}
 
QTextDocumentWriter::QTextDocumentWriter()
    : d(new QTextDocumentWriterPrivate(this))
{
}
 
QTextDocumentWriter::QTextDocumentWriter(QIODevice *device, const QByteArray &format)
    : d(new QTextDocumentWriterPrivate(this))
{
    d->device = device;
    d->format = format;
}
 
QTextDocumentWriter::QTextDocumentWriter(const QString &fileName, const QByteArray &format)
    : QTextDocumentWriter(new QFile(fileName), format)
{
    d->deleteDevice = true;
}
 
QTextDocumentWriter::~QTextDocumentWriter()
{
    if (d->deleteDevice)
        delete d->device;
    delete d;
}
 
void QTextDocumentWriter::setFormat (const QByteArray &format)
{
    d->format = format;
}
 
QByteArray QTextDocumentWriter::format () const
{
    return d->format;
}
 
void QTextDocumentWriter::setDevice (QIODevice *device)
{
    if (d->device && d->deleteDevice)
        delete d->device;
 
    d->device = device;
    d->deleteDevice = false;
}
 
QIODevice *QTextDocumentWriter::device () const
{
    return d->device;
}
 
void QTextDocumentWriter::setFileName (const QString &fileName)
{
    setDevice(new QFile(fileName));
    d->deleteDevice = true;
}
 
QString QTextDocumentWriter::fileName () const
{
    QFile *file = qobject_cast<QFile *>(d->device);
    return file ? file->fileName() : QString();
}
 
bool QTextDocumentWriter::write(const QTextDocument *document)
{
    if (!d->device)
        return false;
 
    QByteArray suffix;
    if (d->format.isEmpty()) {
        // if there's no format, see if device is a file, and if so, find
        // the file suffix
        if (QFile *file = qobject_cast<QFile *>(d->device))
            suffix = QFileInfo(file->fileName()).suffix().toLower().toLatin1();
    }
 
    QByteArray format = !d->format.isEmpty() ? d->format.toLower() : suffix;
 
#ifndef QT_NO_TEXTODFWRITER
    if (format == "odf" || format == "opendocumentformat" || format == "odt") {
        QTextOdfWriter writer(*document, d->device);
        return writer.writeAll();
    }
#endif // QT_NO_TEXTODFWRITER
 
#if QT_CONFIG(textmarkdownwriter)
    if (format == "md" || format == "mkd" || format == "markdown") {
        if (!d->device->isWritable() && !d->device->open(QIODevice::WriteOnly)) {
            qWarning("QTextDocumentWriter::write: the device can not be opened for writing");
            return false;
        }
        QTextStream s(d->device);
        QTextMarkdownWriter writer(s, QTextDocument::MarkdownDialectGitHub);
        return writer.writeAll(document);
    }
#endif // textmarkdownwriter
 
#ifndef QT_NO_TEXTHTMLPARSER
    if (format == "html" || format == "htm") {
        if (!d->device->isWritable() && ! d->device->open(QIODevice::WriteOnly)) {
            qWarning("QTextDocumentWriter::write: the device cannot be opened for writing");
            return false;
        }
        d->device->write(document->toHtml().toUtf8());
        d->device->close();
        return true;
    }
#endif
    if (format == "txt" || format == "plaintext") {
        if (!d->device->isWritable() && ! d->device->open(QIODevice::WriteOnly)) {
            qWarning("QTextDocumentWriter::write: the device cannot be opened for writing");
            return false;
        }
        d->device->write(document->toPlainText().toUtf8());
        d->device->close();
        return true;
    }
 
    return false;
}
 
bool QTextDocumentWriter::write(const QTextDocumentFragment &fragment)
{
    if (fragment.d == nullptr)
        return false; // invalid fragment.
    QTextDocument *doc = fragment.d->doc;
    if (doc)
        return write(doc);
    return false;
}
 
QList<QByteArray> QTextDocumentWriter::supportedDocumentFormats()
{
    QList<QByteArray> answer;
    answer << "plaintext";
 
#ifndef QT_NO_TEXTHTMLPARSER
    answer << "HTML";
#endif
#ifndef QT_NO_TEXTODFWRITER
    answer << "ODF";
#endif // QT_NO_TEXTODFWRITER
#if QT_CONFIG(textmarkdownwriter)
    answer << "markdown";
#endif
 
    std::sort(answer.begin(), answer.end());
    return answer;
}
 
QT_END_NAMESPACE