Source code
Revision control
Copy as Markdown
// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qwasmdrag.h"
#include "qwasmbase64iconstore.h"
#include "qwasmdom.h"
#include "qwasmevent.h"
#include "qwasmintegration.h"
#include <qpa/qwindowsysteminterface.h>
#include <QtCore/private/qstdweb_p.h>
#include <QtCore/qeventloop.h>
#include <QtCore/qmimedata.h>
#include <QtCore/qtimer.h>
#include <QtGui/QPainter>
#include <QtGui/QImage>
#include <QtGui/QPixmap>
#include <QFile>
#include <private/qshapedpixmapdndwindow_p.h>
#include <private/qdnd_p.h>
#include <functional>
#include <string>
#include <utility>
QT_BEGIN_NAMESPACE
namespace {
QWindow *windowForDrag(QDrag *drag)
{
QObject *source = drag->source();
QWindow *window = nullptr;
while (source && !window) {
window = qobject_cast<QWindow *>(source);
if (!window && source->metaObject()->indexOfMethod("_q_closestWindowHandle()") != -1)
QMetaObject::invokeMethod(source, "_q_closestWindowHandle",
Q_RETURN_ARG(QWindow *, window));
if (!window)
source = source->parent();
}
return window;
}
} // namespace
struct QWasmDrag::DragState
{
class DragImage
{
public:
DragImage(const QPixmap &pixmap, const QMimeData *mimeData, QWindow *window);
~DragImage();
emscripten::val htmlElement() { return m_imageDomElement; }
QPixmap pixmap() const { return m_pixmap; }
private:
void generateDragImage(const QPixmap &pixmap, const QMimeData *mimeData);
void generateDragImageFromText(const QMimeData *mimeData);
void generateDefaultDragImage();
void generateDragImageFromPixmap(const QPixmap &pixmap);
emscripten::val m_imageDomElement = emscripten::val::undefined();
emscripten::val m_temporaryImageElementParent = emscripten::val::undefined();
QPixmap m_pixmap;
};
DragState(QDrag *drag, QWindow *window, std::function<void()> quitEventLoopClosure);
~DragState();
DragState(const QWasmDrag &other) = delete;
DragState(QWasmDrag &&other) = delete;
DragState &operator=(const QWasmDrag &other) = delete;
DragState &operator=(QWasmDrag &&other) = delete;
QDrag *drag;
QWindow *window;
std::function<void()> quitEventLoopClosure;
std::unique_ptr<DragImage> dragImage;
Qt::DropAction dropAction = Qt::DropAction::IgnoreAction;
};
QWasmDrag::QWasmDrag() = default;
QWasmDrag::~QWasmDrag() = default;
QWasmDrag *QWasmDrag::instance()
{
return static_cast<QWasmDrag *>(QWasmIntegration::get()->drag());
}
Qt::DropAction QWasmDrag::drag(QDrag *drag)
{
Q_ASSERT_X(!m_dragState, Q_FUNC_INFO, "Drag already in progress");
QWindow *window = windowForDrag(drag);
Qt::DropAction dragResult = Qt::IgnoreAction;
if (!qstdweb::haveAsyncify())
return dragResult;
auto dragState = std::make_shared<DragState>(drag, window, [this]() { QSimpleDrag::cancelDrag(); });
if (!m_isInEnterDrag)
m_dragState = dragState;
if (m_isInEnterDrag)
drag->setPixmap(QPixmap());
else if (drag->pixmap().size() == QSize(0, 0))
drag->setPixmap(dragState->dragImage->pixmap());
dragResult = QSimpleDrag::drag(drag);
m_dragState.reset();
return dragResult;
}
void QWasmDrag::onNativeDragStarted(DragEvent *event)
{
Q_ASSERT_X(event->type == EventType::DragStart, Q_FUNC_INFO,
"The event is not a DragStart event");
// It is possible for a drag start event to arrive from another window.
if (!m_dragState || m_dragState->window != event->targetWindow) {
event->cancelDragStart();
return;
}
setExecutedDropAction(event->dropAction);
// We have our own window
if (shapedPixmapWindow())
shapedPixmapWindow()->setVisible(false);
event->dataTransfer.setDragImage(m_dragState->dragImage->htmlElement(),
m_dragState->drag->hotSpot());
event->dataTransfer.setDataFromMimeData(*m_dragState->drag->mimeData());
}
void QWasmDrag::onNativeDragOver(DragEvent *event)
{
event->webEvent.call<void>("preventDefault");
auto mimeDataPreview = event->dataTransfer.toMimeDataPreview();
const Qt::DropActions actions = m_dragState
? m_dragState->drag->supportedActions()
: (Qt::DropAction::CopyAction | Qt::DropAction::MoveAction
| Qt::DropAction::LinkAction);
const auto dragResponse = QWindowSystemInterface::handleDrag(
event->targetWindow, &*mimeDataPreview, event->pointInPage.toPoint(), actions,
event->mouseButton, event->modifiers);
event->acceptDragOver();
if (dragResponse.isAccepted()) {
setExecutedDropAction(dragResponse.acceptedAction());
event->dataTransfer.setDropAction(dragResponse.acceptedAction());
} else {
setExecutedDropAction(Qt::DropAction::IgnoreAction);
event->dataTransfer.setDropAction(Qt::DropAction::IgnoreAction);
}
}
void QWasmDrag::onNativeDrop(DragEvent *event)
{
event->webEvent.call<void>("preventDefault");
QWasmWindow *wasmWindow = QWasmWindow::fromWindow(event->targetWindow);
const auto screenElementPos = dom::mapPoint(
event->target(), wasmWindow->platformScreen()->element(), event->localPoint);
const auto screenPos =
wasmWindow->platformScreen()->mapFromLocal(screenElementPos);
const QPoint targetWindowPos = event->targetWindow->mapFromGlobal(screenPos).toPoint();
const Qt::DropActions actions = m_dragState
? m_dragState->drag->supportedActions()
: (Qt::DropAction::CopyAction | Qt::DropAction::MoveAction
| Qt::DropAction::LinkAction);
Qt::MouseButton mouseButton = event->mouseButton;
QFlags<Qt::KeyboardModifier> modifiers = event->modifiers;
// Accept the native drop event: We are going to async read any dropped
// files, but the browser expects that accepted state is set before any
// async calls.
event->acceptDrop();
setExecutedDropAction(event->dropAction);
std::shared_ptr<DragState> dragState = m_dragState;
const auto dropCallback = [this, dragState, wasmWindow, targetWindowPos,
actions, mouseButton, modifiers](QMimeData *mimeData) {
if (mimeData) {
const QPlatformDropQtResponse dropResponse =
QWindowSystemInterface::handleDrop(wasmWindow->window(), mimeData,
targetWindowPos, actions,
mouseButton, modifiers);
if (dragState && dropResponse.isAccepted())
dragState->dropAction = dropResponse.acceptedAction();
delete mimeData;
}
if (!dragState)
QSimpleDrag::cancelDrag();
};
event->dataTransfer.toMimeDataWithFile(dropCallback);
}
void QWasmDrag::onNativeDragFinished(DragEvent *event, QWasmScreen *platformScreen)
{
// Keep sourcewindow before it is reset
QPointer<QWindow> sourceWindow = m_sourceWindow;
event->webEvent.call<void>("preventDefault");
if (m_dragState)
m_dragState->dropAction = event->dropAction;
setExecutedDropAction(event->dropAction);
if (m_dragState)
m_dragState->quitEventLoopClosure();
// Send synthetic mouserelease event
const MouseEvent mouseEvent(*event);
const auto pointInScreen = platformScreen->mapFromLocal(
dom::mapPoint(mouseEvent.target(), platformScreen->element(), mouseEvent.localPoint));
const auto geometryF = platformScreen->geometry().toRectF();
QPointF targetPointClippedToScreen(
qBound(geometryF.left(), pointInScreen.x(), geometryF.right()),
qBound(geometryF.top(), pointInScreen.y(), geometryF.bottom()));
QTimer::singleShot(0, [sourceWindow, targetPointClippedToScreen, mouseEvent]() {
if (sourceWindow) {
const QEvent::Type eventType = QEvent::MouseButtonRelease;
QWindowSystemInterface::handleMouseEvent(
sourceWindow, QWasmIntegration::getTimestamp(),
sourceWindow->mapFromGlobal(targetPointClippedToScreen),
targetPointClippedToScreen, mouseEvent.mouseButtons, mouseEvent.mouseButton,
eventType, mouseEvent.modifiers);
}
});
}
void QWasmDrag::onNativeDragEnter(DragEvent *event)
{
event->webEvent.call<void>("preventDefault");
// Already dragging
if (QDragManager::self() && QDragManager::self()->object())
return;
// Event coming from external browser, start a drag
if (m_dragState)
m_dragState->dropAction = event->dropAction;
setExecutedDropAction(event->dropAction);
m_isInEnterDrag = true;
QDrag *drag = new QDrag(this);
drag->setMimeData(event->dataTransfer.toMimeDataPreview());
drag->exec(Qt::CopyAction | Qt::MoveAction, Qt::CopyAction);
m_isInEnterDrag = false;
}
void QWasmDrag::onNativeDragLeave(DragEvent *event)
{
event->webEvent.call<void>("preventDefault");
if (m_dragState)
m_dragState->dropAction = event->dropAction;
setExecutedDropAction(event->dropAction);
event->dataTransfer.setDropAction(Qt::DropAction::IgnoreAction);
// If we started the drag from onNativeDragEnter
// it is correct to cancel the drag.
if (m_isInEnterDrag)
cancelDrag();
}
QWasmDrag::DragState::DragImage::DragImage(const QPixmap &pixmap, const QMimeData *mimeData,
QWindow *window)
{
if (window)
m_temporaryImageElementParent = QWasmWindow::fromWindow(window)->containerElement();
generateDragImage(pixmap, mimeData);
m_imageDomElement.set("className", "hidden-drag-image");
// chromium requires the image to be the first child
if (m_temporaryImageElementParent.isUndefined())
;
else if (m_temporaryImageElementParent["childElementCount"].as<int>() == 0)
m_temporaryImageElementParent.call<void>("appendChild", m_imageDomElement);
else
m_temporaryImageElementParent.call<void>("insertBefore", m_imageDomElement, m_temporaryImageElementParent["children"][0]);
}
QWasmDrag::DragState::DragImage::~DragImage()
{
if (!m_temporaryImageElementParent.isUndefined())
m_temporaryImageElementParent.call<void>("removeChild", m_imageDomElement);
}
void QWasmDrag::DragState::DragImage::generateDragImage(
const QPixmap &pixmap,
const QMimeData *mimeData)
{
if (!pixmap.isNull())
generateDragImageFromPixmap(pixmap);
else if (mimeData && mimeData->hasFormat("text/plain"))
generateDragImageFromText(mimeData);
else
generateDefaultDragImage();
}
void QWasmDrag::DragState::DragImage::generateDragImageFromText(const QMimeData *mimeData)
{
emscripten::val dragImageElement =
emscripten::val::global("document")
.call<emscripten::val>("createElement", emscripten::val("span"));
constexpr qsizetype MaxCharactersInDragImage = 100;
const auto text = QString::fromUtf8(mimeData->data("text/plain"));
dragImageElement.set(
"innerText",
text.first(qMin(qsizetype(MaxCharactersInDragImage), text.length())).toStdString());
QRect bounds;
{
QPixmap image(QSize(200,200));
if (!image.isNull()) {
QPainter painter(&image);
bounds = painter.boundingRect(0, 0, 200, 200, 0, text);
}
}
QImage image(bounds.size(), QImage::Format_RGBA8888);
if (!image.isNull()) {
QPainter painter(&image);
painter.fillRect(bounds, QColor(255,255,255, 255)); // Transparency does not work very well :-(
painter.setPen(Qt::black);
painter.drawText(bounds, text);
m_pixmap = QPixmap::fromImage(image);
}
m_imageDomElement = dragImageElement;
}
void QWasmDrag::DragState::DragImage::generateDefaultDragImage()
{
emscripten::val dragImageElement =
emscripten::val::global("document")
.call<emscripten::val>("createElement", emscripten::val("div"));
auto innerImgElement = emscripten::val::global("document")
.call<emscripten::val>("createElement", emscripten::val("img"));
innerImgElement.set("src",
"data:image/" + std::string("svg+xml") + ";base64,"
+ std::string(Base64IconStore::get()->getIcon(
Base64IconStore::IconType::QtLogo)));
constexpr char DragImageSize[] = "50px";
dragImageElement["style"].set("width", DragImageSize);
innerImgElement["style"].set("width", DragImageSize);
dragImageElement["style"].set("display", "flex");
dragImageElement.call<void>("appendChild", innerImgElement);
QByteArray pixmap_ba =
QByteArray::fromBase64(
QString::fromLatin1(
Base64IconStore::get()->getIcon(
Base64IconStore::IconType::QtLogo)).toLocal8Bit());
if (!m_pixmap.loadFromData(pixmap_ba))
qWarning() << " Load of Qt logo failed";
m_pixmap = m_pixmap.scaled(50, 50);
m_imageDomElement = dragImageElement;
}
void QWasmDrag::DragState::DragImage::generateDragImageFromPixmap(const QPixmap &pixmap)
{
emscripten::val dragImageElement =
emscripten::val::global("document")
.call<emscripten::val>("createElement", emscripten::val("canvas"));
dragImageElement.set("width", pixmap.width());
dragImageElement.set("height", pixmap.height());
dragImageElement["style"].set(
"width", std::to_string(pixmap.width() / pixmap.devicePixelRatio()) + "px");
dragImageElement["style"].set(
"height", std::to_string(pixmap.height() / pixmap.devicePixelRatio()) + "px");
auto context2d = dragImageElement.call<emscripten::val>("getContext", emscripten::val("2d"));
auto imageData = context2d.call<emscripten::val>(
"createImageData", emscripten::val(pixmap.width()), emscripten::val(pixmap.height()));
dom::drawImageToWebImageDataArray(pixmap.toImage().convertedTo(QImage::Format::Format_RGBA8888),
imageData, QRect(0, 0, pixmap.width(), pixmap.height()));
context2d.call<void>("putImageData", imageData, emscripten::val(0), emscripten::val(0));
m_pixmap = pixmap;
m_imageDomElement = dragImageElement;
}
QWasmDrag::DragState::DragState(QDrag *drag, QWindow *window,
std::function<void()> quitEventLoopClosure)
: drag(drag), window(window), quitEventLoopClosure(std::move(quitEventLoopClosure))
{
dragImage =
std::make_unique<DragState::DragImage>(
drag->pixmap(),
drag->mimeData(),
window);
}
QWasmDrag::DragState::~DragState() = default;
QT_END_NAMESPACE