Respect TextEdit.textFormat in TextDocument load(); detect format

Don't load rich text if TextEdit.textFormat is PlainText. Thus it
should be possible to have two independent TextEdit instances with
independent document instances, viewing the same source file: the
raw syntax and the rich/WYSIWYG formatting visible at the same time.

Also, after the QQuickTextDocument's QTextDocument has already loaded
the declared source, don't let QQuickTextEdit::componentComplete()
replace it with empty text from the (unbound) TextEdit.text property.
That was happening only if textFormat was RichText or MarkdownText.

In case the user transitions TextEdit.textFormat from AutoText to any
other, the text property now holds the format that was loaded from
TextDocument.source; QQuickTextDocumentPrivate remembers the format
rather than the mime type (because QMimeType is an optional feature in
Qt); and TextEdit functions such as getFormattedText(), insert() and
append() behave as if the textFormat property had been appropriate for
the loaded file type in the first place.  We cannot algorithmically
detect markdown text by looking at the text itself; but now,
QQuickTextDocumentPrivate::load() can populate markdown or html text
into the document by detecting the file's mime type, even if the
textFormat is AutoText. After that, if the user changes the textFormat
to PlainText, we assume that they want to see the raw markdown or HTML.

Amends b46d6a75ac16089de1a29c773e7594a82ffea13e : it already seemed odd
at the time that it was OK for QQuickTextDocumentPrivate::load() to load
any text format, without first changing TextEdit.textFormat to match
what's expected. The default is PlainText, so it didn't make sense to
read e.g. a markdown file and have the result look like WYSIWYG rich
text. Now you have to change textFormat to MarkdownText or AutoText
beforehand if you want to see WYSIWYG; and
tst_qquicktextdocument::sourceAndSave() needs to do that too.

On the other hand, if you switch textFormat to PlainText, we convert the
QTextDocument to plain text, using Qt-generated markup/markdown syntax.
Maybe the user would prefer to have the original syntax as read from
the file; but so far it has always been this way: we just parse it,
we don't store it. We are quite incapable of incrementally modifying
the original syntax anyway: we can only regenerate it wholesale.
So it makes sense that the text property holds Qt-generated syntax
after the parsing is done.

Pick-to: 6.7
Fixes: QTBUG-120772
Change-Id: I7db533c714e14bb4eb36745996c732e5162fb9cf
Reviewed-by: Oliver Eftevaag <[email protected]>
Reviewed-by: Qt CI Bot <[email protected]>

1 files changed, 46 insertions, 17 deletions

diff --git a/src/quick/items/qquicktextdocument.cpp b/src/quick/items/qquicktextdocument.cpp
index 575f54df29..1fab2e6da0 100644
--- a/src/quick/items/qquicktextdocument.cpp
+++ b/src/quick/items/qquicktextdocument.cpp
@@ -16,6 +16,8 @@
 
 QT_BEGIN_NAMESPACE
 
+Q_LOGGING_CATEGORY(lcTextDoc, "qt.quick.textdocument")
+
 using namespace Qt::StringLiterals;
 
 /*!
@@ -209,7 +211,7 @@ void QQuickTextDocumentPrivate::load()
     QFile file(filePath);
     if (file.exists()) {
 #if QT_CONFIG(mimetype)
-        mimeType = QMimeDatabase().mimeTypeForFile(filePath);
+        QMimeType mimeType = QMimeDatabase().mimeTypeForFile(filePath);
         const bool isHtml = mimeType.inherits("text/html"_L1);
         const bool isMarkdown = mimeType.inherits("text/markdown"_L1);
 #else
@@ -218,17 +220,24 @@ void QQuickTextDocumentPrivate::load()
         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));
+            const bool plainText = editor->textFormat() == QQuickTextEdit::PlainText;
 #if QT_CONFIG(textmarkdownreader)
-            if (isMarkdown) {
+            if (!plainText && isMarkdown) {
                 doc->setMarkdown(QString::fromUtf8(data));
             } else
 #endif
 #ifndef QT_NO_TEXTHTMLPARSER
-            if (isHtml) {
+            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);
@@ -245,6 +254,12 @@ void QQuickTextDocumentPrivate::load()
                 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;
         }
@@ -264,31 +279,44 @@ void QQuickTextDocumentPrivate::writeTo(const QUrl &fileUrl)
 
     const QString filePath = fileUrl.toLocalFile();
     const bool sameUrl = fileUrl == url;
+    if (!sameUrl) {
 #if QT_CONFIG(mimetype)
-    const auto type = (sameUrl ? mimeType : QMimeDatabase().mimeTypeForUrl(fileUrl));
-    const bool isHtml = type.inherits("text/html"_L1);
-    const bool isMarkdown = type.inherits("text/markdown"_L1);
+        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
-    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);
+        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 | (isHtml ? QFile::NotOpen : QFile::Text))) {
-        qmlWarning(q) << QQuickTextDocument::tr("Cannot save: %1").arg(file.errorString());
+    if (!file.open(QFile::WriteOnly | QFile::Truncate |
+                   (detectedFormat == Qt::RichText ? QFile::NotOpen : QFile::Text))) {
+        qmlWarning(q) << QQuickTextDocument::tr("Cannot save:") << file.errorString();
         setStatus(QQuickTextDocument::Status::WriteError);
         return;
     }
     setStatus(QQuickTextDocument::Status::Saving);
     QByteArray raw;
+
+    switch (detectedFormat) {
 #if QT_CONFIG(textmarkdownwriter)
-    if (isMarkdown) {
+    case Qt::MarkdownText:
         raw = doc->toMarkdown().toUtf8();
-    } else
+        break;
 #endif
 #ifndef QT_NO_TEXTHTMLPARSER
-    if (isHtml) {
+    case Qt::RichText:
         if (sameUrl && encoding) {
             QStringEncoder enc(*encoding);
             raw = enc.encode(doc->toHtml());
@@ -296,10 +324,11 @@ void QQuickTextDocumentPrivate::writeTo(const QUrl &fileUrl)
             // default to UTF-8 unless the user is saving the same file as previously loaded
             raw = doc->toHtml().toUtf8();
         }
-    } else
+        break;
 #endif
-    {
+    default:
         raw = doc->toPlainText().toUtf8();
+        break;
     }
 
     file.write(raw);