Exemple de site de dépôt

L'exemple « Drop Site » accepte les dépose provenant d'autres applications et affiche les formats MIME fournis par l'objet glissé.

Cet exemple comporte deux classes, ` DropArea ` et ` DropSiteWindow`, ainsi qu’une fonction ` main() `. Un objet ` DropArea ` est instancié dans ` DropSiteWindow` ; un objet ` DropSiteWindow ` est ensuite appelé dans la fonction ` main() `.

Définition de la classe DropArea

La classe DropArea est une sous-classe de QLabel dotée d’un slot public, clear(), et d’un signal changed().

class DropArea : public QLabel
{
    Q_OBJECT

public:
    explicit DropArea(QWidget *parent = nullptr);

public slots:
    void clear();

signals:
    void changed(const QMimeData *mimeData = nullptr);

De plus, DropArea contient des réimplémentations de quatre gestionnaires d’événements d’ QWidget:

1. dragEnterEvent()
2. dragMoveEvent()
3. dragLeaveEvent()
4. dropEvent()

Ces gestionnaires d'événements sont expliqués plus en détail dans l'implémentation de la classe DropArea.

protected:
    void dragEnterEvent(QDragEnterEvent *event) override;
    void dragMoveEvent(QDragMoveEvent *event) override;
    void dragLeaveEvent(QDragLeaveEvent *event) override;
    void dropEvent(QDropEvent *event) override;
};

Implémentation de la classe DropArea

Dans le constructeur de la classe ` DropArea `, nous définissons la propriété ` minimum size ` à 200 × 200 pixels, la propriété ` frame style ` à la fois sur ` QFrame::Sunken ` et ` QFrame::StyledPanel`, et nous alignons son contenu au centre.

DropArea::DropArea(QWidget *parent)
    : QLabel(parent)
{
    setMinimumSize(200, 200);
    setFrameStyle(QFrame::Sunken | QFrame::StyledPanel);
    setAlignment(Qt::AlignCenter);
    setAcceptDrops(true);
    setAutoFillBackground(true);
    clear();
}

De plus, nous activons les événements de dépôt ( DropArea ) en définissant la propriété ` acceptDrops ` sur ` true`. Ensuite, nous activons la propriété ` autoFillBackground ` et appelons la fonction ` clear() `.

Le gestionnaire d’événements dragEnterEvent() est appelé lorsqu’un glissement est en cours et que la souris pénètre dans l’objet DropArea. Dans l’exemple DropSite, lorsque la souris pénètre dans DropArea, nous définissons son texte sur « <drop content> » et mettons son arrière-plan en surbrillance.

void DropArea::dragEnterEvent(QDragEnterEvent *event)
{
    setText(tr("<drop content>"));
    setBackgroundRole(QPalette::Highlight);

    event->acceptProposedAction();
    emit changed(event->mimeData());
}

Ensuite, nous appelons la méthode ` acceptProposedAction()` sur ` event`, en définissant l’action de dépôt sur celle proposée. Enfin, nous émettons le signal ` changed() `, en passant en paramètre les données qui ont été déposées ainsi que les informations relatives à leur type MIME.

Pour la méthode ` dragMoveEvent()`, nous acceptons simplement l’objet ` QDragMoveEvent ` proposé, ` event`, à l’aide de ` acceptProposedAction()`.

void DropArea::dragMoveEvent(QDragMoveEvent *event)
{
    event->acceptProposedAction();
}

L’implémentation de la méthode ` dropEvent()` de la classe ` DropArea ` extrait les données MIME de ` event` et les affiche en conséquence.

