qquickdroparea.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qquickdroparea_p.h"
#include "qquickdrag_p.h"
#include "qquickitem_p.h"
 
#include <private/qv4arraybuffer_p.h>
 
#include <QtCore/qregularexpression.h>
 
QT_BEGIN_NAMESPACE
 
QQuickDropAreaDrag::QQuickDropAreaDrag(QQuickDropAreaPrivate *d, QObject *parent)
    : QObject(parent)
    , d(d)
{
}
 
QQuickDropAreaDrag::~QQuickDropAreaDrag()
{
}
 
class QQuickDropAreaPrivate : public QQuickItemPrivate
{
    Q_DECLARE_PUBLIC(QQuickDropArea)
 
public:
    QQuickDropAreaPrivate();
    ~QQuickDropAreaPrivate();
 
    bool hasMatchingKey(const QStringList &keys) const;
 
    QStringList getKeys(const QMimeData *mimeData) const;
 
    QStringList keys;
    QRegularExpression keyRegExp;
    QPointF dragPosition;
    QQuickDropAreaDrag *drag;
    QPointer<QObject> source;
    bool containsDrag;
};
 
QQuickDropAreaPrivate::QQuickDropAreaPrivate()
    : drag(nullptr)
    , containsDrag(false)
{
}
 
QQuickDropAreaPrivate::~QQuickDropAreaPrivate()
{
    delete drag;
}
 
QQuickDropArea::QQuickDropArea(QQuickItem *parent)
    : QQuickItem(*new QQuickDropAreaPrivate, parent)
{
    setFlags(ItemAcceptsDrops);
}
 
QQuickDropArea::~QQuickDropArea()
{
}
 
bool QQuickDropArea::containsDrag() const
{
    Q_D(const QQuickDropArea);
    return d->containsDrag;
}
 
QStringList QQuickDropArea::keys() const
{
    Q_D(const QQuickDropArea);
    return d->keys;
}
 
void QQuickDropArea::setKeys(const QStringList &keys)
{
    Q_D(QQuickDropArea);
    if (d->keys != keys) {
        d->keys = keys;
 
        if (keys.isEmpty()) {
            d->keyRegExp = QRegularExpression();
        } else {
            QString pattern = QLatin1Char('(') + QRegularExpression::escape(keys.first());
            for (int i = 1; i < keys.size(); ++i)
                pattern += QLatin1Char('|') + QRegularExpression::escape(keys.at(i));
            pattern += QLatin1Char(')');
            d->keyRegExp = QRegularExpression(
                    QRegularExpression::anchoredPattern(pattern.replace(QLatin1String("\\*"),
                                                                        QLatin1String(".+"))));
        }
        emit keysChanged();
    }
}
 
QQuickDropAreaDrag *QQuickDropArea::drag()
{
    Q_D(QQuickDropArea);
    if (!d->drag)
        d->drag = new QQuickDropAreaDrag(d);
    return d->drag;
}
 
QObject *QQuickDropAreaDrag::source() const
{
    return d->source;
}
 
qreal QQuickDropAreaDrag::x() const
{
    return d->dragPosition.x();
}
 
qreal QQuickDropAreaDrag::y() const
{
    return d->dragPosition.y();
}
 
void QQuickDropArea::dragMoveEvent(QDragMoveEvent *event)
{
    Q_D(QQuickDropArea);
    if (!d->containsDrag)
        return;
 
    d->dragPosition = event->position().toPoint();
    if (d->drag)
        emit d->drag->positionChanged();
 
    event->accept();
    QQuickDragEvent dragTargetEvent(d, event);
    emit positionChanged(&dragTargetEvent);
}
 
bool QQuickDropAreaPrivate::hasMatchingKey(const QStringList &keys) const
{
    if (keyRegExp.pattern().isEmpty())
        return true;
 
    for (const QString &key : keys) {
        if (key.contains(keyRegExp))
            return true;
    }
    return false;
}
 
QStringList QQuickDropAreaPrivate::getKeys(const QMimeData *mimeData) const
{
    if (const QQuickDragMimeData *dragMime = qobject_cast<const QQuickDragMimeData *>(mimeData))
        return dragMime->keys();
    return mimeData->formats();
}
 
