Exemple de site de dépôt

L'exemple Drop Site accepte les dépôts provenant d'autres applications et affiche les formats MIME fournis par l'objet glissant.

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 invoqué dans la fonction main().

Définition de la classe DropArea

La classe DropArea est une sous-classe de QLabel avec un slot public, clear(), et 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);

En outre, DropArea contient des réimplémentations de quatre gestionnaires d'événements 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;
};

Mise en œuvre de la classe DropArea

Dans le constructeur de DropArea, nous définissons minimum size à 200x200 pixels, frame style à 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();
}

Nous activons également les événements de chute dans DropArea en définissant la propriété acceptDrops sur true. Ensuite, nous activons la propriété autoFillBackground et invoquons la fonction clear().

Le gestionnaire d'événements dragEnterEvent() est appelé lorsqu'un déplacement est en cours et que la souris entre dans l'objet DropArea. Pour l'exemple DropSite, lorsque la souris entre dans l'objet DropArea, nous définissons son texte à "<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 invoquons acceptProposedAction() sur event, en définissant l'action de dépôt proposée. Enfin, nous émettons le signal changed(), avec en paramètre les données qui ont été déposées et les informations relatives à leur type MIME.

Pour dragMoveEvent(), nous acceptons simplement l'objet QDragMoveEvent proposé, event, avec acceptProposedAction().

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

L'implémentation de dropEvent() par 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 avec setPixmap().
• Si mimeData contient du HTML, nous l'affichons avec setText() et définissons le format de texte de DropArea comme Qt::RichText.
• Si mimeData contient du Markdown, nous l'affichons avec setText() et définissons le format de texte de DropArea comme Qt::MarkdownText.
• Si mimeData contient du texte brut, nous l'affichons avec 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 sur des lignes individuelles.
• Si mimeData contient d'autres types d'objets, nous définissons le texte de DropArea, avec setText(), sur "Impossible d'afficher les données" pour informer l'utilisateur.

DropAreaNous attribuons ensuite la valeur QPalette::Dark à backgroundRole et 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 déplacement 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 invoquons clairement clear() et acceptons ensuite l'événement proposé.

La fonction clear() attribue la valeur "<drop content>" au texte contenu dans DropArea et attribue la valeur QPalette::Dark au texte contenu dans backgroundRole. 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, et deux objets QPushButton, clearButton et quitButton.

Mise en œuvre de la classe DropSiteWindow

Dans le constructeur de DropSiteWindow, nous instançons abstractLabel et définissons sa propriété wordWrap à 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 instançons dropArea et connectons son signal changed() à l'emplacement 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. En outre, l'en-tête horizontal de l'objet formatTable est formaté de manière à ce que la deuxième colonne s'étire 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 QDialogButtonBox ici pour nous assurer que les boutons-poussoirs sont présentés dans une disposition 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() pour copyButton, clearButton et quitButton sont connectés à copy(), clear() et close(), respectivement.

Pour la mise en page, nous utilisons QVBoxLayout, mainLayout, pour disposer nos widgets verticalement. Nous fixons également le titre de la fenêtre à "Drop Site" et la taille minimale à 350x500 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);
}

Nous passons ensuite à la fonction updateFormatsTable(). Cette fonction met à jour la fenêtre formatsTable, en affichant les formats MIME de l'objet déposé sur l'objet DropArea. Tout d'abord, nous attribuons la valeur 0 à la propriété rowCount de QTableWidget. Ensuite, nous vérifions que l'objet QMimeData transmis est un objet 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 les 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 fixons son flags à Qt::ItemIsEnabled, et son text alignment à Qt::AlignTop et Qt::AlignLeft.

Un objet QString, text, est personnalisé pour afficher les données en fonction du contenu de format. Nous invoquons la fonction simplified() de QString sur text, afin d'obtenir une chaîne de caractères qui ne comporte 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 utilisant des espaces pour les séparer. 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 format et text dans formatsTable avec setItem(). Enfin, nous invoquons resizeColumnToContents() sur la première colonne de formatsTable.

La fonction main()

Dans la fonction main(), nous instançons DropSiteWindow et invoquons sa fonction show().

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

Exemple de projet @ code.qt.io