fix: Refactor file saving with TextFileSaver and add safety checks

- Added TextFileSaver class for atomic file saving with encoding conversion
- Refactored all file saving operations in EditWrapper to use TextFileSaver
- Added null checks in Window class for safer wrapper access
- Improved error handling for long filenames and permission issues
- Removed duplicate encoding conversion code paths

Log: Improved file saving reliability and added safety checks
     throughout the editor

Author: rb-union

src/common/text_file_saver.cpp

@@ -0,0 +1,194 @@
+// SPDX-FileCopyrightText: 2025 UnionTech Software Technology Co., Ltd.
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/**
+ * @file file_saver.cpp
+ * @brief Implementation of FileSaver class for safe file saving with encoding conversion
+ */
+
+#include "text_file_saver.h"
+#include "../encodes/detectcode.h"
+
+#include <QSaveFile>
+#include <QFileInfo>
+#include <QTextCodec>
+#include <QDebug>
+#include <QIODevice>
+#include <QTextDocument>
+#include <QObject>
+
+/**
+ * @brief Constructs a TextFileSaver with the given text document
+ * @param document The QTextDocument to be saved
+ */
+TextFileSaver::TextFileSaver(QTextDocument *document)
+    : m_document(document)
+    , m_fromEncode("UTF-16")
+    , m_toEncode("UTF-8")
+{
+}
+
+TextFileSaver::~TextFileSaver() {}
+
+/**
+ * @brief Sets the target file path for saving
+ * @param filePath The full path of the file to save to
+ */
+void TextFileSaver::setFilePath(const QString &filePath)
+{
+    m_filePath = filePath;
+}
+
+/**
+ * @brief Sets the target encoding for the saved file
+ * @param toEncode The target encoding for the saved file
+ */
+void TextFileSaver::setEncoding(const QByteArray &toEncode)
+{
+    m_toEncode = toEncode;
+}
+
+/**
+ * @brief Saves the document to the preset file path
+ * @return true if the file was saved successfully, false otherwise
+ * @note Uses QSaveFile for atomic writes when filename is not too long
+ */
+bool TextFileSaver::save()
+{
+    if (m_filePath.isEmpty()) {
+        m_errorString = QObject::tr("File path is empty");
+        return false;
+    }
+
+    // WARNING: For long filenames (>245 chars), QSaveFile may create temporary files
+    // with names that exceed system limits. TextFileSaver handles this internally.
+    QFileInfo fileInfo(m_filePath);
+    bool disableSaveProtect = fileInfo.fileName().length() > MAX_FILENAME_LENGTH;
+
+    if (!disableSaveProtect) {
+        QSaveFile saveFile(m_filePath);
+        saveFile.setDirectWriteFallback(true);
+        if (!saveToFile(saveFile)) {
+            return false;
+        }
+        return saveFile.commit();
+    } else {
+        qWarning() << "File name too long, disable QSaveFile. path:" << m_filePath;
+        QFile file(m_filePath);
+        if (!saveToFile(file)) {
+            return false;
+        }
+        return true;
+    }
+}
+
+/**
+ * @brief Saves the document to a new file path
+ * @param newFilePath The target path to save the file to
+ * @return true if the file was saved successfully, false otherwise
+ * @note Restores original file path if save fails
+ */
+bool TextFileSaver::saveAs(const QString &newFilePath)
+{
+    QString oldPath = m_filePath;
+    m_filePath = newFilePath;
+    bool result = save();
+    if (!result) {
+        m_filePath = oldPath;
+    }
+    return result;
+}
+
+/**
+ * @brief Gets the last error message
+ * @return The description of the last error that occurred
+ */
+QString TextFileSaver::errorString() const
+{
+    return m_errorString;
+}
+
+/**
+ * @brief Internal implementation of file writing
+ * @param file The QFileDevice to write to
+ * @return true if the write was successful, false otherwise
+ */
+bool TextFileSaver::saveToFile(QFileDevice &file)
+{
+    try {
+        if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
+            m_errorString = file.errorString();
+            return false;
+        }
+
+        const QString content = m_document->toPlainText();
+        const ushort *data = content.utf16();
+        const int length = content.length();
+
+        // Dynamically calculate chunk size (10MB or 1/8 of total length, whichever is larger)
+        const int chunkSize = qMax(10 * 1024 * 1024, length / 8);
+
+        for (int i = 0; i < length; i += chunkSize) {
+            int currentChunkSize = qMin(chunkSize, length - i);
+            QByteArray input(reinterpret_cast<const char *>(data + i), currentChunkSize * sizeof(ushort));
+            QByteArray outData;
+
+            if (!convertEncoding(input, outData)) {
+                m_errorString = QObject::tr("Encoding conversion failed");
+                return false;
+            }
+
+            if (outData.isEmpty()) {
+                m_errorString = QObject::tr("Converted content is empty");
+                return false;
+            }
+
+            qint64 written = file.write(outData);
+            if (written != outData.size()) {
+                m_errorString = file.errorString();
+                return false;
+            }
+        }
+
+        return true;
+    } catch (const std::bad_alloc &) {
+        m_errorString = QObject::tr("Memory allocation failed");
+        return false;
+    } catch (const std::exception &e) {
+        m_errorString = QObject::tr("Error occurred: %1").arg(e.what());
+        return false;
+    } catch (...) {
+        m_errorString = QObject::tr("Unknown error occurred");
+        return false;
+    }
+}
+
+/**
+ * @brief Gets the document content as plain text
+ * @return The document content as QString
+ */
+QString TextFileSaver::getDocumentContent() const
+{
+    return m_document->toPlainText();
+}
+
+/**
+ * @brief Converts between character encodings
+ * @param input The input byte array to convert
+ * @param output The converted output byte array
+ * @return true if conversion was successful, false otherwise
+ * @note Uses DetectCode first, falls back to QTextCodec if needed
+ */
+bool TextFileSaver::convertEncoding(QByteArray &input, QByteArray &output) const
+{
+    if (m_fromEncode == m_toEncode) {
+        output = input;
+        return true;
+    }
+
+    if (!DetectCode::ChangeFileEncodingFormat(input, output, m_fromEncode, m_toEncode)) {
+        return false;
+    }
+    return true;
+}

