Qt Widgets - Exemple de plugin de visualisation de texte

Un exemple de widget avec des menus, des barres d'outils et une barre d'état.

L'exemple de visualiseur de texte est un éditeur de texte construit autour de QPlainTextEdit, sous la forme d'un plugin pour un visualiseur de document à usage général.

Tout le code de l'exemple de la visionneuse de texte se trouve dans la classe TxtViewer, qui hérite de AbstractViewer. AbstractViewer fournit le cadre de l'interaction entre une visionneuse et la fenêtre principale. L'application propose les entrées File, Edit et Help dans la barre de menu.

La barre d'état située en bas de la fenêtre principale affiche un message fourni par l'application à son utilisateur.

Les fichiers récemment ouverts sont affichés dans le menu File. L'exemple ne peut charger qu'un seul fichier à la fois.

Définition de la classe

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

La définition de la classe commence par la macro Q_OBJECT, qui gère les signaux et les emplacements. Elle est suivie par les macros Q_PLUGIN_METADATA et Q_INTERFACES qui sont nécessaires pour enregistrer le plugin.

La classe hérite de ViewerInterface, qui hérite de AbstractViewer. La classe ViewerInterface est utilisée pour fournir une interface entre l'application de la fenêtre principale et le plugin.

QPluginLoader La classe nécessite également le fichier txtviewer.json, qui doit contenir la clé du plugin :

{ "Keys": [ "txtviewer" ] }
public:
    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 retranslate() override;

#ifdef DOCUMENTVIEWER_PRINTSUPPORT
protected:
    void printDocument(QPrinter *printer) const override;
#endif // DOCUMENTVIEWER_PRINTSUPPORT

private slots:
    void setupTxtUi();

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

    QPlainTextEdit *m_textEdit;
    QMenu *m_editMenu = nullptr;
    QToolBar *m_editToolBar = nullptr;
    QAction *m_cutAct = nullptr;
    QAction *m_copyAct = nullptr;
    QAction *m_pasteAct = nullptr;
};

La classe ne définit pas de constructeur, ce qui signifie que seul un constructeur standard sans arguments est disponible. Toutes les autres fonctions, y compris le destructeur, réimplémentent les fonctions virtuelles de ViewerInterface. Elles sont utilisées pour échanger des données, des informations et des instructions avec l'application principale.

Aucune fonctionnalité n'est implémentée pour sauvegarder et restaurer les paramètres. La fonction supportsOverview renvoie toujours false, ce qui indique à l'application principale qu'aucune fenêtre de navigation dans les vignettes ne doit être affichée.

Mise en œuvre de la classe TxtViewer

#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>

#ifdef DOCUMENTVIEWER_PRINTSUPPORT
#include <QPrinter>
#include <QPrintDialog>
#endif

using namespace Qt::StringLiterals;

TxtViewer::TxtViewer()
{
    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());
    setTranslationBaseName("txtviewer"_L1);
}

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

void TxtViewer::setupTxtUi()
{
    m_editMenu = addMenu(tr("&Edit"));
    m_editToolBar = addToolBar(tr("Edit"));
#if QT_CONFIG(clipboard)
    const QIcon cutIcon = QIcon::fromTheme(QIcon::ThemeIcon::EditCut,
                                           QIcon(":/demos/documentviewer/images/cut.png"_L1));
    m_cutAct = new QAction(cutIcon, tr("Cu&t"), this);
    m_cutAct->setShortcuts(QKeySequence::Cut);
    m_cutAct->setStatusTip(tr("Cut the current selection's contents to the "
                            "clipboard"));
    connect(m_cutAct, &QAction::triggered, m_textEdit, &QPlainTextEdit::cut);
    m_editMenu->addAction(m_cutAct);
    m_editToolBar->addAction(m_cutAct);

    const QIcon copyIcon = QIcon::fromTheme(QIcon::ThemeIcon::EditCopy,
                                            QIcon(":/demos/documentviewer/images/copy.png"_L1));
    m_copyAct = new QAction(copyIcon, tr("&Copy"), this);
    m_copyAct->setShortcuts(QKeySequence::Copy);
    m_copyAct->setStatusTip(tr("Copy the current selection's contents to the "
                             "clipboard"));
    connect(m_copyAct, &QAction::triggered, m_textEdit, &QPlainTextEdit::copy);
    m_editMenu->addAction(m_copyAct);
    m_editToolBar->addAction(m_copyAct);

    const QIcon pasteIcon = QIcon::fromTheme(QIcon::ThemeIcon::EditPaste,
                                             QIcon(":/demos/documentviewer/images/paste.png"_L1));
    m_pasteAct = new QAction(pasteIcon, tr("&Paste"), this);
    m_pasteAct->setShortcuts(QKeySequence::Paste);
    m_pasteAct->setStatusTip(tr("Paste the clipboard's contents into the current "
                              "selection"));
    connect(m_pasteAct, &QAction::triggered, m_textEdit, &QPlainTextEdit::paste);
    m_editMenu->addAction(m_pasteAct);
    m_editToolBar->addAction(m_pasteAct);

    menuBar()->addSeparator();

    m_cutAct->setEnabled(false);
    m_copyAct->setEnabled(false);
    connect(m_textEdit, &QPlainTextEdit::copyAvailable, m_cutAct, &QAction::setEnabled);
    connect(m_textEdit, &QPlainTextEdit::copyAvailable, m_copyAct, &QAction::setEnabled);
#endif // QT_CONFIG(clipboard)

    openFile();

    connect(m_textEdit, &QPlainTextEdit::textChanged, this, [&](){
        maybeSetPrintingEnabled(hasContent());
    });

    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);
    });
}

