qquicktextdocument.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 "qquicktextdocument.h"
#include "qquicktextdocument_p.h"
 
#include "qquicktextedit_p.h"
 
#include <QtQml/qqmlcontext.h>
#include <QtQml/qqmlfile.h>
#include <QtQml/qqmlinfo.h>
#include <QtQuick/private/qquickpixmap_p.h>
 
#include <QtCore/qfile.h>
#include <QtCore/qpointer.h>
 
QT_BEGIN_NAMESPACE
 
Q_LOGGING_CATEGORY(lcTextDoc, "qt.quick.textdocument")
 
using namespace Qt::StringLiterals;
 
QQuickTextDocument::QQuickTextDocument(QQuickItem *parent)
    : QObject(*(new QQuickTextDocumentPrivate), parent)
{
    Q_D(QQuickTextDocument);
    Q_ASSERT(parent);
    d->editor = qobject_cast<QQuickTextEdit *>(parent);
    Q_ASSERT(d->editor);
    connect(textDocument(), &QTextDocument::modificationChanged,
            this, &QQuickTextDocument::modifiedChanged);
}
 
QQuickTextDocument::Status QQuickTextDocument::status() const
{
    Q_D(const QQuickTextDocument);
    return d->status;
}
 
QString QQuickTextDocument::errorString() const
{
    Q_D(const QQuickTextDocument);
    return d->errorString;
}
 
void QQuickTextDocumentPrivate::setStatus(QQuickTextDocument::Status s, const QString &err)
{
    Q_Q(QQuickTextDocument);
    if (status == s)
        return;
 
    status = s;
    emit q->statusChanged();
 
    if (errorString == err)
        return;
    errorString = err;
    emit q->errorStringChanged();
    if (!err.isEmpty())
        qmlWarning(q) << err;
}
 
QUrl QQuickTextDocument::source() const
{
    Q_D(const QQuickTextDocument);
    return d->url;
}
 
void QQuickTextDocument::setSource(const QUrl &url)
{
    Q_D(QQuickTextDocument);
 
    if (url == d->url)
        return;
 
    if (isModified()) {
        qmlWarning(this) << "Existing document modified: you should save(),"
                            "or call TextEdit.clear() before setting a different source";
        return;
    }
 
    d->url = url;
    emit sourceChanged();
    d->load();
}
 
bool QQuickTextDocument::isModified() const
{
    const auto *doc = textDocument();
    return doc && doc->isModified();
}
 
void QQuickTextDocument::setModified(bool modified)
{
    if (auto *doc = textDocument())
        doc->setModified(modified);
}
 
void QQuickTextDocumentPrivate::load()
{
    auto *doc = editor->document();
    if (!doc) {
        setStatus(QQuickTextDocument::Status::ReadError,
                  QQuickTextDocument::tr("Null document object: cannot load"));
        return;
    }
    const QQmlContext *context = qmlContext(editor);
    const QUrl &resolvedUrl = context ? context->resolvedUrl(url) : url;
    const QString filePath = QQmlFile::urlToLocalFileOrQrc(resolvedUrl);
    QFile file(filePath);
    if (file.exists()) {
#if QT_CONFIG(mimetype)
        QMimeType mimeType = QMimeDatabase().mimeTypeForFile(filePath);
        const bool isHtml = mimeType.inherits("text/html"_L1);
        const bool isMarkdown = mimeType.inherits("text/markdown"_L1);
#else
        const bool isHtml = filePath.endsWith(".html"_L1, Qt::CaseInsensitive) ||
                filePath.endsWith(".htm"_L1, Qt::CaseInsensitive);
        const bool isMarkdown = filePath.endsWith(".md"_L1, Qt::CaseInsensitive) ||
                filePath.endsWith(".markdown"_L1, Qt::CaseInsensitive);
#endif
        if (isHtml)
            detectedFormat = Qt::RichText;
        else if (isMarkdown)
            detectedFormat = Qt::MarkdownText;
        else
            detectedFormat = Qt::PlainText;
        if (file.open(QFile::ReadOnly | QFile::Text)) {
            setStatus(QQuickTextDocument::Status::Loading, {});
            QByteArray data = file.readAll();
            doc->setBaseUrl(resolvedUrl.adjusted(QUrl::RemoveFilename));
#if QT_CONFIG(textmarkdownreader) || QT_CONFIG(texthtmlparser)
            const bool plainText = editor->textFormat() == QQuickTextEdit::PlainText;
#endif
#if QT_CONFIG(textmarkdownreader)
            if (!plainText && isMarkdown) {
                doc->setMarkdown(QString::fromUtf8(data));
            } else
#endif
#if QT_CONFIG(texthtmlparser)
            if (!plainText && isHtml) {
                // If a user loads an HTML file, remember the encoding.
                // If the user then calls save() later, the same encoding will be used.
                encoding = QStringConverter::encodingForHtml(data);
                if (encoding) {
                    QStringDecoder decoder(*encoding);
                    doc->setHtml(decoder(data));
                } else {
                    // fall back to utf8
                    doc->setHtml(QString::fromUtf8(data));
                }
            } else
#endif
            {
                doc->setPlainText(QString::fromUtf8(data));
            }
            setStatus(QQuickTextDocument::Status::Loaded, {});
            qCDebug(lcTextDoc) << editor << "loaded" << filePath
                               << "as" << editor->textFormat() << "detected" << detectedFormat
#if QT_CONFIG(mimetype)
                               << "(file type" << mimeType << ')'
#endif
                    ;
            doc->setModified(false);
            return;
        }
        setStatus(QQuickTextDocument::Status::ReadError,
                  QQuickTextDocument::tr("Failed to read: %1").arg(file.errorString()));
    } else {
        setStatus(QQuickTextDocument::Status::ReadError,
                  QQuickTextDocument::tr("%1 does not exist").arg(filePath));
    }
}
 