src/common/text_file_saver.h

@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: 2025 UnionTech Software Technology Co., Ltd.
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#ifndef TEXT_FILE_SAVER_H
+#define TEXT_FILE_SAVER_H
+
+#include <QString>
+#include <QByteArray>
+#include <QFile>
+
+class QTextDocument;
+
+class TextFileSaver
+{
+public:
+    explicit TextFileSaver(QTextDocument *document);
+    ~TextFileSaver();
+
+    void setFilePath(const QString &filePath);
+    void setEncoding(const QByteArray &toEncode);
+    bool save();
+    bool saveAs(const QString &newFilePath);
+    QString errorString() const;
+
+private:
+    bool saveToFile(QFileDevice &file);
+    QString getDocumentContent() const;
+    bool convertEncoding(QByteArray &input, QByteArray &output) const;
+
+private:
+    QTextDocument *m_document;
+    QString m_filePath;
+    QByteArray m_fromEncode; // default is UTF-16 (QString)
+    QByteArray m_toEncode;   // default is UTF-8
+    QString m_errorString;
+    static const int MAX_FILENAME_LENGTH = 245;
+};
+
+#endif // TEXT_FILE_SAVER_H

src/common/utils.cpp

@@ -1122,3 +1122,108 @@ void Utils::sendFloatMessageFixedFont(QWidget *par, const QIcon &icon, const QSt
 
     DMessageManager::instance()->sendMessage(par, floMsg);
 }
