Hey there, let's tackle this frustrating performance issue you're seeing with your Qt text editor. That 42-second wait for setPlainText() on a 540KB file is definitely way out of line, especially since reading the file only takes 18ms—so the problem isn't the file I/O, it's how Qt's text widget is handling the content once you have it.

Why setPlainText() is so slow for large files #

Under the hood, setPlainText() does a lot more than just dump text into the widget:

• It triggers multiple textChanged() signals, which might be connected to handlers that do extra work (like syntax highlighting, auto-completion, or status bar updates).
• It forces the widget to re-render the entire document immediately, which is expensive for large text blocks.
• It creates a full undo/redo record for the entire operation, which involves copying the entire text into the undo stack.
• If you're using QTextEdit (not QPlainTextEdit), it's designed for rich text—even if you're only using plain text, it carries extra overhead for formatting support.

Practical Fixes to Speed Up Loading #

1. Disable UI Updates, Signals, and Undo/Redo Temporarily

The easiest win is to turn off all the extra processing while loading the file, then re-enable it afterwards. Here's how to implement this:

// Before loading, pause all non-essential operations
textEdit->setUpdatesEnabled(false); // Stop UI from redrawing
textEdit->setUndoRedoEnabled(false); // Skip creating undo records
textEdit->blockSignals(true); // Prevent textChanged() and other signals from firing

// If you have a syntax highlighter, disable it temporarily
QSyntaxHighlighter* highlighter = textEdit->document()->findChild<QSyntaxHighlighter*>();
if (highlighter) {
    highlighter->setDocument(nullptr);
}

// Load the file (your fast readAll() code here)
QFile file("your_large_file.txt");
if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
    QByteArray content = file.readAll();
    textEdit->setPlainText(content);
    file.close();
}

// Restore all settings
textEdit->blockSignals(false);
textEdit->setUndoRedoEnabled(true);
textEdit->setUpdatesEnabled(true);

// Re-enable syntax highlighting if you disabled it
if (highlighter) {
    highlighter->setDocument(textEdit->document());
}

This should cut down the loading time drastically by eliminating all the unnecessary background work during the text insertion.

2. Switch to QPlainTextEdit Instead of QTextEdit

If you're building a pure text editor, QPlainTextEdit is specifically optimized for this use case. It skips most of the rich text formatting overhead of QTextEdit and uses a more efficient line-based rendering system. The API is almost identical to QTextEdit, so switching is straightforward—just replace your QTextEdit instances with QPlainTextEdit in your code and UI files.

For large files, this alone can bring loading times from seconds down to milliseconds.

3. Load Text in Chunks (Optional)

If even with the above optimizations you still see delays, try loading the file line by line instead of all at once. Combine this with the temporary disable steps for best results:

textEdit->setUpdatesEnabled(false);
textEdit->setUndoRedoEnabled(false);
textEdit->blockSignals(true);

QFile file("your_large_file.txt");
if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
    QTextStream in(&file);
    textEdit->clear();
    while (!in.atEnd()) {
        QString line = in.readLine();
        textEdit->append(line); // Insert line by line
    }
    file.close();
}

// Restore settings as before
textEdit->blockSignals(false);
textEdit->setUndoRedoEnabled(true);
textEdit->setUpdatesEnabled(true);

This reduces the amount of text processed in a single operation, which can help with memory usage and rendering overhead.

Final Notes #

Start with the first fix (disabling updates/signals/undo) and see how much that helps. If you're still not satisfied, switching to QPlainTextEdit is the next big step—this is the most impactful change for pure text editors.

Combining these two approaches should get your loading time down to a reasonable level (well under a second for a 540KB file).

内容的提问来源于stack exchange，提问作者JosanSun