9a13743c49
Summary: During pointer motion we already had the condition that an update of focused pointer surface can only happen when no button is pressed. But there are more conditions where we try to update the focused pointer even if a button is pressed. E.g. if the stacking order changes. This happens when trying to move one of Qt's dock widgets: 1. Press inside a dock widget 2. Qt opens another window, which is underneath the cursor 3. KWin sends pointer leave to parent window 4. dock widget movement breaks This change ensures that also this sequence works as expected and the pointer gets only updated when there are no buttons pressed, no matter from where we go into the update code path. BUG: 372876 Test Plan: Dock widgets in Dolphin can be moved now. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5461
1281 lines
40 KiB
C++
1281 lines
40 KiB
C++
/********************************************************************
|
|
KWin - the KDE window manager
|
|
This file is part of the KDE project.
|
|
|
|
Copyright (C) 2013, 2016 Martin Gräßlin <mgraesslin@kde.org>
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*********************************************************************/
|
|
#include "pointer_input.h"
|
|
#include "platform.h"
|
|
#include "effects.h"
|
|
#include "input_event.h"
|
|
#include "input_event_spy.h"
|
|
#include "osd.h"
|
|
#include "screens.h"
|
|
#include "shell_client.h"
|
|
#include "wayland_cursor_theme.h"
|
|
#include "wayland_server.h"
|
|
#include "workspace.h"
|
|
#include "decorations/decoratedclient.h"
|
|
// KDecoration
|
|
#include <KDecoration2/Decoration>
|
|
// KWayland
|
|
#include <KWayland/Client/connection_thread.h>
|
|
#include <KWayland/Client/buffer.h>
|
|
#include <KWayland/Server/buffer_interface.h>
|
|
#include <KWayland/Server/datadevice_interface.h>
|
|
#include <KWayland/Server/display.h>
|
|
#include <KWayland/Server/pointerconstraints_interface.h>
|
|
#include <KWayland/Server/seat_interface.h>
|
|
#include <KWayland/Server/surface_interface.h>
|
|
// screenlocker
|
|
#include <KScreenLocker/KsldApp>
|
|
|
|
#include <KLocalizedString>
|
|
|
|
#include <QHoverEvent>
|
|
#include <QWindow>
|
|
// Wayland
|
|
#include <wayland-cursor.h>
|
|
|
|
#include <linux/input.h>
|
|
|
|
namespace KWin
|
|
{
|
|
|
|
static Qt::MouseButton buttonToQtMouseButton(uint32_t button)
|
|
{
|
|
switch (button) {
|
|
case BTN_LEFT:
|
|
return Qt::LeftButton;
|
|
case BTN_MIDDLE:
|
|
return Qt::MiddleButton;
|
|
case BTN_RIGHT:
|
|
return Qt::RightButton;
|
|
case BTN_SIDE:
|
|
// in QtWayland mapped like that
|
|
return Qt::ExtraButton1;
|
|
case BTN_EXTRA:
|
|
// in QtWayland mapped like that
|
|
return Qt::ExtraButton2;
|
|
case BTN_BACK:
|
|
return Qt::BackButton;
|
|
case BTN_FORWARD:
|
|
return Qt::ForwardButton;
|
|
case BTN_TASK:
|
|
return Qt::TaskButton;
|
|
// mapped like that in QtWayland
|
|
case 0x118:
|
|
return Qt::ExtraButton6;
|
|
case 0x119:
|
|
return Qt::ExtraButton7;
|
|
case 0x11a:
|
|
return Qt::ExtraButton8;
|
|
case 0x11b:
|
|
return Qt::ExtraButton9;
|
|
case 0x11c:
|
|
return Qt::ExtraButton10;
|
|
case 0x11d:
|
|
return Qt::ExtraButton11;
|
|
case 0x11e:
|
|
return Qt::ExtraButton12;
|
|
case 0x11f:
|
|
return Qt::ExtraButton13;
|
|
}
|
|
// all other values get mapped to ExtraButton24
|
|
// this is actually incorrect but doesn't matter in our usage
|
|
// KWin internally doesn't use these high extra buttons anyway
|
|
// it's only needed for recognizing whether buttons are pressed
|
|
// if multiple buttons are mapped to the value the evaluation whether
|
|
// buttons are pressed is correct and that's all we care about.
|
|
return Qt::ExtraButton24;
|
|
}
|
|
|
|
static bool screenContainsPos(const QPointF &pos)
|
|
{
|
|
for (int i = 0; i < screens()->count(); ++i) {
|
|
if (screens()->geometry(i).contains(pos.toPoint())) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
PointerInputRedirection::PointerInputRedirection(InputRedirection* parent)
|
|
: InputDeviceHandler(parent)
|
|
, m_cursor(nullptr)
|
|
, m_supportsWarping(Application::usesLibinput())
|
|
{
|
|
}
|
|
|
|
PointerInputRedirection::~PointerInputRedirection() = default;
|
|
|
|
void PointerInputRedirection::init()
|
|
{
|
|
Q_ASSERT(!m_inited);
|
|
m_cursor = new CursorImage(this);
|
|
m_inited = true;
|
|
connect(m_cursor, &CursorImage::changed, kwinApp()->platform(), &Platform::cursorChanged);
|
|
emit m_cursor->changed();
|
|
connect(workspace(), &Workspace::stackingOrderChanged, this, &PointerInputRedirection::update);
|
|
connect(screens(), &Screens::changed, this, &PointerInputRedirection::updateAfterScreenChange);
|
|
if (waylandServer()->hasScreenLockerIntegration()) {
|
|
connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged, this,
|
|
[this] {
|
|
waylandServer()->seat()->cancelPointerPinchGesture();
|
|
waylandServer()->seat()->cancelPointerSwipeGesture();
|
|
update();
|
|
}
|
|
);
|
|
}
|
|
connect(workspace(), &QObject::destroyed, this, [this] { m_inited = false; });
|
|
connect(waylandServer(), &QObject::destroyed, this, [this] { m_inited = false; });
|
|
connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::dragEnded, this,
|
|
[this] {
|
|
// need to force a focused pointer change
|
|
waylandServer()->seat()->setFocusedPointerSurface(nullptr);
|
|
m_window.clear();
|
|
update();
|
|
}
|
|
);
|
|
connect(this, &PointerInputRedirection::internalWindowChanged, this,
|
|
[this] {
|
|
disconnect(m_internalWindowConnection);
|
|
m_internalWindowConnection = QMetaObject::Connection();
|
|
if (m_internalWindow) {
|
|
m_internalWindowConnection = connect(m_internalWindow.data(), &QWindow::visibleChanged, this,
|
|
[this] (bool visible) {
|
|
if (!visible) {
|
|
update();
|
|
}
|
|
}
|
|
);
|
|
}
|
|
}
|
|
);
|
|
// connect the move resize of all window
|
|
auto setupMoveResizeConnection = [this] (AbstractClient *c) {
|
|
connect(c, &AbstractClient::clientStartUserMovedResized, this, &PointerInputRedirection::updateOnStartMoveResize);
|
|
connect(c, &AbstractClient::clientFinishUserMovedResized, this, &PointerInputRedirection::update);
|
|
};
|
|
const auto clients = workspace()->allClientList();
|
|
std::for_each(clients.begin(), clients.end(), setupMoveResizeConnection);
|
|
connect(workspace(), &Workspace::clientAdded, this, setupMoveResizeConnection);
|
|
connect(waylandServer(), &WaylandServer::shellClientAdded, this, setupMoveResizeConnection);
|
|
|
|
// warp the cursor to center of screen
|
|
warp(screens()->geometry().center());
|
|
updateAfterScreenChange();
|
|
}
|
|
|
|
void PointerInputRedirection::updateOnStartMoveResize()
|
|
{
|
|
breakPointerConstraints(m_window ? m_window->surface() : nullptr);
|
|
disconnectPointerConstraintsConnection();
|
|
m_window.clear();
|
|
waylandServer()->seat()->setFocusedPointerSurface(nullptr);
|
|
}
|
|
|
|
void PointerInputRedirection::updateToReset()
|
|
{
|
|
if (m_internalWindow) {
|
|
disconnect(m_internalWindowConnection);
|
|
m_internalWindowConnection = QMetaObject::Connection();
|
|
QEvent event(QEvent::Leave);
|
|
QCoreApplication::sendEvent(m_internalWindow.data(), &event);
|
|
m_internalWindow.clear();
|
|
}
|
|
if (m_decoration) {
|
|
QHoverEvent event(QEvent::HoverLeave, QPointF(), QPointF());
|
|
QCoreApplication::instance()->sendEvent(m_decoration->decoration(), &event);
|
|
m_decoration.clear();
|
|
}
|
|
if (m_window) {
|
|
if (AbstractClient *c = qobject_cast<AbstractClient*>(m_window.data())) {
|
|
c->leaveEvent();
|
|
}
|
|
disconnect(m_windowGeometryConnection);
|
|
m_windowGeometryConnection = QMetaObject::Connection();
|
|
breakPointerConstraints(m_window->surface());
|
|
disconnectPointerConstraintsConnection();
|
|
m_window.clear();
|
|
}
|
|
waylandServer()->seat()->setFocusedPointerSurface(nullptr);
|
|
}
|
|
|
|
void PointerInputRedirection::processMotion(const QPointF &pos, uint32_t time, LibInput::Device *device)
|
|
{
|
|
processMotion(pos, QSizeF(), QSizeF(), time, 0, device);
|
|
}
|
|
|
|
class PositionUpdateBlocker
|
|
{
|
|
public:
|
|
PositionUpdateBlocker(PointerInputRedirection *pointer)
|
|
: m_pointer(pointer)
|
|
{
|
|
s_counter++;
|
|
}
|
|
~PositionUpdateBlocker() {
|
|
s_counter--;
|
|
if (s_counter == 0) {
|
|
if (!s_scheduledPositions.isEmpty()) {
|
|
const auto pos = s_scheduledPositions.takeFirst();
|
|
m_pointer->processMotion(pos.pos, pos.delta, pos.deltaNonAccelerated, pos.time, pos.timeUsec, nullptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool isPositionBlocked() {
|
|
return s_counter > 0;
|
|
}
|
|
|
|
static void schedulePosition(const QPointF &pos, const QSizeF &delta, const QSizeF &deltaNonAccelerated, uint32_t time, quint64 timeUsec) {
|
|
s_scheduledPositions.append({pos, delta, deltaNonAccelerated, time, timeUsec});
|
|
}
|
|
|
|
private:
|
|
static int s_counter;
|
|
struct ScheduledPosition {
|
|
QPointF pos;
|
|
QSizeF delta;
|
|
QSizeF deltaNonAccelerated;
|
|
quint32 time;
|
|
quint64 timeUsec;
|
|
};
|
|
static QVector<ScheduledPosition> s_scheduledPositions;
|
|
|
|
PointerInputRedirection *m_pointer;
|
|
};
|
|
|
|
int PositionUpdateBlocker::s_counter = 0;
|
|
QVector<PositionUpdateBlocker::ScheduledPosition> PositionUpdateBlocker::s_scheduledPositions;
|
|
|
|
void PointerInputRedirection::processMotion(const QPointF &pos, const QSizeF &delta, const QSizeF &deltaNonAccelerated, uint32_t time, quint64 timeUsec, LibInput::Device *device)
|
|
{
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
if (PositionUpdateBlocker::isPositionBlocked()) {
|
|
PositionUpdateBlocker::schedulePosition(pos, delta, deltaNonAccelerated, time, timeUsec);
|
|
return;
|
|
}
|
|
|
|
PositionUpdateBlocker blocker(this);
|
|
updatePosition(pos);
|
|
MouseEvent event(QEvent::MouseMove, m_pos, Qt::NoButton, m_qtButtons,
|
|
m_input->keyboardModifiers(), time,
|
|
delta, deltaNonAccelerated, timeUsec, device);
|
|
event.setModifiersRelevantForGlobalShortcuts(m_input->modifiersRelevantForGlobalShortcuts());
|
|
|
|
m_input->processSpies(std::bind(&InputEventSpy::pointerEvent, std::placeholders::_1, &event));
|
|
m_input->processFilters(std::bind(&InputEventFilter::pointerEvent, std::placeholders::_1, &event, 0));
|
|
}
|
|
|
|
void PointerInputRedirection::processButton(uint32_t button, InputRedirection::PointerButtonState state, uint32_t time, LibInput::Device *device)
|
|
{
|
|
updateButton(button, state);
|
|
|
|
QEvent::Type type;
|
|
switch (state) {
|
|
case InputRedirection::PointerButtonReleased:
|
|
type = QEvent::MouseButtonRelease;
|
|
break;
|
|
case InputRedirection::PointerButtonPressed:
|
|
type = QEvent::MouseButtonPress;
|
|
break;
|
|
default:
|
|
Q_UNREACHABLE();
|
|
return;
|
|
}
|
|
|
|
MouseEvent event(type, m_pos, buttonToQtMouseButton(button), m_qtButtons,
|
|
m_input->keyboardModifiers(), time, QSizeF(), QSizeF(), 0, device);
|
|
event.setModifiersRelevantForGlobalShortcuts(m_input->modifiersRelevantForGlobalShortcuts());
|
|
event.setNativeButton(button);
|
|
|
|
m_input->processSpies(std::bind(&InputEventSpy::pointerEvent, std::placeholders::_1, &event));
|
|
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
|
|
m_input->processFilters(std::bind(&InputEventFilter::pointerEvent, std::placeholders::_1, &event, button));
|
|
}
|
|
|
|
void PointerInputRedirection::processAxis(InputRedirection::PointerAxis axis, qreal delta, uint32_t time, LibInput::Device *device)
|
|
{
|
|
if (delta == 0) {
|
|
return;
|
|
}
|
|
|
|
emit m_input->pointerAxisChanged(axis, delta);
|
|
|
|
WheelEvent wheelEvent(m_pos, delta,
|
|
(axis == InputRedirection::PointerAxisHorizontal) ? Qt::Horizontal : Qt::Vertical,
|
|
m_qtButtons, m_input->keyboardModifiers(), time, device);
|
|
wheelEvent.setModifiersRelevantForGlobalShortcuts(m_input->modifiersRelevantForGlobalShortcuts());
|
|
|
|
m_input->processSpies(std::bind(&InputEventSpy::wheelEvent, std::placeholders::_1, &wheelEvent));
|
|
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
m_input->processFilters(std::bind(&InputEventFilter::wheelEvent, std::placeholders::_1, &wheelEvent));
|
|
}
|
|
|
|
void PointerInputRedirection::processSwipeGestureBegin(int fingerCount, quint32 time, KWin::LibInput::Device *device)
|
|
{
|
|
Q_UNUSED(device)
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
|
|
m_input->processSpies(std::bind(&InputEventSpy::swipeGestureBegin, std::placeholders::_1, fingerCount, time));
|
|
m_input->processFilters(std::bind(&InputEventFilter::swipeGestureBegin, std::placeholders::_1, fingerCount, time));
|
|
}
|
|
|
|
void PointerInputRedirection::processSwipeGestureUpdate(const QSizeF &delta, quint32 time, KWin::LibInput::Device *device)
|
|
{
|
|
Q_UNUSED(device)
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
|
|
m_input->processSpies(std::bind(&InputEventSpy::swipeGestureUpdate, std::placeholders::_1, delta, time));
|
|
m_input->processFilters(std::bind(&InputEventFilter::swipeGestureUpdate, std::placeholders::_1, delta, time));
|
|
}
|
|
|
|
void PointerInputRedirection::processSwipeGestureEnd(quint32 time, KWin::LibInput::Device *device)
|
|
{
|
|
Q_UNUSED(device)
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
|
|
m_input->processSpies(std::bind(&InputEventSpy::swipeGestureEnd, std::placeholders::_1, time));
|
|
m_input->processFilters(std::bind(&InputEventFilter::swipeGestureEnd, std::placeholders::_1, time));
|
|
}
|
|
|
|
void PointerInputRedirection::processSwipeGestureCancelled(quint32 time, KWin::LibInput::Device *device)
|
|
{
|
|
Q_UNUSED(device)
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
|
|
m_input->processSpies(std::bind(&InputEventSpy::swipeGestureCancelled, std::placeholders::_1, time));
|
|
m_input->processFilters(std::bind(&InputEventFilter::swipeGestureCancelled, std::placeholders::_1, time));
|
|
}
|
|
|
|
void PointerInputRedirection::processPinchGestureBegin(int fingerCount, quint32 time, KWin::LibInput::Device *device)
|
|
{
|
|
Q_UNUSED(device)
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
|
|
m_input->processSpies(std::bind(&InputEventSpy::pinchGestureBegin, std::placeholders::_1, fingerCount, time));
|
|
m_input->processFilters(std::bind(&InputEventFilter::pinchGestureBegin, std::placeholders::_1, fingerCount, time));
|
|
}
|
|
|
|
void PointerInputRedirection::processPinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time, KWin::LibInput::Device *device)
|
|
{
|
|
Q_UNUSED(device)
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
|
|
m_input->processSpies(std::bind(&InputEventSpy::pinchGestureUpdate, std::placeholders::_1, scale, angleDelta, delta, time));
|
|
m_input->processFilters(std::bind(&InputEventFilter::pinchGestureUpdate, std::placeholders::_1, scale, angleDelta, delta, time));
|
|
}
|
|
|
|
void PointerInputRedirection::processPinchGestureEnd(quint32 time, KWin::LibInput::Device *device)
|
|
{
|
|
Q_UNUSED(device)
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
|
|
m_input->processSpies(std::bind(&InputEventSpy::pinchGestureEnd, std::placeholders::_1, time));
|
|
m_input->processFilters(std::bind(&InputEventFilter::pinchGestureEnd, std::placeholders::_1, time));
|
|
}
|
|
|
|
void PointerInputRedirection::processPinchGestureCancelled(quint32 time, KWin::LibInput::Device *device)
|
|
{
|
|
Q_UNUSED(device)
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
|
|
m_input->processSpies(std::bind(&InputEventSpy::pinchGestureCancelled, std::placeholders::_1, time));
|
|
m_input->processFilters(std::bind(&InputEventFilter::pinchGestureCancelled, std::placeholders::_1, time));
|
|
}
|
|
|
|
void PointerInputRedirection::update()
|
|
{
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
if (waylandServer()->seat()->isDragPointer()) {
|
|
// ignore during drag and drop
|
|
return;
|
|
}
|
|
if (input()->isSelectingWindow()) {
|
|
return;
|
|
}
|
|
auto areButtonsPressed = [this] {
|
|
for (auto state : qAsConst(m_buttons)) {
|
|
if (state == InputRedirection::PointerButtonPressed) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
if (areButtonsPressed()) {
|
|
return;
|
|
}
|
|
Toplevel *t = m_input->findToplevel(m_pos.toPoint());
|
|
const auto oldDeco = m_decoration;
|
|
updateInternalWindow(m_pos);
|
|
if (!m_internalWindow) {
|
|
updateDecoration(t, m_pos);
|
|
} else {
|
|
updateDecoration(waylandServer()->findClient(m_internalWindow), m_pos);
|
|
if (m_decoration) {
|
|
disconnect(m_internalWindowConnection);
|
|
m_internalWindowConnection = QMetaObject::Connection();
|
|
QEvent event(QEvent::Leave);
|
|
QCoreApplication::sendEvent(m_internalWindow.data(), &event);
|
|
m_internalWindow.clear();
|
|
}
|
|
}
|
|
if (m_decoration || m_internalWindow) {
|
|
t = nullptr;
|
|
}
|
|
if (m_decoration != oldDeco) {
|
|
emit decorationChanged();
|
|
}
|
|
auto oldWindow = m_window;
|
|
if (!oldWindow.isNull() && t == m_window.data()) {
|
|
return;
|
|
}
|
|
auto seat = waylandServer()->seat();
|
|
// disconnect old surface
|
|
if (oldWindow) {
|
|
if (AbstractClient *c = qobject_cast<AbstractClient*>(oldWindow.data())) {
|
|
c->leaveEvent();
|
|
}
|
|
disconnect(m_windowGeometryConnection);
|
|
m_windowGeometryConnection = QMetaObject::Connection();
|
|
breakPointerConstraints(oldWindow->surface());
|
|
disconnectPointerConstraintsConnection();
|
|
}
|
|
if (AbstractClient *c = qobject_cast<AbstractClient*>(t)) {
|
|
// only send enter if it wasn't on deco for the same client before
|
|
if (m_decoration.isNull() || m_decoration->client() != c) {
|
|
c->enterEvent(m_pos.toPoint());
|
|
workspace()->updateFocusMousePosition(m_pos.toPoint());
|
|
}
|
|
}
|
|
if (t && t->surface()) {
|
|
m_window = QPointer<Toplevel>(t);
|
|
// TODO: add convenient API to update global pos together with updating focused surface
|
|
warpXcbOnSurfaceLeft(t->surface());
|
|
seat->setFocusedPointerSurface(nullptr);
|
|
seat->setPointerPos(m_pos.toPoint());
|
|
seat->setFocusedPointerSurface(t->surface(), t->inputTransformation());
|
|
m_windowGeometryConnection = connect(t, &Toplevel::geometryChanged, this,
|
|
[this] {
|
|
if (m_window.isNull()) {
|
|
return;
|
|
}
|
|
// TODO: can we check on the client instead?
|
|
if (workspace()->getMovingClient()) {
|
|
// don't update while moving
|
|
return;
|
|
}
|
|
auto seat = waylandServer()->seat();
|
|
if (m_window.data()->surface() != seat->focusedPointerSurface()) {
|
|
return;
|
|
}
|
|
seat->setFocusedPointerSurfaceTransformation(m_window.data()->inputTransformation());
|
|
}
|
|
);
|
|
m_constraintsConnection = connect(m_window->surface(), &KWayland::Server::SurfaceInterface::pointerConstraintsChanged,
|
|
this, &PointerInputRedirection::enablePointerConstraints);
|
|
// check whether a pointer confinement/lock fires
|
|
m_blockConstraint = false;
|
|
enablePointerConstraints();
|
|
} else {
|
|
m_window.clear();
|
|
warpXcbOnSurfaceLeft(nullptr);
|
|
seat->setFocusedPointerSurface(nullptr);
|
|
t = nullptr;
|
|
}
|
|
}
|
|
|
|
void PointerInputRedirection::breakPointerConstraints(KWayland::Server::SurfaceInterface *surface)
|
|
{
|
|
// cancel pointer constraints
|
|
if (surface) {
|
|
auto c = surface->confinedPointer();
|
|
if (c && c->isConfined()) {
|
|
c->setConfined(false);
|
|
}
|
|
auto l = surface->lockedPointer();
|
|
if (l && l->isLocked()) {
|
|
l->setLocked(false);
|
|
}
|
|
}
|
|
disconnectConfinedPointerRegionConnection();
|
|
m_confined = false;
|
|
m_locked = false;
|
|
}
|
|
|
|
void PointerInputRedirection::breakPointerConstraints()
|
|
{
|
|
breakPointerConstraints(m_window ? m_window->surface() : nullptr);
|
|
}
|
|
|
|
void PointerInputRedirection::disconnectConfinedPointerRegionConnection()
|
|
{
|
|
disconnect(m_confinedPointerRegionConnection);
|
|
m_confinedPointerRegionConnection = QMetaObject::Connection();
|
|
}
|
|
|
|
void PointerInputRedirection::disconnectPointerConstraintsConnection()
|
|
{
|
|
disconnect(m_constraintsConnection);
|
|
m_constraintsConnection = QMetaObject::Connection();
|
|
}
|
|
|
|
template <typename T>
|
|
static QRegion getConstraintRegion(Toplevel *t, T *constraint)
|
|
{
|
|
const QRegion windowShape = t->inputShape();
|
|
const QRegion windowRegion = windowShape.isEmpty() ? QRegion(0, 0, t->clientSize().width(), t->clientSize().height()) : windowShape;
|
|
const QRegion intersected = constraint->region().isEmpty() ? windowRegion : windowRegion.intersected(constraint->region());
|
|
return intersected.translated(t->pos() + t->clientPos());
|
|
}
|
|
|
|
void PointerInputRedirection::enablePointerConstraints()
|
|
{
|
|
if (m_window.isNull()) {
|
|
return;
|
|
}
|
|
const auto s = m_window->surface();
|
|
if (!s) {
|
|
return;
|
|
}
|
|
if (s != waylandServer()->seat()->focusedPointerSurface()) {
|
|
return;
|
|
}
|
|
if (!supportsWarping()) {
|
|
return;
|
|
}
|
|
if (m_blockConstraint) {
|
|
return;
|
|
}
|
|
const auto cf = s->confinedPointer();
|
|
if (cf) {
|
|
if (cf->isConfined()) {
|
|
return;
|
|
}
|
|
const QRegion r = getConstraintRegion(m_window.data(), cf.data());
|
|
if (r.contains(m_pos.toPoint())) {
|
|
cf->setConfined(true);
|
|
m_confined = true;
|
|
m_confinedPointerRegionConnection = connect(cf.data(), &KWayland::Server::ConfinedPointerInterface::regionChanged, this,
|
|
[this] {
|
|
if (!m_window) {
|
|
return;
|
|
}
|
|
const auto s = m_window->surface();
|
|
if (!s) {
|
|
return;
|
|
}
|
|
const auto cf = s->confinedPointer();
|
|
if (!getConstraintRegion(m_window.data(), cf.data()).contains(m_pos.toPoint())) {
|
|
// pointer no longer in confined region, break the confinement
|
|
cf->setConfined(false);
|
|
m_confined = false;
|
|
} else {
|
|
if (!cf->isConfined()) {
|
|
cf->setConfined(true);
|
|
m_confined = true;
|
|
}
|
|
}
|
|
}
|
|
);
|
|
OSD::show(i18nc("notification about mouse pointer confined",
|
|
"Pointer motion confined to the current window.\nTo release pointer hold Escape for 3 seconds."),
|
|
QStringLiteral("preferences-desktop-mouse"), 5000);
|
|
return;
|
|
}
|
|
} else {
|
|
disconnectConfinedPointerRegionConnection();
|
|
}
|
|
const auto lock = s->lockedPointer();
|
|
if (lock) {
|
|
if (lock->isLocked()) {
|
|
return;
|
|
}
|
|
const QRegion r = getConstraintRegion(m_window.data(), lock.data());
|
|
if (r.contains(m_pos.toPoint())) {
|
|
lock->setLocked(true);
|
|
m_locked = true;
|
|
OSD::show(i18nc("notification about mouse pointer locked",
|
|
"Pointer locked to current position.\nTo end pointer lock hold Escape for 3 seconds."),
|
|
QStringLiteral("preferences-desktop-mouse"), 5000);
|
|
// TODO: connect to region change - is it needed at all? If the pointer is locked it's always in the region
|
|
}
|
|
}
|
|
}
|
|
|
|
void PointerInputRedirection::warpXcbOnSurfaceLeft(KWayland::Server::SurfaceInterface *newSurface)
|
|
{
|
|
auto xc = waylandServer()->xWaylandConnection();
|
|
if (!xc) {
|
|
// No XWayland, no point in warping the x cursor
|
|
return;
|
|
}
|
|
if (!kwinApp()->x11Connection()) {
|
|
return;
|
|
}
|
|
static bool s_hasXWayland119 = xcb_get_setup(kwinApp()->x11Connection())->release_number >= 11900000;
|
|
if (s_hasXWayland119) {
|
|
return;
|
|
}
|
|
if (newSurface && newSurface->client() == xc) {
|
|
// new window is an X window
|
|
return;
|
|
}
|
|
auto s = waylandServer()->seat()->focusedPointerSurface();
|
|
if (!s || s->client() != xc) {
|
|
// pointer was not on an X window
|
|
return;
|
|
}
|
|
// warp pointer to 0/0 to trigger leave events on previously focused X window
|
|
xcb_warp_pointer(connection(), XCB_WINDOW_NONE, rootWindow(), 0, 0, 0, 0, 0, 0),
|
|
xcb_flush(connection());
|
|
}
|
|
|
|
QPointF PointerInputRedirection::applyPointerConfinement(const QPointF &pos) const
|
|
{
|
|
if (!m_window) {
|
|
return pos;
|
|
}
|
|
auto s = m_window->surface();
|
|
if (!s) {
|
|
return pos;
|
|
}
|
|
auto cf = s->confinedPointer();
|
|
if (!cf) {
|
|
return pos;
|
|
}
|
|
if (!cf->isConfined()) {
|
|
return pos;
|
|
}
|
|
|
|
const QRegion confinementRegion = getConstraintRegion(m_window.data(), cf.data());
|
|
if (confinementRegion.contains(pos.toPoint())) {
|
|
return pos;
|
|
}
|
|
QPointF p = pos;
|
|
// allow either x or y to pass
|
|
p = QPointF(m_pos.x(), pos.y());
|
|
if (confinementRegion.contains(p.toPoint())) {
|
|
return p;
|
|
}
|
|
p = QPointF(pos.x(), m_pos.y());
|
|
if (confinementRegion.contains(p.toPoint())) {
|
|
return p;
|
|
}
|
|
|
|
return m_pos;
|
|
}
|
|
|
|
void PointerInputRedirection::updatePosition(const QPointF &pos)
|
|
{
|
|
if (m_locked) {
|
|
// locked pointer should not move
|
|
return;
|
|
}
|
|
// verify that at least one screen contains the pointer position
|
|
QPointF p = pos;
|
|
if (!screenContainsPos(p)) {
|
|
// allow either x or y to pass
|
|
p = QPointF(m_pos.x(), pos.y());
|
|
if (!screenContainsPos(p)) {
|
|
p = QPointF(pos.x(), m_pos.y());
|
|
if (!screenContainsPos(p)) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
p = applyPointerConfinement(p);
|
|
if (p == m_pos) {
|
|
// didn't change due to confinement
|
|
return;
|
|
}
|
|
// verify screen confinement
|
|
if (!screenContainsPos(p)) {
|
|
return;
|
|
}
|
|
m_pos = p;
|
|
emit m_input->globalPointerChanged(m_pos);
|
|
}
|
|
|
|
void PointerInputRedirection::updateButton(uint32_t button, InputRedirection::PointerButtonState state)
|
|
{
|
|
m_buttons[button] = state;
|
|
|
|
// update Qt buttons
|
|
m_qtButtons = Qt::NoButton;
|
|
for (auto it = m_buttons.constBegin(); it != m_buttons.constEnd(); ++it) {
|
|
if (it.value() == InputRedirection::PointerButtonReleased) {
|
|
continue;
|
|
}
|
|
m_qtButtons |= buttonToQtMouseButton(it.key());
|
|
}
|
|
|
|
emit m_input->pointerButtonStateChanged(button, state);
|
|
}
|
|
|
|
void PointerInputRedirection::warp(const QPointF &pos)
|
|
{
|
|
if (supportsWarping()) {
|
|
kwinApp()->platform()->warpPointer(pos);
|
|
processMotion(pos, waylandServer()->seat()->timestamp());
|
|
}
|
|
}
|
|
|
|
bool PointerInputRedirection::supportsWarping() const
|
|
{
|
|
if (!m_inited) {
|
|
return false;
|
|
}
|
|
if (m_supportsWarping) {
|
|
return true;
|
|
}
|
|
if (kwinApp()->platform()->supportsPointerWarping()) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void PointerInputRedirection::updateAfterScreenChange()
|
|
{
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
if (screenContainsPos(m_pos)) {
|
|
// pointer still on a screen
|
|
return;
|
|
}
|
|
// pointer no longer on a screen, reposition to closes screen
|
|
const QPointF pos = screens()->geometry(screens()->number(m_pos.toPoint())).center();
|
|
// TODO: better way to get timestamps
|
|
processMotion(pos, waylandServer()->seat()->timestamp());
|
|
}
|
|
|
|
QImage PointerInputRedirection::cursorImage() const
|
|
{
|
|
if (!m_inited) {
|
|
return QImage();
|
|
}
|
|
return m_cursor->image();
|
|
}
|
|
|
|
QPoint PointerInputRedirection::cursorHotSpot() const
|
|
{
|
|
if (!m_inited) {
|
|
return QPoint();
|
|
}
|
|
return m_cursor->hotSpot();
|
|
}
|
|
|
|
void PointerInputRedirection::markCursorAsRendered()
|
|
{
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
m_cursor->markAsRendered();
|
|
}
|
|
|
|
void PointerInputRedirection::setEffectsOverrideCursor(Qt::CursorShape shape)
|
|
{
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
// current pointer focus window should get a leave event
|
|
update();
|
|
m_cursor->setEffectsOverrideCursor(shape);
|
|
}
|
|
|
|
void PointerInputRedirection::removeEffectsOverrideCursor()
|
|
{
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
// cursor position might have changed while there was an effect in place
|
|
update();
|
|
m_cursor->removeEffectsOverrideCursor();
|
|
}
|
|
|
|
void PointerInputRedirection::setWindowSelectionCursor(const QByteArray &shape)
|
|
{
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
// send leave to current pointer focus window
|
|
updateToReset();
|
|
m_cursor->setWindowSelectionCursor(shape);
|
|
}
|
|
|
|
void PointerInputRedirection::removeWindowSelectionCursor()
|
|
{
|
|
if (!m_inited) {
|
|
return;
|
|
}
|
|
update();
|
|
m_cursor->removeWindowSelectionCursor();
|
|
}
|
|
|
|
CursorImage::CursorImage(PointerInputRedirection *parent)
|
|
: QObject(parent)
|
|
, m_pointer(parent)
|
|
{
|
|
connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::focusedPointerChanged, this, &CursorImage::update);
|
|
connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::dragStarted, this, &CursorImage::updateDrag);
|
|
connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::dragEnded, this,
|
|
[this] {
|
|
disconnect(m_drag.connection);
|
|
reevaluteSource();
|
|
}
|
|
);
|
|
if (waylandServer()->hasScreenLockerIntegration()) {
|
|
connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged, this, &CursorImage::reevaluteSource);
|
|
}
|
|
connect(m_pointer, &PointerInputRedirection::decorationChanged, this, &CursorImage::updateDecoration);
|
|
// connect the move resize of all window
|
|
auto setupMoveResizeConnection = [this] (AbstractClient *c) {
|
|
connect(c, &AbstractClient::moveResizedChanged, this, &CursorImage::updateMoveResize);
|
|
};
|
|
const auto clients = workspace()->allClientList();
|
|
std::for_each(clients.begin(), clients.end(), setupMoveResizeConnection);
|
|
connect(workspace(), &Workspace::clientAdded, this, setupMoveResizeConnection);
|
|
connect(waylandServer(), &WaylandServer::shellClientAdded, this, setupMoveResizeConnection);
|
|
loadThemeCursor(Qt::ArrowCursor, &m_fallbackCursor);
|
|
if (m_cursorTheme) {
|
|
connect(m_cursorTheme, &WaylandCursorTheme::themeChanged, this,
|
|
[this] {
|
|
m_cursors.clear();
|
|
loadThemeCursor(Qt::ArrowCursor, &m_fallbackCursor);
|
|
updateDecorationCursor();
|
|
updateMoveResize();
|
|
// TODO: update effects
|
|
}
|
|
);
|
|
}
|
|
m_surfaceRenderedTimer.start();
|
|
}
|
|
|
|
CursorImage::~CursorImage() = default;
|
|
|
|
void CursorImage::markAsRendered()
|
|
{
|
|
if (m_currentSource == CursorSource::DragAndDrop) {
|
|
// always sending a frame rendered to the drag icon surface to not freeze QtWayland (see https://bugreports.qt.io/browse/QTBUG-51599 )
|
|
if (auto ddi = waylandServer()->seat()->dragSource()) {
|
|
if (auto s = ddi->icon()) {
|
|
s->frameRendered(m_surfaceRenderedTimer.elapsed());
|
|
}
|
|
}
|
|
auto p = waylandServer()->seat()->dragPointer();
|
|
if (!p) {
|
|
return;
|
|
}
|
|
auto c = p->cursor();
|
|
if (!c) {
|
|
return;
|
|
}
|
|
auto cursorSurface = c->surface();
|
|
if (cursorSurface.isNull()) {
|
|
return;
|
|
}
|
|
cursorSurface->frameRendered(m_surfaceRenderedTimer.elapsed());
|
|
return;
|
|
}
|
|
if (m_currentSource != CursorSource::LockScreen && m_currentSource != CursorSource::PointerSurface) {
|
|
return;
|
|
}
|
|
auto p = waylandServer()->seat()->focusedPointer();
|
|
if (!p) {
|
|
return;
|
|
}
|
|
auto c = p->cursor();
|
|
if (!c) {
|
|
return;
|
|
}
|
|
auto cursorSurface = c->surface();
|
|
if (cursorSurface.isNull()) {
|
|
return;
|
|
}
|
|
cursorSurface->frameRendered(m_surfaceRenderedTimer.elapsed());
|
|
}
|
|
|
|
void CursorImage::update()
|
|
{
|
|
using namespace KWayland::Server;
|
|
disconnect(m_serverCursor.connection);
|
|
auto p = waylandServer()->seat()->focusedPointer();
|
|
if (p) {
|
|
m_serverCursor.connection = connect(p, &PointerInterface::cursorChanged, this, &CursorImage::updateServerCursor);
|
|
} else {
|
|
m_serverCursor.connection = QMetaObject::Connection();
|
|
}
|
|
updateServerCursor();
|
|
}
|
|
|
|
void CursorImage::updateDecoration()
|
|
{
|
|
disconnect(m_decorationConnection);
|
|
auto deco = m_pointer->decoration();
|
|
AbstractClient *c = deco.isNull() ? nullptr : deco->client();
|
|
if (c) {
|
|
m_decorationConnection = connect(c, &AbstractClient::moveResizeCursorChanged, this, &CursorImage::updateDecorationCursor);
|
|
} else {
|
|
m_decorationConnection = QMetaObject::Connection();
|
|
}
|
|
updateDecorationCursor();
|
|
}
|
|
|
|
void CursorImage::updateDecorationCursor()
|
|
{
|
|
m_decorationCursor.image = QImage();
|
|
m_decorationCursor.hotSpot = QPoint();
|
|
|
|
auto deco = m_pointer->decoration();
|
|
if (AbstractClient *c = deco.isNull() ? nullptr : deco->client()) {
|
|
loadThemeCursor(c->cursor(), &m_decorationCursor);
|
|
if (m_currentSource == CursorSource::Decoration) {
|
|
emit changed();
|
|
}
|
|
}
|
|
reevaluteSource();
|
|
}
|
|
|
|
void CursorImage::updateMoveResize()
|
|
{
|
|
m_moveResizeCursor.image = QImage();
|
|
m_moveResizeCursor.hotSpot = QPoint();
|
|
if (AbstractClient *c = workspace()->getMovingClient()) {
|
|
loadThemeCursor(c->isMove() ? Qt::SizeAllCursor : Qt::SizeBDiagCursor, &m_moveResizeCursor);
|
|
if (m_currentSource == CursorSource::MoveResize) {
|
|
emit changed();
|
|
}
|
|
}
|
|
reevaluteSource();
|
|
}
|
|
|
|
void CursorImage::updateServerCursor()
|
|
{
|
|
m_serverCursor.image = QImage();
|
|
m_serverCursor.hotSpot = QPoint();
|
|
reevaluteSource();
|
|
const bool needsEmit = m_currentSource == CursorSource::LockScreen || m_currentSource == CursorSource::PointerSurface;
|
|
auto p = waylandServer()->seat()->focusedPointer();
|
|
if (!p) {
|
|
if (needsEmit) {
|
|
emit changed();
|
|
}
|
|
return;
|
|
}
|
|
auto c = p->cursor();
|
|
if (!c) {
|
|
if (needsEmit) {
|
|
emit changed();
|
|
}
|
|
return;
|
|
}
|
|
auto cursorSurface = c->surface();
|
|
if (cursorSurface.isNull()) {
|
|
if (needsEmit) {
|
|
emit changed();
|
|
}
|
|
return;
|
|
}
|
|
auto buffer = cursorSurface.data()->buffer();
|
|
if (!buffer) {
|
|
if (needsEmit) {
|
|
emit changed();
|
|
}
|
|
return;
|
|
}
|
|
m_serverCursor.hotSpot = c->hotspot();
|
|
m_serverCursor.image = buffer->data().copy();
|
|
if (needsEmit) {
|
|
emit changed();
|
|
}
|
|
}
|
|
|
|
void CursorImage::loadTheme()
|
|
{
|
|
if (m_cursorTheme) {
|
|
return;
|
|
}
|
|
// check whether we can create it
|
|
if (waylandServer()->internalShmPool()) {
|
|
m_cursorTheme = new WaylandCursorTheme(waylandServer()->internalShmPool(), this);
|
|
connect(waylandServer(), &WaylandServer::terminatingInternalClientConnection, this,
|
|
[this] {
|
|
delete m_cursorTheme;
|
|
m_cursorTheme = nullptr;
|
|
}
|
|
);
|
|
}
|
|
}
|
|
|
|
void CursorImage::setEffectsOverrideCursor(Qt::CursorShape shape)
|
|
{
|
|
loadThemeCursor(shape, &m_effectsCursor);
|
|
if (m_currentSource == CursorSource::EffectsOverride) {
|
|
emit changed();
|
|
}
|
|
reevaluteSource();
|
|
}
|
|
|
|
void CursorImage::removeEffectsOverrideCursor()
|
|
{
|
|
reevaluteSource();
|
|
}
|
|
|
|
void CursorImage::setWindowSelectionCursor(const QByteArray &shape)
|
|
{
|
|
if (shape.isEmpty()) {
|
|
loadThemeCursor(Qt::CrossCursor, &m_windowSelectionCursor);
|
|
} else {
|
|
loadThemeCursor(shape, &m_windowSelectionCursor);
|
|
}
|
|
if (m_currentSource == CursorSource::WindowSelector) {
|
|
emit changed();
|
|
}
|
|
reevaluteSource();
|
|
}
|
|
|
|
void CursorImage::removeWindowSelectionCursor()
|
|
{
|
|
reevaluteSource();
|
|
}
|
|
|
|
void CursorImage::updateDrag()
|
|
{
|
|
using namespace KWayland::Server;
|
|
disconnect(m_drag.connection);
|
|
m_drag.cursor.image = QImage();
|
|
m_drag.cursor.hotSpot = QPoint();
|
|
reevaluteSource();
|
|
if (auto p = waylandServer()->seat()->dragPointer()) {
|
|
m_drag.connection = connect(p, &PointerInterface::cursorChanged, this, &CursorImage::updateDragCursor);
|
|
} else {
|
|
m_drag.connection = QMetaObject::Connection();
|
|
}
|
|
updateDragCursor();
|
|
}
|
|
|
|
void CursorImage::updateDragCursor()
|
|
{
|
|
m_drag.cursor.image = QImage();
|
|
m_drag.cursor.hotSpot = QPoint();
|
|
const bool needsEmit = m_currentSource == CursorSource::DragAndDrop;
|
|
QImage additionalIcon;
|
|
if (auto ddi = waylandServer()->seat()->dragSource()) {
|
|
if (auto dragIcon = ddi->icon()) {
|
|
if (auto buffer = dragIcon->buffer()) {
|
|
additionalIcon = buffer->data().copy();
|
|
}
|
|
}
|
|
}
|
|
auto p = waylandServer()->seat()->dragPointer();
|
|
if (!p) {
|
|
if (needsEmit) {
|
|
emit changed();
|
|
}
|
|
return;
|
|
}
|
|
auto c = p->cursor();
|
|
if (!c) {
|
|
if (needsEmit) {
|
|
emit changed();
|
|
}
|
|
return;
|
|
}
|
|
auto cursorSurface = c->surface();
|
|
if (cursorSurface.isNull()) {
|
|
if (needsEmit) {
|
|
emit changed();
|
|
}
|
|
return;
|
|
}
|
|
auto buffer = cursorSurface.data()->buffer();
|
|
if (!buffer) {
|
|
if (needsEmit) {
|
|
emit changed();
|
|
}
|
|
return;
|
|
}
|
|
m_drag.cursor.hotSpot = c->hotspot();
|
|
m_drag.cursor.image = buffer->data().copy();
|
|
if (needsEmit) {
|
|
emit changed();
|
|
}
|
|
// TODO: add the cursor image
|
|
}
|
|
|
|
void CursorImage::loadThemeCursor(Qt::CursorShape shape, Image *image)
|
|
{
|
|
loadThemeCursor(shape, m_cursors, image);
|
|
}
|
|
|
|
void CursorImage::loadThemeCursor(const QByteArray &shape, Image *image)
|
|
{
|
|
loadThemeCursor(shape, m_cursorsByName, image);
|
|
}
|
|
|
|
template <typename T>
|
|
void CursorImage::loadThemeCursor(const T &shape, QHash<T, Image> &cursors, Image *image)
|
|
{
|
|
loadTheme();
|
|
if (!m_cursorTheme) {
|
|
return;
|
|
}
|
|
auto it = cursors.constFind(shape);
|
|
if (it == cursors.constEnd()) {
|
|
image->image = QImage();
|
|
image->hotSpot = QPoint();
|
|
wl_cursor_image *cursor = m_cursorTheme->get(shape);
|
|
if (!cursor) {
|
|
return;
|
|
}
|
|
wl_buffer *b = wl_cursor_image_get_buffer(cursor);
|
|
if (!b) {
|
|
return;
|
|
}
|
|
waylandServer()->internalClientConection()->flush();
|
|
waylandServer()->dispatch();
|
|
auto buffer = KWayland::Server::BufferInterface::get(waylandServer()->internalConnection()->getResource(KWayland::Client::Buffer::getId(b)));
|
|
if (!buffer) {
|
|
return;
|
|
}
|
|
it = decltype(it)(cursors.insert(shape, {buffer->data().copy(), QPoint(cursor->hotspot_x, cursor->hotspot_y)}));
|
|
}
|
|
image->hotSpot = it.value().hotSpot;
|
|
image->image = it.value().image;
|
|
}
|
|
|
|
void CursorImage::reevaluteSource()
|
|
{
|
|
if (waylandServer()->seat()->isDragPointer()) {
|
|
// TODO: touch drag?
|
|
setSource(CursorSource::DragAndDrop);
|
|
return;
|
|
}
|
|
if (waylandServer()->isScreenLocked()) {
|
|
setSource(CursorSource::LockScreen);
|
|
return;
|
|
}
|
|
if (input()->isSelectingWindow()) {
|
|
setSource(CursorSource::WindowSelector);
|
|
return;
|
|
}
|
|
if (effects && static_cast<EffectsHandlerImpl*>(effects)->isMouseInterception()) {
|
|
setSource(CursorSource::EffectsOverride);
|
|
return;
|
|
}
|
|
if (workspace() && workspace()->getMovingClient()) {
|
|
setSource(CursorSource::MoveResize);
|
|
return;
|
|
}
|
|
if (!m_pointer->decoration().isNull()) {
|
|
setSource(CursorSource::Decoration);
|
|
return;
|
|
}
|
|
if (!m_pointer->window().isNull()) {
|
|
setSource(CursorSource::PointerSurface);
|
|
return;
|
|
}
|
|
setSource(CursorSource::Fallback);
|
|
}
|
|
|
|
void CursorImage::setSource(CursorSource source)
|
|
{
|
|
if (m_currentSource == source) {
|
|
return;
|
|
}
|
|
m_currentSource = source;
|
|
emit changed();
|
|
}
|
|
|
|
QImage CursorImage::image() const
|
|
{
|
|
switch (m_currentSource) {
|
|
case CursorSource::EffectsOverride:
|
|
return m_effectsCursor.image;
|
|
case CursorSource::MoveResize:
|
|
return m_moveResizeCursor.image;
|
|
case CursorSource::LockScreen:
|
|
case CursorSource::PointerSurface:
|
|
// lockscreen also uses server cursor image
|
|
return m_serverCursor.image;
|
|
case CursorSource::Decoration:
|
|
return m_decorationCursor.image;
|
|
case CursorSource::DragAndDrop:
|
|
return m_drag.cursor.image;
|
|
case CursorSource::Fallback:
|
|
return m_fallbackCursor.image;
|
|
case CursorSource::WindowSelector:
|
|
return m_windowSelectionCursor.image;
|
|
default:
|
|
Q_UNREACHABLE();
|
|
}
|
|
}
|
|
|
|
QPoint CursorImage::hotSpot() const
|
|
{
|
|
switch (m_currentSource) {
|
|
case CursorSource::EffectsOverride:
|
|
return m_effectsCursor.hotSpot;
|
|
case CursorSource::MoveResize:
|
|
return m_moveResizeCursor.hotSpot;
|
|
case CursorSource::LockScreen:
|
|
case CursorSource::PointerSurface:
|
|
// lockscreen also uses server cursor image
|
|
return m_serverCursor.hotSpot;
|
|
case CursorSource::Decoration:
|
|
return m_decorationCursor.hotSpot;
|
|
case CursorSource::DragAndDrop:
|
|
return m_drag.cursor.hotSpot;
|
|
case CursorSource::Fallback:
|
|
return m_fallbackCursor.hotSpot;
|
|
case CursorSource::WindowSelector:
|
|
return m_windowSelectionCursor.hotSpot;
|
|
default:
|
|
Q_UNREACHABLE();
|
|
}
|
|
}
|
|
|
|
}
|