void DropArea::dropEvent(QDropEvent *event)
{
    const QMimeData *mimeData = event->mimeData();

L'objet ` mimeData ` peut contenir l'un des objets suivants : une image, du texte HTML, du texte Markdown, du texte brut ou une liste d'URL.

    if (mimeData->hasImage()) {
        setPixmap(qvariant_cast<QPixmap>(mimeData->imageData()));
    } else if (mimeData->hasColor()) {
        const auto color = mimeData->colorData().value<QColor>();
        setText(tr("Color: %1").arg(color.name()));
        setPalette(QPalette(color));
        setBackgroundRole(QPalette::Button);
    } else if (mimeData->hasFormat(u"text/markdown"_s)) {
        setText(QString::fromUtf8(mimeData->data(u"text/markdown"_s)));
        setTextFormat(Qt::MarkdownText);
    } else if (mimeData->hasHtml()) {
        setText(mimeData->html());
        setTextFormat(Qt::RichText);
    } else if (mimeData->hasText()) {
        setText(mimeData->text());
        setTextFormat(Qt::PlainText);
    } else if (mimeData->hasUrls()) {
        QList<QUrl> urlList = mimeData->urls();
        QString text;
        for (qsizetype i = 0, count = qMin(urlList.size(), qsizetype(32)); i < count; ++i)
            text += urlList.at(i).path() + u'\n';
        setText(text);
    } else {
        setText(tr("Cannot display data"));
    }

• Si ` mimeData ` contient une image, nous l'affichons dans ` DropArea ` à l'aide de ` setPixmap()`.
• Si mimeData contient du code HTML, nous l'affichons à l'aide de setText() et définissons le format de texte de DropArea sur Qt::RichText.
• Si mimeData contient du Markdown, nous l'affichons à l'aide de setText() et définissons le format de texte de DropArea sur Qt::MarkdownText.
• Si mimeData contient du texte brut, nous l’affichons à l’aide de setText() et définissons le format de texte de DropArea comme Qt::PlainText. Si mimeData contient des URL, nous parcourons la liste des URL pour les afficher chacune sur une ligne distincte.
• Si mimeData contient d’autres types d’objets, nous définissons le texte de DropArea, avec setText(), sur « Impossible d’afficher les données » afin d’en informer l’utilisateur.

Nous définissons ensuite l'backgroundRole de DropArea sur QPalette::Dark, puis nous acceptons l'action proposée par event.

    if (!mimeData->hasColor()) {
        setPalette({});
        setBackgroundRole(QPalette::Dark);
    }
    event->acceptProposedAction();
}

Le gestionnaire d’événements dragLeaveEvent() est appelé lorsqu’un glissement est en cours et que la souris quitte le widget.

void DropArea::dragLeaveEvent(QDragLeaveEvent *event)
{
    clear();
    event->accept();
}

Pour l’implémentation de DropArea, nous appelons clear(), puis acceptons l’événement proposé.

La fonction ` clear() ` définit le texte de ` DropArea ` sur « <drop content> » et définit ` backgroundRole ` sur ` QPalette::Dark`. Enfin, elle émet le signal ` changed() `.

void DropArea::clear()
{
    setText(tr("<drop content>"));
    setBackgroundRole(QPalette::Dark);

    emit changed();
}

Définition de la classe DropSiteWindow

La classe DropSiteWindow contient un constructeur et un slot public, updateFormatsTable().

class DropSiteWindow : public QWidget
{
    Q_OBJECT

public:
    DropSiteWindow();

public slots:
    void updateFormatsTable(const QMimeData *mimeData);
    void copy();

private:
    DropArea *dropArea;
    QLabel *abstractLabel;
    QTableWidget *formatsTable;

    QPushButton *clearButton;
    QPushButton *copyButton;
    QPushButton *quitButton;
    QDialogButtonBox *buttonBox;
};

La classe contient également une instance privée de DropArea, dropArea, QLabel, abstractLabel, QTableWidget, formatsTable, QDialogButtonBox, buttonBox, ainsi que deux objets QPushButton, clearButton et quitButton.

Implémentation de la classe DropSiteWindow

Dans le constructeur de ` DropSiteWindow`, nous instancions ` abstractLabel ` et définissons sa propriété ` wordWrap ` sur ` true`. Nous appelons également la fonction ` adjustSize()` pour ajuster la taille de ` abstractLabel` en fonction de son contenu.

DropSiteWindow::DropSiteWindow()
{
    abstractLabel = new QLabel(tr("This example accepts drags from other "
                                  "applications and displays the MIME types "
                                  "provided by the drag object."));
    abstractLabel->setWordWrap(true);
    abstractLabel->adjustSize();

Ensuite, nous instancions dropArea et connectons son signal changed() au slot updateFormatsTable() de DropSiteWindow.

    dropArea = new DropArea;
    connect(dropArea, &DropArea::changed,
            this, &DropSiteWindow::updateFormatsTable);

Nous configurons maintenant l’objet ` QTableWidget `, ` formatsTable`. Son en-tête horizontal est défini à l’aide d’un objet ` QStringList `, ` labels`. Le nombre de colonnes est fixé à deux et le tableau n’est pas modifiable. De plus, l’en-tête horizontal de ` formatTable` est formaté de manière à ce que sa deuxième colonne s’étende pour occuper l’espace supplémentaire disponible.

    formatsTable = new QTableWidget;
    formatsTable->setColumnCount(2);
    formatsTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
    formatsTable->setHorizontalHeaderLabels({tr("Format"),  tr("Content")});
    formatsTable->horizontalHeader()->setStretchLastSection(true);

Trois objets ` QPushButton `, clearButton, copyButton et quitButton, sont instanciés et ajoutés à buttonBox — un objet ` QDialogButtonBox `. Nous utilisons ici ` QDialogButtonBox ` pour garantir que les boutons soient présentés selon une mise en page conforme au style de la plateforme.

    clearButton = new QPushButton(tr("Clear"));
    copyButton = new QPushButton(tr("Copy"));
    quitButton = new QPushButton(tr("Quit"));

    buttonBox = new QDialogButtonBox;
    buttonBox->addButton(clearButton, QDialogButtonBox::ActionRole);
    buttonBox->addButton(copyButton, QDialogButtonBox::ActionRole);
#if !QT_CONFIG(clipboard)
    copyButton->setVisible(false);
#endif

    buttonBox->addButton(quitButton, QDialogButtonBox::RejectRole);

    connect(quitButton, &QAbstractButton::clicked, this, &QWidget::close);
    connect(clearButton, &QAbstractButton::clicked, dropArea, &DropArea::clear);
    connect(copyButton, &QAbstractButton::clicked, this, &DropSiteWindow::copy);

Les signaux ` clicked()` de ` copyButton`, ` clearButton` et ` quitButton ` sont respectivement connectés à ` copy()`, ` clear() ` et ` close()`.

Pour la mise en page, nous utilisons un QVBoxLayout, mainLayout, afin d’agencer nos widgets verticalement. Nous définissons également le titre de la fenêtre sur « Drop Site » et la taille minimale sur 350 × 500 pixels.

    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    mainLayout->addWidget(abstractLabel);
    mainLayout->addWidget(dropArea);
    mainLayout->addWidget(formatsTable);
    mainLayout->addWidget(buttonBox);

    setWindowTitle(tr("Drop Site"));
    resize(700, 500);
}

