Qt Widgets - Text Viewer Plugin Example

A widget example with menus, toolbars and a status bar.

The Text Viewer example is a text editor built around QPlainTextEdit, in the form of a plugin for a general-purpose Document Viewer.

All of the code for the Text Viewer example is in the TxtViewer class, which inherits AbstractViewer. AbstractViewer provides the framework for interaction between a viewer and the main window. The application provides File, Edit, and Help entries in the menu bar.

The status bar at the bottom of the main window shows a message provided by the application to its user.

Recently opened files are shown in the File menu. The example can only load one file at a time.

Class Definition

class TxtViewer : public ViewerInterface
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.Examples.DocumentViewer.ViewerInterface" FILE "txtviewer.json")

The class definition starts with the Q_OBJECT macro, which handles signals and slots. It is followed by the Q_PLUGIN_METADATA and Q_INTERFACES macros which are necessary to register the plugin.

The class inherits from ViewerInterface, which inherits from AbstractViewer. The ViewerInterface class is used to provide an interface between the main window application and the plugin.

QPluginLoader also requires the file txtviewer.json, which has to contain the plugin's key:

{ "Keys": [ "txtviewer" ] }
    ~TxtViewer() override;
    void init(QFile *file, QWidget *parent, QMainWindow *mainWindow) override;
    QString viewerName() const override { return QLatin1StringView(staticMetaObject.className()); };
    QStringList supportedMimeTypes() const override;
    bool saveDocument() override { return saveFile(m_file.get()); };
    bool saveDocumentAs() override;
    bool hasContent() const override;
    QByteArray saveState() const override { return {}; }
    bool restoreState(QByteArray &) override { return true; }
    bool supportsOverview() const override { return false; }

    void printDocument(QPrinter *printer) const override;

private slots:
    void setupTxtUi();

    void openFile();
    bool saveFile (QFile *file);

    QPlainTextEdit *m_textEdit;

The class defines no constructor, which means that only a standard constructor without arguments is available. All other functions, including the destructor, re-implement virtual functions of ViewerInterface. They are used to exchange data, information, and instructions with the main application.

No functionality is implemented to save and restore settings. The supportsOverview function always returns false, which tells the main application that no window for thumbnail navigation has to be displayed.

TxtViewer Class Implementation

#include "txtviewer.h"

#include <QFileDialog>
#include <QMainWindow>
#include <QMenu>
#include <QMenuBar>
#include <QPlainTextEdit>
#include <QScrollBar>
#include <QToolBar>

#include <QGuiApplication>
#include <QPainter>
#include <QTextDocument>

#include <QDir>

#include <QPrinter>
#include <QPrintDialog>

using namespace Qt::StringLiterals;

    connect(this, &AbstractViewer::uiInitialized, this, &TxtViewer::setupTxtUi);

TxtViewer::~TxtViewer() = default;

void TxtViewer::init(QFile *file, QWidget *parent, QMainWindow *mainWindow)
    AbstractViewer::init(file, new QPlainTextEdit(parent), mainWindow);
    m_textEdit = qobject_cast<QPlainTextEdit *>(widget());

QStringList TxtViewer::supportedMimeTypes() const
    return {"text/plain"_L1};