void QQuickDropArea::dragEnterEvent(QDragEnterEvent *event)
{
    Q_D(QQuickDropArea);
    const QMimeData *mimeData = event->mimeData();
    if (!d->effectiveEnable || d->containsDrag || !mimeData || !d->hasMatchingKey(d->getKeys(mimeData)))
        return;
 
    const QQuickDragMimeData *dragMime = qobject_cast<const QQuickDragMimeData *>(mimeData);
    auto dragSource = dragMime ? dragMime->source() : event->source();
 
    // if the source of the drag is an ancestor of the drop area, then dragging
    // also drags the drop area; see QTBUG-64128
    if (QQuickItem *dragSourceItem = qobject_cast<QQuickItem *>(dragSource)) {
        if (dragSourceItem->isAncestorOf(this))
            return;
    }
 
    d->dragPosition = event->position().toPoint();
 
    event->accept();
 
    QQuickDragEvent dragTargetEvent(d, event);
    emit entered(&dragTargetEvent);
    if (!event->isAccepted())
        return;
 
    d->containsDrag = true;
    d->source = dragSource;
    d->dragPosition = event->position().toPoint();
    if (d->drag) {
        emit d->drag->positionChanged();
        emit d->drag->sourceChanged();
    }
    emit containsDragChanged();
}
 
void QQuickDropArea::dragLeaveEvent(QDragLeaveEvent *)
{
    Q_D(QQuickDropArea);
    if (!d->containsDrag)
        return;
 
    emit exited();
 
    d->containsDrag = false;
    d->source = nullptr;
    emit containsDragChanged();
    if (d->drag)
        emit d->drag->sourceChanged();
}
 
void QQuickDropArea::dropEvent(QDropEvent *event)
{
    Q_D(QQuickDropArea);
    if (!d->containsDrag)
        return;
 
    QQuickDragEvent dragTargetEvent(d, event);
    emit dropped(&dragTargetEvent);
 
    d->containsDrag = false;
    d->source = nullptr;
    emit containsDragChanged();
    if (d->drag)
        emit d->drag->sourceChanged();
}
 
QObject *QQuickDragEvent::source() const
{
    if (const QQuickDragMimeData *dragMime = qobject_cast<const QQuickDragMimeData *>(event->mimeData()))
        return dragMime->source();
    else
        return event->source();
}
 
QStringList QQuickDragEvent::keys() const
{
    return d->getKeys(event->mimeData());
}
 
bool QQuickDragEvent::hasColor() const
{
    return event->mimeData()->hasColor();
}
 
bool QQuickDragEvent::hasHtml() const
{
    return event->mimeData()->hasHtml();
}
 
bool QQuickDragEvent::hasText() const
{
    return event->mimeData()->hasText();
}
 
bool QQuickDragEvent::hasUrls() const
{
    return event->mimeData()->hasUrls();
}
 
QVariant QQuickDragEvent::colorData() const
{
    return event->mimeData()->colorData();
}
 
QString QQuickDragEvent::html() const
{
    return event->mimeData()->html();
}
 
QString QQuickDragEvent::text() const
{
    return event->mimeData()->text();
}
 
QList<QUrl> QQuickDragEvent::urls() const
{
    return event->mimeData()->urls();
}
 
QStringList QQuickDragEvent::formats() const
{
    return event->mimeData()->formats();
}
 
QString QQuickDragEvent::getDataAsString(const QString &format) const
{
    return QString::fromUtf8(event->mimeData()->data(format));
}
 
QByteArray QQuickDragEvent::getDataAsArrayBuffer(const QString &format) const
{
    return event->mimeData()->data(format);
}
 
void QQuickDragEvent::acceptProposedAction()
{
    event->acceptProposedAction();
}
 
void QQuickDragEvent::accept()
{
    Qt::DropAction action = event->dropAction();
    event->setDropAction(action);
    event->accept();
}
 
void QQuickDragEvent::accept(Qt::DropAction action)
{
    // get action from arguments.
    event->setDropAction(action);
    event->accept();
}
 
 
QT_END_NAMESPACE
 
#include "moc_qquickdroparea_p.cpp"