+
+/**
+ * @brief Gets system memory information from /proc/meminfo
+ * @param[out] totalMemory Total system memory in KB
+ * @param[out] freeMemory Available memory in KB (MemAvailable if exists, otherwise MemFree+Buffers+Cached)
+ * @return True if memory info was successfully read and parsed, false otherwise
+ */
+bool Utils::getSystemMemoryInfo(qlonglong &totalMemory, qlonglong &freeMemory)
+{
+    qlonglong memFree = 0;
+    qlonglong buffers = 0;
+    qlonglong cached = 0;
+    bool valueOk = false;
+
+    QFile file(PROC_MEMINFO_PATH);
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        qWarning() << "Utils: Failed to open" << PROC_MEMINFO_PATH << "for memory check.";
+        return false;
+    }
+
+    QByteArray allData = file.readAll();
+    file.close();
+
+    QTextStream stream(allData);
+    QString line;
+    while (!stream.atEnd()) {
+        line = stream.readLine();
+        if (line.startsWith("MemTotal:")) {
+            totalMemory = line.section(':', 1, 1).trimmed().section(' ', 0, 0).toLongLong(&valueOk);
+        } else if (line.startsWith("MemFree:")) {
+            memFree = line.section(':', 1, 1).trimmed().section(' ', 0, 0).toLongLong(&valueOk);
+        } else if (line.startsWith("Buffers:")) {
+            buffers = line.section(':', 1, 1).trimmed().section(' ', 0, 0).toLongLong(&valueOk);
+        } else if (line.startsWith("Cached:")) {
+            cached = line.section(':', 1, 1).trimmed().section(' ', 0, 0).toLongLong(&valueOk);
+        } else if (line.startsWith("MemAvailable:")) {
+            freeMemory = line.section(':', 1, 1).trimmed().section(' ', 0, 0).toLongLong(&valueOk);
+            break;
+        }
+        if (stream.atEnd() && freeMemory == 0) {
+            freeMemory = memFree + buffers + cached;
+        }
+    }
+
+    return (totalMemory > 0 && freeMemory > 0);
+}
+
+/**
+ * @brief Checks if the system has sufficient memory to perform the specified operation.
+ * @param operationType The type of operation (Copy/Paste).
+ * @param operationDataSize The size of the data involved in the operation (bytes).
+ * @param currentDocumentSize The current size of the document (characters/bytes).
+ * @return True if memory is sufficient, false otherwise.
+ */
+bool Utils::isMemorySufficientForOperation(OperationType operationType, qlonglong operationDataSize, qlonglong currentDocumentSize)
+{
+    qlonglong memoryFree = 0;
+    qlonglong memoryTotal = 0;
+
+    if (!getSystemMemoryInfo(memoryTotal, memoryFree)) {
+        // Conservatively allow the operation if memory info cannot be read
+        return true;
+    }
+
+    // Convert KB to Bytes for comparison
+    qlonglong availableMemoryBytes = memoryFree * DATA_SIZE_1024;
+    qlonglong totalMemoryBytes = memoryTotal * DATA_SIZE_1024;
+
+    // Judge based on operation type
+    if (operationType == OperationType::CopyOperation) {
+        // Copy operation: Estimated memory consumption = data size * factor
+        qlonglong estimatedMemoryNeeded = operationDataSize * COPY_CONSUME_MEMORY_MULTIPLE;
+        if (estimatedMemoryNeeded > availableMemoryBytes) {
+            qWarning() << "Utils: Insufficient memory for copy operation. Needed(est):" << estimatedMemoryNeeded << "Available:" << availableMemoryBytes;
+            return false;
+        }
+    } else if (operationType == OperationType::PasteOperation) {
+        // Paste operation: Estimated memory consumption = paste data size * factor
+        qlonglong estimatedMemoryNeededForPaste = operationDataSize * PASTE_CONSUME_MEMORY_MULTIPLE;
+        // Estimated total document memory after paste
+        qlonglong estimatedTotalDocMemory = (currentDocumentSize + operationDataSize) * PASTE_CONSUME_MEMORY_MULTIPLE; // Estimate using paste factor
+
+        // Check if pasting the data itself would cause insufficient memory
+        if (estimatedMemoryNeededForPaste > availableMemoryBytes) {
+            qWarning() << "Utils: Insufficient memory for paste operation (paste data). Needed(est):" << estimatedMemoryNeededForPaste << "Available:" << availableMemoryBytes;
+            return false;
+        }
+
+        // Check if the estimated total document size after paste exceeds total system memory (very rough check)
+        if (estimatedTotalDocMemory > totalMemoryBytes) {
+            qWarning() << "Utils: Paste operation might exceed total system memory. Estimated total doc memory:" << estimatedTotalDocMemory << "Total system memory:" << totalMemoryBytes;
+            return false;
+        }
+
+        // Check specific threshold: Restrict paste size if document reaches 800MB
+        const qlonglong DOC_SIZE_LIMIT_800MB = 800LL * DATA_SIZE_1024 * DATA_SIZE_1024;
+        const qlonglong PASTE_SIZE_LIMIT_500KB = 500LL * DATA_SIZE_1024;
+        if (currentDocumentSize > DOC_SIZE_LIMIT_800MB && operationDataSize > PASTE_SIZE_LIMIT_500KB) {
+            qWarning() << "Utils: Paste operation restricted. Document size exceeds 800MB and paste data exceeds 500KB.";
+            return false;
+        }
+    }
+
+    return true; // Memory is sufficient
+}

src/common/utils.h

@@ -47,6 +47,14 @@ class Utils
         EIntersectInner,   ///< 活动区间处于固定区间内部         例如 [0, 9] 和 [5, 6]
     };
 
+    /**
+     * @brief A text operation type for memory checking
+     */
+    enum OperationType {
+        CopyOperation,
+        PasteOperation
+    };
+
     /**
      * @brief 当前运行时系统环境
      */
@@ -157,6 +165,11 @@ class Utils
     // 发送浮动提示信息，并且字体大小跟随 qApp 应用默认字体而不是父窗口字体
     static void sendFloatMessageFixedFont(QWidget *par, const QIcon &icon, const QString &message);
 
+    // Gets system memory information from /proc/meminfo
+    static bool getSystemMemoryInfo(qlonglong &totalMemory, qlonglong &freeMemory);
+    // Checks if the system has sufficient memory to perform the specified operation.
+    static bool isMemorySufficientForOperation(OperationType operationType, qlonglong operationDataSize, qlonglong currentDocumentSize);
+
 private:
     static QString m_systemLanguage;
 };