void TxtViewer::setupTxtUi()
    QMenu *editMenu = addMenu(tr("&Edit"));
    QToolBar *editToolBar = addToolBar(tr("Edit"));
    const QIcon cutIcon = QIcon::fromTheme("edit-cut"_L1,
    QAction *cutAct = new QAction(cutIcon, tr("Cu&t"), this);
    cutAct->setStatusTip(tr("Cut the current selection's contents to the "
    connect(cutAct, &QAction::triggered, m_textEdit, &QPlainTextEdit::cut);

    const QIcon copyIcon = QIcon::fromTheme("edit-copy"_L1,
    QAction *copyAct = new QAction(copyIcon, tr("&Copy"), this);
    copyAct->setStatusTip(tr("Copy the current selection's contents to the "
    connect(copyAct, &QAction::triggered, m_textEdit, &QPlainTextEdit::copy);

    const QIcon pasteIcon = QIcon::fromTheme("edit-paste"_L1,
    QAction *pasteAct = new QAction(pasteIcon, tr("&Paste"), this);
    pasteAct->setStatusTip(tr("Paste the clipboard's contents into the current "
    connect(pasteAct, &QAction::triggered, m_textEdit, &QPlainTextEdit::paste);


    connect(m_textEdit, &QPlainTextEdit::copyAvailable, cutAct, &QAction::setEnabled);
    connect(m_textEdit, &QPlainTextEdit::copyAvailable, copyAct, &QAction::setEnabled);
#endif // !QT_NO_CLIPBOARD


    connect(m_textEdit, &QPlainTextEdit::textChanged, this, [&](){

    connect(m_uiAssets.back, &QAction::triggered, m_textEdit, [&](){
        auto *bar = m_textEdit->verticalScrollBar();
        if (bar->value() > bar->minimum())
            bar->setValue(bar->value() - 1);

    connect(m_uiAssets.forward, &QAction::triggered, m_textEdit, [&](){
        auto *bar = m_textEdit->verticalScrollBar();
        if (bar->value() < bar->maximum())
            bar->setValue(bar->value() + 1);

We start by including the header files necessary to access all classes used by TxtViewer. We also include txtviewer.h.

QPrinter and QPrintDialog are only included if print support is enabled on the compilation system.

You might wonder why we don't include these headers in mainwindow.h and be done with it. The reason is that including multiple large headers from another header file can rapidly degrade performance. Here, it wouldn't do any harm, but it's still generally a good idea to include only the header files that are strictly necessary from another header file.

The implementation starts with an empty destructor. It could be completely omitted. It's good practice to implement it empty in order to point out to code readers that nothing needs to be done in the destructor.

The destructor is followed by an initialization function, taking three arguments:

  • file, the pointer to the file to be opened and displayed.
  • parent, pointing to the QWidget inside which the editor shall be placed.
  • mainWindow, pointing to the application's main window, where menus and menu bars are handled.

The function calls the base init function of AbstractViwer. A new QPlainTextEdit widget is created, which will display the file's contents. Then, TxtViewer's setup function is connected to the base class' uiInitialized signal.

The next function returns the list of mime types, which the text viewer supports. Only plain text is supported.

The last initialization function adds viewer specific UI components like menus, icons, buttons, and tooltips. It uses functionality provided by AbstractViewer to make sure that these components are removed from the application's main window, once another file is displayed with another viewer plugin.

void TxtViewer::openFile()
    const QString type = tr("open");
    if (!m_file->open(QFile::ReadOnly | QFile::Text)) {
        statusMessage(tr("Cannot read file %1:\n%2.")
                           m_file->errorString()), type);

    QTextStream in(m_file.get());
#ifndef QT_NO_CURSOR
    if (!m_textEdit->toPlainText().isEmpty()) {
#ifndef QT_NO_CURSOR

    statusMessage(tr("File %1 loaded.")
                  .arg(QDir::toNativeSeparators(m_file->fileName())), type);

openFile opens a file, transfers its contents into the QPlainTextEdit, and prints a status message for the user, depending on whether or not the opening was successful.

bool TxtViewer::hasContent() const
    return (!m_textEdit->toPlainText().isEmpty());

void TxtViewer::printDocument(QPrinter *printer) const
    if (!hasContent())


bool TxtViewer::saveFile(QFile *file)
    QString errorMessage;

    if (file->open(QFile::WriteOnly | QFile::Text)) {
        QTextStream out(file);
        out << m_textEdit->toPlainText();
    } else {
        errorMessage = tr("Cannot open file %1 for writing:\n%2.")

    if (!errorMessage.isEmpty()) {
        return false;

    statusMessage(tr("File %1 saved")
    return true;

bool TxtViewer::saveDocumentAs()
    QFileDialog dialog(mainWindow());
    if (dialog.exec() != QDialog::Accepted)
        return false;

    const QStringList &files = dialog.selectedFiles();
    if (files.isEmpty())
        return false;

    return saveDocument();

The next re-implemented function tells the main application whether or not the viewer plugin is actually displaying content.

If printing is supported on the compiling system, the next section implements it.

The last two re-implementations provide functionality to save the current file or to save it under a new name.

Example project @ code.qt.io

© 2024 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.