void QQuickTextDocumentPrivate::writeTo(const QUrl &fileUrl)
{
    auto *doc = editor->document();
    if (!doc)
        return;
 
    const QString filePath = fileUrl.toLocalFile();
    const bool sameUrl = fileUrl == url;
    if (!sameUrl) {
#if QT_CONFIG(mimetype)
        const auto type = QMimeDatabase().mimeTypeForUrl(fileUrl);
        if (type.inherits("text/html"_L1))
            detectedFormat = Qt::RichText;
        else if (type.inherits("text/markdown"_L1))
            detectedFormat = Qt::MarkdownText;
        else
            detectedFormat = Qt::PlainText;
#else
        if (filePath.endsWith(".html"_L1, Qt::CaseInsensitive) ||
            filePath.endsWith(".htm"_L1, Qt::CaseInsensitive))
            detectedFormat = Qt::RichText;
        else if (filePath.endsWith(".md"_L1, Qt::CaseInsensitive) ||
                 filePath.endsWith(".markdown"_L1, Qt::CaseInsensitive))
            detectedFormat = Qt::MarkdownText;
        else
            detectedFormat = Qt::PlainText;
#endif
    }
    QFile file(filePath);
    if (!file.open(QFile::WriteOnly | QFile::Truncate |
                   (detectedFormat == Qt::RichText ? QFile::NotOpen : QFile::Text))) {
        setStatus(QQuickTextDocument::Status::WriteError,
                  QQuickTextDocument::tr("Cannot save: %1").arg(file.errorString()));
        return;
    }
    setStatus(QQuickTextDocument::Status::Saving, {});
    QByteArray raw;
 
    switch (detectedFormat) {
#if QT_CONFIG(textmarkdownwriter)
    case Qt::MarkdownText:
        raw = doc->toMarkdown().toUtf8();
        break;
#endif
#if QT_CONFIG(texthtmlparser)
    case Qt::RichText:
        if (sameUrl && encoding) {
            QStringEncoder enc(*encoding);
            raw = enc.encode(doc->toHtml());
        } else {
            // default to UTF-8 unless the user is saving the same file as previously loaded
            raw = doc->toHtml().toUtf8();
        }
        break;
#endif
    default:
        raw = doc->toPlainText().toUtf8();
        break;
    }
 
    file.write(raw);
    file.close();
    setStatus(QQuickTextDocument::Status::Saved, {});
    doc->setModified(false);
}
 
QTextDocument *QQuickTextDocumentPrivate::document() const
{
    return editor->document();
}
 
void QQuickTextDocumentPrivate::setDocument(QTextDocument *doc)
{
    Q_Q(QQuickTextDocument);
    QTextDocument *oldDoc = editor->document();
    if (doc == oldDoc)
        return;
 
    if (oldDoc)
        oldDoc->disconnect(q);
    if (doc) {
        q->connect(doc, &QTextDocument::modificationChanged,
                   q, &QQuickTextDocument::modifiedChanged);
    }
    editor->setDocument(doc);
    emit q->textDocumentChanged();
}
 
QTextDocument *QQuickTextDocument::textDocument() const
{
    Q_D(const QQuickTextDocument);
    return d->document();
}
 
void QQuickTextDocument::setTextDocument(QTextDocument *document)
{
    d_func()->setDocument(document);
}
 
void QQuickTextDocument::save()
{
    Q_D(QQuickTextDocument);
    d->writeTo(d->url);
}
 
void QQuickTextDocument::saveAs(const QUrl &url)
{
    Q_D(QQuickTextDocument);
    if (!url.isLocalFile()) {
        d->setStatus(QQuickTextDocument::Status::NonLocalFileError,
                     QQuickTextDocument::tr("Can only save to local files"));
        return;
    }
    d->writeTo(url);
 
    if (url == d->url)
        return;
 
    d->url = url;
    emit sourceChanged();
}
 
QQuickTextImageHandler::QQuickTextImageHandler(QObject *parent)
    : QObject(parent)
{
}
 
QSizeF QQuickTextImageHandler::intrinsicSize(
        QTextDocument *doc, int, const QTextFormat &format)
{
    if (format.isImageFormat()) {
        QTextImageFormat imageFormat = format.toImageFormat();
        const int width = qRound(imageFormat.width());
        const bool hasWidth = imageFormat.hasProperty(QTextFormat::ImageWidth) && width > 0;
        const int height = qRound(imageFormat.height());
        const bool hasHeight = imageFormat.hasProperty(QTextFormat::ImageHeight) && height > 0;
        QSizeF size(width, height);
        if (!hasWidth || !hasHeight) {
            QVariant res = doc->resource(QTextDocument::ImageResource, QUrl(imageFormat.name()));
            QImage image = res.value<QImage>();
            if (image.isNull()) {
                // autotests expect us to reserve a 16x16 space for a "broken image" icon,
                // even though we don't actually display one
                if (!hasWidth)
                    size.setWidth(16);
                if (!hasHeight)
                    size.setHeight(16);
                return size;
            }
            QSize imgSize = image.size();
            if (!hasWidth) {
                if (!hasHeight)
                    size.setWidth(imgSize.width());
                else
                    size.setWidth(qRound(height * (imgSize.width() / (qreal) imgSize.height())));
            }
            if (!hasHeight) {
                if (!hasWidth)
                    size.setHeight(imgSize.height());
                else
                    size.setHeight(qRound(width * (imgSize.height() / (qreal) imgSize.width())));
            }
        }
        return size;
    }
    return QSizeF();
}
 
QT_END_NAMESPACE
 
#include "moc_qquicktextdocument.cpp"
#include "moc_qquicktextdocument_p.cpp"