Passons maintenant à la fonction ` updateFormatsTable() `. Cette fonction met à jour la propriété ` formatsTable`, affichant les formats MIME de l’objet déposé sur l’objet ` DropArea `. Tout d’abord, nous définissons la propriété ` rowCount ` de ` QTableWidget` sur 0. Ensuite, nous effectuons une validation pour nous assurer que l’objet ` QMimeData ` transmis est valide.

void DropSiteWindow::updateFormatsTable(const QMimeData *mimeData)
{
    formatsTable->setRowCount(0);
    copyButton->setEnabled(false);
    if (!mimeData)
        return;

Une fois que nous sommes sûrs que mimeData est valide, nous parcourons ses formats pris en charge.

    const QStringList formats = mimeData->formats();
    for (const QString &format : formats) {
        QTableWidgetItem *formatItem = new QTableWidgetItem(format);
        formatItem->setFlags(Qt::ItemIsEnabled);
        formatItem->setTextAlignment(Qt::AlignTop | Qt::AlignLeft);

À chaque itération, nous créons un objet ` QTableWidgetItem`, ` formatItem `, et nous définissons son ` flags ` sur ` Qt::ItemIsEnabled`, ainsi que ses ` text alignment ` sur ` Qt::AlignTop ` et ` Qt::AlignLeft`.

Un objet ` QString `, ` text`, est personnalisé pour afficher les données en fonction du contenu de ` format`. Nous appelons la fonction ` simplified()` de ` QString` sur ` text`, afin d’obtenir une chaîne de caractères ne comportant aucun espace supplémentaire avant, après ou entre les mots.

        QString text;
        if (format == u"text/plain") {
            text = mimeData->text().simplified();
        } else if (format == u"text/markdown") {
            text = QString::fromUtf8(mimeData->data(u"text/markdown"_s));
        } else if (format == u"text/html") {
            text = mimeData->html().simplified();
        } else if (format == u"text/uri-list") {
            QList<QUrl> urlList = mimeData->urls();
            for (qsizetype i = 0, count = qMin(urlList.size(), qsizetype(32)); i < count; ++i)
                text.append(urlList.at(i).toString() + u' ');
        } else {
            QByteArray data = mimeData->data(format);
            if (data.size() > 32)
                data.truncate(32);
            text = QString::fromLatin1(data.toHex(' ')).toUpper();
        }

Si format contient une liste d'URL, nous les parcourons en les séparant par des espaces. En revanche, si format contient une image, nous affichons les données en convertissant le texte en hexadécimal.

        int row = formatsTable->rowCount();
        formatsTable->insertRow(row);
        formatsTable->setItem(row, 0, new QTableWidgetItem(format));
        formatsTable->setItem(row, 1, new QTableWidgetItem(text));
    }

    formatsTable->resizeColumnToContents(0);
#if QT_CONFIG(clipboard)
    copyButton->setEnabled(formatsTable->rowCount() > 0);
#endif
}

Une fois que text a été personnalisé pour contenir les données appropriées, nous insérons à la fois format et text dans formatsTable à l'aide de setItem(). Enfin, nous appelons resizeColumnToContents() sur la première colonne de formatsTable.

La fonction main()

Dans la fonction main(), nous instancions DropSiteWindow et appelons sa fonction show().

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    DropSiteWindow window;
    window.show();
    return app.exec();
}

Exemple de projet sur code.qt.io