Nous commençons par inclure les fichiers d'en-tête nécessaires pour accéder à toutes les classes utilisées par TxtViewer. Nous incluons également txtviewer.h.

QPrinter et QPrintDialog ne sont inclus que si la prise en charge de l'impression est activée sur le système de compilation.

Vous pouvez vous demander pourquoi nous n'incluons pas ces fichiers d'en-tête dans mainwindow.h et n'en faisons qu'à notre tête. La raison en est que l'inclusion de plusieurs gros en-têtes provenant d'un autre fichier d'en-tête peut rapidement dégrader les performances. Ici, cela ne ferait pas de mal, mais c'est toujours une bonne idée d'inclure seulement les fichiers d'en-tête qui sont strictement nécessaires à partir d'un autre fichier d'en-tête.

L'implémentation commence par un destructeur vide. Il pourrait être complètement omis. C'est une bonne pratique de l'implémenter vide afin d'indiquer aux lecteurs de code que rien ne doit être fait dans le destructeur.

Le destructeur est suivi d'une fonction d'initialisation, qui prend trois arguments :

  • filele pointeur sur le fichier à ouvrir et à afficher.
  • parentle pointeur sur le fichier à ouvrir et à afficher, pointant vers le site QWidget à l'intérieur duquel l'éditeur doit être placé.
  • mainWindowLe destructeur est suivi d'une fonction d'initialisation qui prend trois arguments : , le pointeur sur le fichier à ouvrir et à afficher.

La fonction appelle la fonction init de base de AbstractViwer. Un nouveau widget QPlainTextEdit est créé, qui affichera le contenu du fichier. Ensuite, la fonction setup de TxtViewer est connectée au signal uiInitialized de la classe de base.

La fonction suivante renvoie la liste des types mime pris en charge par le visualiseur de texte. Seul le texte simple est pris en charge.

La dernière fonction d'initialisation ajoute des composants d'interface utilisateur spécifiques au visualiseur, tels que des menus, des icônes, des boutons et des infobulles. Elle utilise la fonctionnalité fournie par AbstractViewer pour s'assurer que ces composants sont supprimés de la fenêtre principale de l'application, une fois qu'un autre fichier est affiché avec un autre plugin de visualisation.

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

    QTextStream in(m_file.get());
#if QT_CONFIG(cursor)
    QGuiApplication::setOverrideCursor(Qt::WaitCursor);
#endif
    if (!m_textEdit->toPlainText().isEmpty()) {
        m_textEdit->clear();
        disablePrinting();
    }
    m_textEdit->setPlainText(in.readAll());
#if QT_CONFIG(cursor)
    QGuiApplication::restoreOverrideCursor();
#endif

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

openFile ouvre un fichier, transfère son contenu dans le site QPlainTextEdit, et affiche un message d'état à l'intention de l'utilisateur, selon que l'ouverture a réussi ou non.

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

#ifdef DOCUMENTVIEWER_PRINTSUPPORT
void TxtViewer::printDocument(QPrinter *printer) const
{
    if (!hasContent())
        return;

    m_textEdit->print(printer);
}
#endif // DOCUMENTVIEWER_PRINTSUPPORT

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

    QGuiApplication::setOverrideCursor(Qt::WaitCursor);
    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.")
                       .arg(QDir::toNativeSeparators(file->fileName())),
                            file->errorString();
    }
    QGuiApplication::restoreOverrideCursor();

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

    statusMessage(tr("File %1 saved")
                  .arg(QDir::toNativeSeparators(file->fileName())));
    return true;
}

bool TxtViewer::saveDocumentAs()
{
    QFileDialog dialog(mainWindow());
    dialog.setWindowModality(Qt::WindowModal);
    dialog.setAcceptMode(QFileDialog::AcceptSave);
    if (dialog.exec() != QDialog::Accepted)
        return false;

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

    //newFile();
    m_file->setFileName(files.first());
    return saveDocument();
}

void TxtViewer::retranslate()
{
    if (m_editMenu)
        m_editMenu->setTitle(tr("&Edit"));
    if (m_editToolBar)
        m_editToolBar->setWindowTitle(tr("Edit"));
    if (m_cutAct) {
        m_cutAct->setText(tr("Cu&t"));
        m_cutAct->setStatusTip(tr("Cut the current selection's contents to the "
                                "clipboard"));
    }
    if (m_copyAct) {
        m_copyAct->setText(tr("&Copy"));
        m_copyAct->setStatusTip(tr("Copy the current selection's contents to the "
                                 "clipboard"));
    }
    if (m_pasteAct) {
        m_pasteAct->setText(tr("&Paste"));
        m_pasteAct->setStatusTip(tr("Paste the clipboard's contents into the current "
                                  "selection"));
    }
}

La fonction suivante réimplémentée indique à l'application principale si le plugin de visualisation affiche ou non du contenu.

Si l'impression est prise en charge par le système de compilation, la section suivante l'implémente.

Les deux dernières réimplémentations permettent de sauvegarder le fichier actuel ou de le sauvegarder sous un nouveau nom.

Exemple de projet @ code.qt.io

© 2025 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.