2020-08-02 22:22:19 +00:00
|
|
|
/*
|
|
|
|
KWin - the KDE window manager
|
|
|
|
This file is part of the KDE project.
|
2013-06-17 07:35:45 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-FileCopyrightText: 2019 Roman Gilg <subdiff@gmail.com>
|
|
|
|
SPDX-FileCopyrightText: 2013 Martin Gräßlin <mgraesslin@kde.org>
|
2013-06-17 07:35:45 +00:00
|
|
|
|
2020-08-02 22:22:19 +00:00
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
*/
|
2013-06-17 07:35:45 +00:00
|
|
|
#include "wayland_backend.h"
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
|
2020-10-06 23:36:18 +00:00
|
|
|
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
#if HAVE_WAYLAND_EGL
|
|
|
|
#include "egl_wayland_backend.h"
|
2020-10-06 23:36:18 +00:00
|
|
|
#if HAVE_GBM
|
|
|
|
#include "../drm/gbm_dmabuf.h"
|
|
|
|
#include <gbm.h>
|
|
|
|
#endif
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
#endif
|
2015-05-05 15:27:03 +00:00
|
|
|
#include "logging.h"
|
2015-05-05 13:13:36 +00:00
|
|
|
#include "scene_qpainter_wayland_backend.h"
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
#include "wayland_output.h"
|
|
|
|
|
|
|
|
#include "composite.h"
|
|
|
|
#include "cursor.h"
|
|
|
|
#include "input.h"
|
|
|
|
#include "main.h"
|
|
|
|
#include "outputscreens.h"
|
|
|
|
#include "pointer_input.h"
|
2015-11-17 09:43:10 +00:00
|
|
|
#include "screens.h"
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
#include "wayland_server.h"
|
|
|
|
|
2014-09-19 11:59:51 +00:00
|
|
|
#include <KWayland/Client/buffer.h>
|
|
|
|
#include <KWayland/Client/compositor.h>
|
|
|
|
#include <KWayland/Client/connection_thread.h>
|
2014-09-23 11:15:49 +00:00
|
|
|
#include <KWayland/Client/event_queue.h>
|
2014-09-19 11:59:51 +00:00
|
|
|
#include <KWayland/Client/keyboard.h>
|
|
|
|
#include <KWayland/Client/pointer.h>
|
2016-11-24 12:51:15 +00:00
|
|
|
#include <KWayland/Client/pointerconstraints.h>
|
2017-03-15 16:56:08 +00:00
|
|
|
#include <KWayland/Client/pointergestures.h>
|
2014-09-19 11:59:51 +00:00
|
|
|
#include <KWayland/Client/registry.h>
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
#include <KWayland/Client/relativepointer.h>
|
2014-09-19 11:59:51 +00:00
|
|
|
#include <KWayland/Client/seat.h>
|
2015-12-17 14:32:41 +00:00
|
|
|
#include <KWayland/Client/server_decoration.h>
|
2014-09-19 11:59:51 +00:00
|
|
|
#include <KWayland/Client/shm_pool.h>
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
#include <KWayland/Client/subcompositor.h>
|
|
|
|
#include <KWayland/Client/subsurface.h>
|
2014-09-19 11:59:51 +00:00
|
|
|
#include <KWayland/Client/surface.h>
|
2015-03-25 13:50:14 +00:00
|
|
|
#include <KWayland/Client/touch.h>
|
2016-07-11 07:59:05 +00:00
|
|
|
#include <KWayland/Client/xdgshell.h>
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
|
2020-04-29 15:18:41 +00:00
|
|
|
#include <KWaylandServer/seat_interface.h>
|
2016-11-24 12:51:15 +00:00
|
|
|
|
2015-02-21 08:30:22 +00:00
|
|
|
#include <QMetaMethod>
|
2014-08-13 10:54:02 +00:00
|
|
|
#include <QThread>
|
2013-06-17 07:35:45 +00:00
|
|
|
|
2016-11-24 12:51:15 +00:00
|
|
|
#include <linux/input.h>
|
2020-07-22 17:31:23 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <fcntl.h>
|
2016-11-24 12:51:15 +00:00
|
|
|
|
2013-06-17 07:35:45 +00:00
|
|
|
namespace KWin
|
|
|
|
{
|
|
|
|
namespace Wayland
|
|
|
|
{
|
|
|
|
|
2014-09-19 11:59:51 +00:00
|
|
|
using namespace KWayland::Client;
|
|
|
|
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
WaylandCursor::WaylandCursor(WaylandBackend *backend)
|
|
|
|
: QObject(backend)
|
|
|
|
, m_backend(backend)
|
|
|
|
{
|
|
|
|
resetSurface();
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandCursor::resetSurface()
|
|
|
|
{
|
|
|
|
delete m_surface;
|
|
|
|
m_surface = backend()->compositor()->createSurface(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandCursor::init()
|
|
|
|
{
|
|
|
|
installImage();
|
|
|
|
}
|
|
|
|
|
|
|
|
WaylandCursor::~WaylandCursor()
|
|
|
|
{
|
|
|
|
delete m_surface;
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandCursor::installImage()
|
|
|
|
{
|
2020-04-02 16:18:01 +00:00
|
|
|
const QImage image = Cursors::self()->currentCursor()->image();
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
if (image.isNull() || image.size().isEmpty()) {
|
|
|
|
doInstallImage(nullptr, QSize());
|
|
|
|
return;
|
|
|
|
}
|
2020-03-15 19:59:29 +00:00
|
|
|
|
|
|
|
auto buffer = m_backend->shmPool()->createBuffer(image).toStrongRef();
|
|
|
|
wl_buffer *imageBuffer = *buffer.data();
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
doInstallImage(imageBuffer, image.size());
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandCursor::doInstallImage(wl_buffer *image, const QSize &size)
|
|
|
|
{
|
|
|
|
auto *pointer = m_backend->seat()->pointer();
|
|
|
|
if (!pointer || !pointer->isValid()) {
|
|
|
|
return;
|
|
|
|
}
|
2020-04-02 16:18:01 +00:00
|
|
|
pointer->setCursor(m_surface, image ? Cursors::self()->currentCursor()->hotspot() : QPoint());
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
drawSurface(image, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandCursor::drawSurface(wl_buffer *image, const QSize &size)
|
|
|
|
{
|
|
|
|
m_surface->attachBuffer(image);
|
|
|
|
m_surface->damage(QRect(QPoint(0,0), size));
|
|
|
|
m_surface->commit(Surface::CommitFlag::None);
|
|
|
|
m_backend->flush();
|
|
|
|
}
|
|
|
|
|
|
|
|
WaylandSubSurfaceCursor::WaylandSubSurfaceCursor(WaylandBackend *backend)
|
|
|
|
: WaylandCursor(backend)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandSubSurfaceCursor::init()
|
|
|
|
{
|
|
|
|
if (auto *pointer = backend()->seat()->pointer()) {
|
|
|
|
pointer->hideCursor();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
WaylandSubSurfaceCursor::~WaylandSubSurfaceCursor()
|
|
|
|
{
|
|
|
|
delete m_subSurface;
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandSubSurfaceCursor::changeOutput(WaylandOutput *output)
|
|
|
|
{
|
|
|
|
delete m_subSurface;
|
|
|
|
m_subSurface = nullptr;
|
|
|
|
m_output = output;
|
|
|
|
if (!output) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
createSubSurface();
|
|
|
|
surface()->commit();
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandSubSurfaceCursor::createSubSurface()
|
|
|
|
{
|
|
|
|
if (m_subSurface) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!m_output) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
resetSurface();
|
|
|
|
m_subSurface = backend()->subCompositor()->createSubSurface(surface(), m_output->surface(), this);
|
|
|
|
m_subSurface->setMode(SubSurface::Mode::Desynchronized);
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandSubSurfaceCursor::doInstallImage(wl_buffer *image, const QSize &size)
|
|
|
|
{
|
|
|
|
if (!image) {
|
|
|
|
delete m_subSurface;
|
|
|
|
m_subSurface = nullptr;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
createSubSurface();
|
|
|
|
// cursor position might have changed due to different cursor hot spot
|
|
|
|
move(input()->pointer()->pos());
|
|
|
|
drawSurface(image, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
QPointF WaylandSubSurfaceCursor::absoluteToRelativePosition(const QPointF &position)
|
|
|
|
{
|
2020-04-02 16:18:01 +00:00
|
|
|
return position - m_output->geometry().topLeft() - Cursors::self()->currentCursor()->hotspot();
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandSubSurfaceCursor::move(const QPointF &globalPosition)
|
|
|
|
{
|
|
|
|
auto *output = backend()->getOutputAt(globalPosition.toPoint());
|
|
|
|
if (!m_output || (output && m_output != output)) {
|
|
|
|
changeOutput(output);
|
|
|
|
if (!m_output) {
|
|
|
|
// cursor might be off the grid
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
installImage();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!m_subSurface) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// place the sub-surface relative to the output it is on and factor in the hotspot
|
2020-04-02 16:18:01 +00:00
|
|
|
const auto relativePosition = globalPosition.toPoint() - Cursors::self()->currentCursor()->hotspot() - m_output->geometry().topLeft();
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
m_subSurface->setPosition(relativePosition);
|
|
|
|
Compositor::self()->addRepaintFull();
|
|
|
|
}
|
|
|
|
|
2013-06-17 07:35:45 +00:00
|
|
|
WaylandSeat::WaylandSeat(wl_seat *seat, WaylandBackend *backend)
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
: QObject(nullptr)
|
2014-08-21 09:20:03 +00:00
|
|
|
, m_seat(new Seat(this))
|
Use nullptr everywhere
Summary:
Because KWin is a very old project, we use three kinds of null pointer
literals: 0, NULL, and nullptr. Since C++11, it's recommended to use
nullptr keyword.
This change converts all usages of 0 and NULL literal to nullptr. Even
though it breaks git history, we need to do it in order to have consistent
code as well to ease code reviews (it's very tempting for some people to
add unrelated changes to their patches, e.g. converting NULL to nullptr).
Test Plan: Compiles.
Reviewers: #kwin, davidedmundson, romangg
Reviewed By: #kwin, davidedmundson, romangg
Subscribers: romangg, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D23618
2019-09-19 14:46:54 +00:00
|
|
|
, m_pointer(nullptr)
|
|
|
|
, m_keyboard(nullptr)
|
2015-03-31 09:22:58 +00:00
|
|
|
, m_touch(nullptr)
|
2013-06-27 06:25:59 +00:00
|
|
|
, m_enteredSerial(0)
|
2013-06-17 07:35:45 +00:00
|
|
|
, m_backend(backend)
|
|
|
|
{
|
2014-08-21 09:20:03 +00:00
|
|
|
m_seat->setup(seat);
|
|
|
|
connect(m_seat, &Seat::hasKeyboardChanged, this,
|
|
|
|
[this](bool hasKeyboard) {
|
|
|
|
if (hasKeyboard) {
|
|
|
|
m_keyboard = m_seat->createKeyboard(this);
|
|
|
|
connect(m_keyboard, &Keyboard::keyChanged, this,
|
|
|
|
[this](quint32 key, Keyboard::KeyState state, quint32 time) {
|
2015-05-05 08:44:46 +00:00
|
|
|
switch (state) {
|
|
|
|
case Keyboard::KeyState::Pressed:
|
2016-11-24 12:51:15 +00:00
|
|
|
if (key == KEY_RIGHTCTRL) {
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
m_backend->togglePointerLock();
|
2016-11-24 12:51:15 +00:00
|
|
|
}
|
2015-05-05 08:44:46 +00:00
|
|
|
m_backend->keyboardKeyPressed(key, time);
|
|
|
|
break;
|
|
|
|
case Keyboard::KeyState::Released:
|
|
|
|
m_backend->keyboardKeyReleased(key, time);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
Q_UNREACHABLE();
|
|
|
|
}
|
2014-08-21 09:20:03 +00:00
|
|
|
}
|
|
|
|
);
|
|
|
|
connect(m_keyboard, &Keyboard::modifiersChanged, this,
|
|
|
|
[this](quint32 depressed, quint32 latched, quint32 locked, quint32 group) {
|
2015-05-05 08:44:46 +00:00
|
|
|
m_backend->keyboardModifiers(depressed, latched, locked, group);
|
2014-08-21 09:20:03 +00:00
|
|
|
}
|
|
|
|
);
|
|
|
|
connect(m_keyboard, &Keyboard::keymapChanged, this,
|
|
|
|
[this](int fd, quint32 size) {
|
2015-05-05 08:44:46 +00:00
|
|
|
m_backend->keymapChange(fd, size);
|
2014-08-21 09:20:03 +00:00
|
|
|
}
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
destroyKeyboard();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
|
|
|
connect(m_seat, &Seat::hasPointerChanged, this,
|
|
|
|
[this](bool hasPointer) {
|
|
|
|
if (hasPointer && !m_pointer) {
|
|
|
|
m_pointer = m_seat->createPointer(this);
|
2017-03-15 16:56:08 +00:00
|
|
|
setupPointerGestures();
|
2014-08-21 09:20:03 +00:00
|
|
|
connect(m_pointer, &Pointer::entered, this,
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
[this](quint32 serial, const QPointF &relativeToSurface) {
|
|
|
|
Q_UNUSED(relativeToSurface)
|
2014-08-21 09:20:03 +00:00
|
|
|
m_enteredSerial = serial;
|
|
|
|
}
|
|
|
|
);
|
|
|
|
connect(m_pointer, &Pointer::motion, this,
|
|
|
|
[this](const QPointF &relativeToSurface, quint32 time) {
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
m_backend->pointerMotionRelativeToOutput(relativeToSurface, time);
|
2014-08-21 09:20:03 +00:00
|
|
|
}
|
|
|
|
);
|
|
|
|
connect(m_pointer, &Pointer::buttonStateChanged, this,
|
|
|
|
[this](quint32 serial, quint32 time, quint32 button, Pointer::ButtonState state) {
|
|
|
|
Q_UNUSED(serial)
|
2015-05-05 08:44:46 +00:00
|
|
|
switch (state) {
|
|
|
|
case Pointer::ButtonState::Pressed:
|
|
|
|
m_backend->pointerButtonPressed(button, time);
|
|
|
|
break;
|
|
|
|
case Pointer::ButtonState::Released:
|
|
|
|
m_backend->pointerButtonReleased(button, time);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
Q_UNREACHABLE();
|
|
|
|
}
|
2014-08-21 09:20:03 +00:00
|
|
|
}
|
|
|
|
);
|
Send axis_source, axis_discrete, and axis_stop
Summary:
So far KWin didn't send axis_source, axis_discrete, and axis_stop. Even
though most of those events are optional, clients need them to work as
expected. For example, one needs axis_source and axis_stop to implement
kinetic scrolling; Xwayland needs axis_discrete to prevent multiple
scroll events when the compositor sends axis deltas greater than 10, etc.
BUG: 404152
FIXED-IN: 5.17.0
Test Plan:
* Content of a webpage in Firefox is moved by one line per each mouse
wheel "click";
* Scrolled gedit using 2 fingers on GNOME Shell, sway, and KDE Plasma;
in all three cases wayland debug looked the same (except diagonal scroll
motions).
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D19000
2019-02-12 09:14:51 +00:00
|
|
|
// TODO: Send discreteDelta and source as well.
|
2014-08-21 09:20:03 +00:00
|
|
|
connect(m_pointer, &Pointer::axisChanged, this,
|
|
|
|
[this](quint32 time, Pointer::Axis axis, qreal delta) {
|
2015-05-05 08:44:46 +00:00
|
|
|
switch (axis) {
|
|
|
|
case Pointer::Axis::Horizontal:
|
|
|
|
m_backend->pointerAxisHorizontal(delta, time);
|
|
|
|
break;
|
|
|
|
case Pointer::Axis::Vertical:
|
|
|
|
m_backend->pointerAxisVertical(delta, time);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
Q_UNREACHABLE();
|
|
|
|
}
|
2014-08-21 09:20:03 +00:00
|
|
|
}
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
destroyPointer();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
2015-03-25 13:50:14 +00:00
|
|
|
connect(m_seat, &Seat::hasTouchChanged,
|
|
|
|
[this] (bool hasTouch) {
|
|
|
|
if (hasTouch && !m_touch) {
|
|
|
|
m_touch = m_seat->createTouch(this);
|
2016-04-07 07:18:10 +00:00
|
|
|
connect(m_touch, &Touch::sequenceCanceled, m_backend, &Platform::touchCancel);
|
|
|
|
connect(m_touch, &Touch::frameEnded, m_backend, &Platform::touchFrame);
|
2015-03-25 13:50:14 +00:00
|
|
|
connect(m_touch, &Touch::sequenceStarted, this,
|
2015-05-05 08:44:46 +00:00
|
|
|
[this] (TouchPoint *tp) {
|
|
|
|
m_backend->touchDown(tp->id(), tp->position(), tp->time());
|
2015-03-25 13:50:14 +00:00
|
|
|
}
|
|
|
|
);
|
|
|
|
connect(m_touch, &Touch::pointAdded, this,
|
2015-05-05 08:44:46 +00:00
|
|
|
[this] (TouchPoint *tp) {
|
|
|
|
m_backend->touchDown(tp->id(), tp->position(), tp->time());
|
2015-03-25 13:50:14 +00:00
|
|
|
}
|
|
|
|
);
|
|
|
|
connect(m_touch, &Touch::pointRemoved, this,
|
2015-05-05 08:44:46 +00:00
|
|
|
[this] (TouchPoint *tp) {
|
|
|
|
m_backend->touchUp(tp->id(), tp->time());
|
2015-03-25 13:50:14 +00:00
|
|
|
}
|
|
|
|
);
|
|
|
|
connect(m_touch, &Touch::pointMoved, this,
|
2015-05-05 08:44:46 +00:00
|
|
|
[this] (TouchPoint *tp) {
|
|
|
|
m_backend->touchMotion(tp->id(), tp->position(), tp->time());
|
2015-03-25 13:50:14 +00:00
|
|
|
}
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
destroyTouch();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
2015-02-25 08:35:42 +00:00
|
|
|
WaylandServer *server = waylandServer();
|
|
|
|
if (server) {
|
2020-04-29 15:18:41 +00:00
|
|
|
using namespace KWaylandServer;
|
2015-02-25 08:35:42 +00:00
|
|
|
SeatInterface *si = server->seat();
|
|
|
|
connect(m_seat, &Seat::hasKeyboardChanged, si, &SeatInterface::setHasKeyboard);
|
|
|
|
connect(m_seat, &Seat::hasPointerChanged, si, &SeatInterface::setHasPointer);
|
|
|
|
connect(m_seat, &Seat::hasTouchChanged, si, &SeatInterface::setHasTouch);
|
|
|
|
connect(m_seat, &Seat::nameChanged, si, &SeatInterface::setName);
|
|
|
|
}
|
2013-06-17 07:35:45 +00:00
|
|
|
}
|
|
|
|
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
void WaylandBackend::pointerMotionRelativeToOutput(const QPointF &position, quint32 time)
|
|
|
|
{
|
2020-09-09 01:46:12 +00:00
|
|
|
auto outputIt = std::find_if(m_outputs.constBegin(), m_outputs.constEnd(), [this](WaylandOutput *wo) {
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
return wo->surface() == m_seat->pointer()->enteredSurface();
|
|
|
|
});
|
2020-09-09 01:46:12 +00:00
|
|
|
Q_ASSERT(outputIt != m_outputs.constEnd());
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
const QPointF outputPosition = (*outputIt)->geometry().topLeft() + position;
|
|
|
|
Platform::pointerMotion(outputPosition, time);
|
|
|
|
}
|
|
|
|
|
2013-06-17 07:35:45 +00:00
|
|
|
WaylandSeat::~WaylandSeat()
|
|
|
|
{
|
|
|
|
destroyPointer();
|
|
|
|
destroyKeyboard();
|
2015-03-25 13:50:14 +00:00
|
|
|
destroyTouch();
|
2013-06-17 07:35:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandSeat::destroyPointer()
|
|
|
|
{
|
2017-03-15 16:56:08 +00:00
|
|
|
delete m_pinchGesture;
|
|
|
|
m_pinchGesture = nullptr;
|
|
|
|
delete m_swipeGesture;
|
|
|
|
m_swipeGesture = nullptr;
|
2014-08-21 09:20:03 +00:00
|
|
|
delete m_pointer;
|
|
|
|
m_pointer = nullptr;
|
2013-06-17 07:35:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandSeat::destroyKeyboard()
|
|
|
|
{
|
2014-08-21 09:20:03 +00:00
|
|
|
delete m_keyboard;
|
|
|
|
m_keyboard = nullptr;
|
2013-06-17 07:35:45 +00:00
|
|
|
}
|
|
|
|
|
2015-03-25 13:50:14 +00:00
|
|
|
void WaylandSeat::destroyTouch()
|
|
|
|
{
|
|
|
|
delete m_touch;
|
|
|
|
m_touch = nullptr;
|
|
|
|
}
|
|
|
|
|
2017-03-15 16:56:08 +00:00
|
|
|
void WaylandSeat::setupPointerGestures()
|
|
|
|
{
|
|
|
|
if (!m_pointer || !m_gesturesInterface) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (m_pinchGesture || m_swipeGesture) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m_pinchGesture = m_gesturesInterface->createPinchGesture(m_pointer, this);
|
|
|
|
m_swipeGesture = m_gesturesInterface->createSwipeGesture(m_pointer, this);
|
|
|
|
connect(m_pinchGesture, &PointerPinchGesture::started, m_backend,
|
|
|
|
[this] (quint32 serial, quint32 time) {
|
|
|
|
Q_UNUSED(serial);
|
|
|
|
m_backend->processPinchGestureBegin(m_pinchGesture->fingerCount(), time);
|
|
|
|
}
|
|
|
|
);
|
|
|
|
connect(m_pinchGesture, &PointerPinchGesture::updated, m_backend,
|
|
|
|
[this] (const QSizeF &delta, qreal scale, qreal rotation, quint32 time) {
|
|
|
|
m_backend->processPinchGestureUpdate(scale, rotation, delta, time);
|
|
|
|
}
|
|
|
|
);
|
|
|
|
connect(m_pinchGesture, &PointerPinchGesture::ended, m_backend,
|
|
|
|
[this] (quint32 serial, quint32 time) {
|
|
|
|
Q_UNUSED(serial)
|
|
|
|
m_backend->processPinchGestureEnd(time);
|
|
|
|
}
|
|
|
|
);
|
|
|
|
connect(m_pinchGesture, &PointerPinchGesture::cancelled, m_backend,
|
|
|
|
[this] (quint32 serial, quint32 time) {
|
|
|
|
Q_UNUSED(serial)
|
|
|
|
m_backend->processPinchGestureCancelled(time);
|
|
|
|
}
|
|
|
|
);
|
|
|
|
|
|
|
|
connect(m_swipeGesture, &PointerSwipeGesture::started, m_backend,
|
|
|
|
[this] (quint32 serial, quint32 time) {
|
|
|
|
Q_UNUSED(serial)
|
|
|
|
m_backend->processSwipeGestureBegin(m_swipeGesture->fingerCount(), time);
|
|
|
|
}
|
|
|
|
);
|
|
|
|
connect(m_swipeGesture, &PointerSwipeGesture::updated, m_backend, &Platform::processSwipeGestureUpdate);
|
|
|
|
connect(m_swipeGesture, &PointerSwipeGesture::ended, m_backend,
|
|
|
|
[this] (quint32 serial, quint32 time) {
|
|
|
|
Q_UNUSED(serial)
|
|
|
|
m_backend->processSwipeGestureEnd(time);
|
|
|
|
}
|
|
|
|
);
|
|
|
|
connect(m_swipeGesture, &PointerSwipeGesture::cancelled, m_backend,
|
|
|
|
[this] (quint32 serial, quint32 time) {
|
|
|
|
Q_UNUSED(serial)
|
|
|
|
m_backend->processSwipeGestureCancelled(time);
|
|
|
|
}
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2015-05-06 07:37:25 +00:00
|
|
|
WaylandBackend::WaylandBackend(QObject *parent)
|
2016-04-07 07:18:10 +00:00
|
|
|
: Platform(parent)
|
2013-07-03 09:56:05 +00:00
|
|
|
, m_display(nullptr)
|
2014-09-23 11:15:49 +00:00
|
|
|
, m_eventQueue(new EventQueue(this))
|
2014-08-18 12:05:35 +00:00
|
|
|
, m_registry(new Registry(this))
|
2017-09-23 18:21:26 +00:00
|
|
|
, m_compositor(new KWayland::Client::Compositor(this))
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
, m_subCompositor(new KWayland::Client::SubCompositor(this))
|
2014-08-21 05:54:16 +00:00
|
|
|
, m_shm(new ShmPool(this))
|
2015-03-23 11:45:21 +00:00
|
|
|
, m_connectionThreadObject(new ConnectionThread(nullptr))
|
2014-08-13 10:54:02 +00:00
|
|
|
, m_connectionThread(nullptr)
|
2015-05-06 06:32:39 +00:00
|
|
|
{
|
2020-07-20 16:11:30 +00:00
|
|
|
supportsOutputChanges();
|
2020-07-22 17:31:23 +00:00
|
|
|
connect(this, &WaylandBackend::connectionFailed, this, &WaylandBackend::initFailed);
|
|
|
|
|
|
|
|
|
2020-10-06 23:36:18 +00:00
|
|
|
#if HAVE_GBM && HAVE_WAYLAND_EGL
|
2020-07-22 17:31:23 +00:00
|
|
|
char const *drm_render_node = "/dev/dri/renderD128";
|
2020-07-22 17:38:57 +00:00
|
|
|
m_drmFileDescriptor = open(drm_render_node, O_RDWR);
|
|
|
|
if (m_drmFileDescriptor < 0) {
|
2020-07-22 17:31:23 +00:00
|
|
|
qCWarning(KWIN_WAYLAND_BACKEND) << "Failed to open drm render node" << drm_render_node;
|
|
|
|
m_gbmDevice = nullptr;
|
|
|
|
return;
|
|
|
|
}
|
2020-07-22 17:38:57 +00:00
|
|
|
m_gbmDevice = gbm_create_device(m_drmFileDescriptor);
|
2020-10-06 23:36:18 +00:00
|
|
|
#endif
|
2015-05-06 06:32:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
WaylandBackend::~WaylandBackend()
|
|
|
|
{
|
2016-11-24 12:51:15 +00:00
|
|
|
if (m_pointerConstraints) {
|
|
|
|
m_pointerConstraints->release();
|
|
|
|
}
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
delete m_waylandCursor;
|
|
|
|
|
2020-03-27 13:18:22 +00:00
|
|
|
m_eventQueue->release();
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
qDeleteAll(m_outputs);
|
|
|
|
|
2016-07-11 07:59:05 +00:00
|
|
|
if (m_xdgShell) {
|
|
|
|
m_xdgShell->release();
|
|
|
|
}
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
m_subCompositor->release();
|
2015-05-06 06:32:39 +00:00
|
|
|
m_compositor->release();
|
|
|
|
m_registry->release();
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
delete m_seat;
|
2015-05-06 06:32:39 +00:00
|
|
|
m_shm->release();
|
|
|
|
|
|
|
|
m_connectionThread->quit();
|
|
|
|
m_connectionThread->wait();
|
2020-03-27 13:18:22 +00:00
|
|
|
m_connectionThreadObject->deleteLater();
|
2020-10-06 23:36:18 +00:00
|
|
|
#if HAVE_GBM && HAVE_WAYLAND_EGL
|
2020-07-22 17:31:23 +00:00
|
|
|
gbm_device_destroy(m_gbmDevice);
|
2020-07-22 17:38:57 +00:00
|
|
|
close(m_drmFileDescriptor);
|
2020-10-06 23:36:18 +00:00
|
|
|
#endif
|
2015-05-06 06:32:39 +00:00
|
|
|
qCDebug(KWIN_WAYLAND_BACKEND) << "Destroyed Wayland display";
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandBackend::init()
|
2013-06-17 07:35:45 +00:00
|
|
|
{
|
2014-08-18 12:05:35 +00:00
|
|
|
connect(m_registry, &Registry::compositorAnnounced, this,
|
|
|
|
[this](quint32 name) {
|
2014-08-21 06:53:00 +00:00
|
|
|
m_compositor->setup(m_registry->bindCompositor(name, 1));
|
2014-08-18 12:05:35 +00:00
|
|
|
}
|
|
|
|
);
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
connect(m_registry, &Registry::subCompositorAnnounced, this,
|
|
|
|
[this](quint32 name) {
|
|
|
|
m_subCompositor->setup(m_registry->bindSubCompositor(name, 1));
|
|
|
|
}
|
|
|
|
);
|
2014-08-21 09:30:56 +00:00
|
|
|
connect(m_registry, &Registry::seatAnnounced, this,
|
|
|
|
[this](quint32 name) {
|
2014-08-15 12:16:15 +00:00
|
|
|
if (Application::usesLibinput()) {
|
|
|
|
return;
|
|
|
|
}
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
m_seat = new WaylandSeat(m_registry->bindSeat(name, 2), this);
|
2014-08-18 12:05:35 +00:00
|
|
|
}
|
|
|
|
);
|
2014-08-21 05:54:16 +00:00
|
|
|
connect(m_registry, &Registry::shmAnnounced, this,
|
|
|
|
[this](quint32 name) {
|
|
|
|
m_shm->setup(m_registry->bindShm(name, 1));
|
|
|
|
}
|
|
|
|
);
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
connect(m_registry, &Registry::relativePointerManagerUnstableV1Announced, this,
|
|
|
|
[this](quint32 name, quint32 version) {
|
|
|
|
if (m_relativePointerManager) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m_relativePointerManager = m_registry->createRelativePointerManager(name, version, this);
|
|
|
|
if (m_pointerConstraints) {
|
|
|
|
emit pointerLockSupportedChanged();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
2016-11-24 12:51:15 +00:00
|
|
|
connect(m_registry, &Registry::pointerConstraintsUnstableV1Announced, this,
|
|
|
|
[this](quint32 name, quint32 version) {
|
|
|
|
if (m_pointerConstraints) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m_pointerConstraints = m_registry->createPointerConstraints(name, version, this);
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
if (m_relativePointerManager) {
|
|
|
|
emit pointerLockSupportedChanged();
|
|
|
|
}
|
2016-11-24 12:51:15 +00:00
|
|
|
}
|
|
|
|
);
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
connect(m_registry, &Registry::interfacesAnnounced, this, &WaylandBackend::createOutputs);
|
2017-03-15 16:56:08 +00:00
|
|
|
connect(m_registry, &Registry::interfacesAnnounced, this,
|
|
|
|
[this] {
|
|
|
|
if (!m_seat) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const auto gi = m_registry->interface(Registry::Interface::PointerGesturesUnstableV1);
|
|
|
|
if (gi.name == 0) {
|
|
|
|
return;
|
|
|
|
}
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
auto gesturesInterface = m_registry->createPointerGestures(gi.name, gi.version, m_seat);
|
2017-03-15 16:56:08 +00:00
|
|
|
m_seat->installGesturesInterface(gesturesInterface);
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
|
|
|
|
m_waylandCursor = new WaylandCursor(this);
|
2017-03-15 16:56:08 +00:00
|
|
|
}
|
|
|
|
);
|
2015-11-17 08:47:46 +00:00
|
|
|
if (!deviceIdentifier().isEmpty()) {
|
|
|
|
m_connectionThreadObject->setSocketName(deviceIdentifier());
|
|
|
|
}
|
2020-04-02 16:18:01 +00:00
|
|
|
connect(Cursors::self(), &Cursors::currentCursorChanged, this,
|
2016-02-23 11:29:05 +00:00
|
|
|
[this] {
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
if (!m_seat) {
|
2016-02-23 11:29:05 +00:00
|
|
|
return;
|
|
|
|
}
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
m_waylandCursor->installImage();
|
2020-04-02 16:18:01 +00:00
|
|
|
auto c = Cursors::self()->currentCursor();
|
2020-11-18 14:08:54 +00:00
|
|
|
emit c->rendered(c->geometry());
|
2016-02-23 11:29:05 +00:00
|
|
|
}
|
|
|
|
);
|
2020-04-02 16:18:01 +00:00
|
|
|
connect(this, &WaylandBackend::pointerLockChanged, this, [this] (bool locked) {
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
delete m_waylandCursor;
|
|
|
|
if (locked) {
|
|
|
|
Q_ASSERT(!m_relativePointer);
|
|
|
|
m_waylandCursor = new WaylandSubSurfaceCursor(this);
|
|
|
|
m_waylandCursor->move(input()->pointer()->pos());
|
|
|
|
m_relativePointer = m_relativePointerManager->createRelativePointer(m_seat->pointer(), this);
|
|
|
|
if (!m_relativePointer->isValid()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
connect(m_relativePointer, &RelativePointer::relativeMotion,
|
|
|
|
this, &WaylandBackend::relativeMotionHandler);
|
|
|
|
} else {
|
|
|
|
delete m_relativePointer;
|
|
|
|
m_relativePointer = nullptr;
|
|
|
|
m_waylandCursor = new WaylandCursor(this);
|
|
|
|
}
|
|
|
|
m_waylandCursor->init();
|
|
|
|
});
|
2013-07-03 09:56:05 +00:00
|
|
|
initConnection();
|
2013-06-17 07:35:45 +00:00
|
|
|
}
|
|
|
|
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
void WaylandBackend::relativeMotionHandler(const QSizeF &delta, const QSizeF &deltaNonAccelerated, quint64 timestamp)
|
|
|
|
{
|
|
|
|
Q_UNUSED(deltaNonAccelerated)
|
|
|
|
Q_ASSERT(m_waylandCursor);
|
|
|
|
|
|
|
|
const auto oldGlobalPos = input()->pointer()->pos();
|
|
|
|
const QPointF newPos = oldGlobalPos + QPointF(delta.width(), delta.height());
|
|
|
|
m_waylandCursor->move(newPos);
|
|
|
|
Platform::pointerMotion(newPos, timestamp);
|
|
|
|
}
|
|
|
|
|
2013-07-03 09:56:05 +00:00
|
|
|
void WaylandBackend::initConnection()
|
|
|
|
{
|
2014-08-13 10:54:02 +00:00
|
|
|
connect(m_connectionThreadObject, &ConnectionThread::connected, this,
|
|
|
|
[this]() {
|
|
|
|
// create the event queue for the main gui thread
|
|
|
|
m_display = m_connectionThreadObject->display();
|
2014-09-23 11:15:49 +00:00
|
|
|
m_eventQueue->setup(m_connectionThreadObject);
|
|
|
|
m_registry->setEventQueue(m_eventQueue);
|
2014-08-13 10:54:02 +00:00
|
|
|
// setup registry
|
2014-08-18 12:05:35 +00:00
|
|
|
m_registry->create(m_display);
|
|
|
|
m_registry->setup();
|
2014-08-13 10:54:02 +00:00
|
|
|
},
|
|
|
|
Qt::QueuedConnection);
|
|
|
|
connect(m_connectionThreadObject, &ConnectionThread::connectionDied, this,
|
|
|
|
[this]() {
|
2015-05-05 17:02:52 +00:00
|
|
|
setReady(false);
|
2014-08-13 10:54:02 +00:00
|
|
|
emit systemCompositorDied();
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
delete m_seat;
|
2014-08-21 05:54:16 +00:00
|
|
|
m_shm->destroy();
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
|
|
|
|
qDeleteAll(m_outputs);
|
|
|
|
m_outputs.clear();
|
|
|
|
|
2016-07-11 07:59:05 +00:00
|
|
|
if (m_xdgShell) {
|
|
|
|
m_xdgShell->destroy();
|
|
|
|
}
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
m_subCompositor->destroy();
|
2014-08-21 06:53:00 +00:00
|
|
|
m_compositor->destroy();
|
2014-08-18 12:05:35 +00:00
|
|
|
m_registry->destroy();
|
2014-09-23 11:15:49 +00:00
|
|
|
m_eventQueue->destroy();
|
2014-08-13 10:54:02 +00:00
|
|
|
if (m_display) {
|
|
|
|
m_display = nullptr;
|
|
|
|
}
|
|
|
|
},
|
|
|
|
Qt::QueuedConnection);
|
|
|
|
connect(m_connectionThreadObject, &ConnectionThread::failed, this, &WaylandBackend::connectionFailed, Qt::QueuedConnection);
|
|
|
|
|
|
|
|
m_connectionThread = new QThread(this);
|
|
|
|
m_connectionThreadObject->moveToThread(m_connectionThread);
|
|
|
|
m_connectionThread->start();
|
|
|
|
|
|
|
|
m_connectionThreadObject->initConnection();
|
2013-07-03 09:56:05 +00:00
|
|
|
}
|
|
|
|
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
void WaylandBackend::updateScreenSize(WaylandOutput *output)
|
|
|
|
{
|
2020-09-09 01:46:12 +00:00
|
|
|
auto it = std::find(m_outputs.constBegin(), m_outputs.constEnd(), output);
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
|
|
|
|
int nextLogicalPosition = output->geometry().topRight().x();
|
2020-09-09 01:46:12 +00:00
|
|
|
while (++it != m_outputs.constEnd()) {
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
const QRect geo = (*it)->geometry();
|
|
|
|
(*it)->setGeometry(QPoint(nextLogicalPosition, 0), geo.size());
|
|
|
|
nextLogicalPosition = geo.topRight().x();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandBackend::createOutputs()
|
2013-06-17 07:35:45 +00:00
|
|
|
{
|
2015-12-17 14:32:41 +00:00
|
|
|
using namespace KWayland::Client;
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
|
|
|
|
const auto ssdManagerIface = m_registry->interface(Registry::Interface::ServerSideDecorationManager);
|
|
|
|
ServerSideDecorationManager *ssdManager = ssdManagerIface.name == 0 ? nullptr :
|
|
|
|
m_registry->createServerSideDecorationManager(ssdManagerIface.name, ssdManagerIface.version, this);
|
|
|
|
|
|
|
|
|
2019-11-03 16:08:59 +00:00
|
|
|
const auto xdgIface = m_registry->interface(Registry::Interface::XdgShellStable);
|
2016-07-11 07:59:05 +00:00
|
|
|
if (xdgIface.name != 0) {
|
|
|
|
m_xdgShell = m_registry->createXdgShell(xdgIface.name, xdgIface.version, this);
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// we need to multiply the initial window size with the scale in order to
|
|
|
|
// create an output window of this size in the end
|
|
|
|
const int pixelWidth = initialWindowSize().width() * initialOutputScale() + 0.5;
|
|
|
|
const int pixelHeight = initialWindowSize().height() * initialOutputScale() + 0.5;
|
|
|
|
const int logicalWidth = initialWindowSize().width();
|
|
|
|
|
|
|
|
int logicalWidthSum = 0;
|
|
|
|
for (int i = 0; i < initialOutputCount(); i++) {
|
|
|
|
auto surface = m_compositor->createSurface(this);
|
|
|
|
if (!surface || !surface->isValid()) {
|
|
|
|
qCCritical(KWIN_WAYLAND_BACKEND) << "Creating Wayland Surface failed";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ssdManager) {
|
|
|
|
auto decoration = ssdManager->create(surface, this);
|
|
|
|
connect(decoration, &ServerSideDecoration::modeChanged, this,
|
2020-03-15 19:59:29 +00:00
|
|
|
[decoration] {
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
if (decoration->mode() != ServerSideDecoration::Mode::Server) {
|
|
|
|
decoration->requestMode(ServerSideDecoration::Mode::Server);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
WaylandOutput *waylandOutput = nullptr;
|
|
|
|
|
2016-07-11 07:59:05 +00:00
|
|
|
if (m_xdgShell && m_xdgShell->isValid()) {
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
waylandOutput = new XdgShellOutput(surface, m_xdgShell, this, i+1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!waylandOutput) {
|
|
|
|
qCCritical(KWIN_WAYLAND_BACKEND) << "Binding to all shell interfaces failed for output" << i;
|
2016-07-11 07:59:05 +00:00
|
|
|
return;
|
|
|
|
}
|
2013-06-17 07:35:45 +00:00
|
|
|
|
2019-08-27 10:14:10 +00:00
|
|
|
waylandOutput->init(QPoint(logicalWidthSum, 0), QSize(pixelWidth, pixelHeight));
|
2016-07-11 07:59:05 +00:00
|
|
|
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
connect(waylandOutput, &WaylandOutput::sizeChanged, this, [this, waylandOutput](const QSize &size) {
|
|
|
|
Q_UNUSED(size)
|
|
|
|
updateScreenSize(waylandOutput);
|
|
|
|
Compositor::self()->addRepaintFull();
|
|
|
|
});
|
|
|
|
connect(waylandOutput, &WaylandOutput::frameRendered, this, &WaylandBackend::checkBufferSwap);
|
|
|
|
|
|
|
|
logicalWidthSum += logicalWidth;
|
|
|
|
m_outputs << waylandOutput;
|
2016-07-11 07:59:05 +00:00
|
|
|
}
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
setReady(true);
|
|
|
|
emit screensQueried();
|
2014-08-20 09:27:09 +00:00
|
|
|
}
|
|
|
|
|
2015-03-27 06:52:59 +00:00
|
|
|
Screens *WaylandBackend::createScreens(QObject *parent)
|
|
|
|
{
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
return new OutputScreens(this, parent);
|
2015-03-27 06:52:59 +00:00
|
|
|
}
|
|
|
|
|
2015-03-27 07:51:56 +00:00
|
|
|
OpenGLBackend *WaylandBackend::createOpenGLBackend()
|
|
|
|
{
|
2015-11-30 07:34:52 +00:00
|
|
|
#if HAVE_WAYLAND_EGL
|
2015-03-27 07:51:56 +00:00
|
|
|
return new EglWaylandBackend(this);
|
2015-11-30 07:34:52 +00:00
|
|
|
#else
|
|
|
|
return nullptr;
|
|
|
|
#endif
|
2015-03-27 07:51:56 +00:00
|
|
|
}
|
|
|
|
|
2015-03-27 08:05:03 +00:00
|
|
|
QPainterBackend *WaylandBackend::createQPainterBackend()
|
|
|
|
{
|
|
|
|
return new WaylandQPainterBackend(this);
|
|
|
|
}
|
|
|
|
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
void WaylandBackend::checkBufferSwap()
|
|
|
|
{
|
2020-09-09 01:46:12 +00:00
|
|
|
const bool allRendered = std::all_of(m_outputs.constBegin(), m_outputs.constEnd(), [](WaylandOutput *o) {
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
return o->rendered();
|
|
|
|
});
|
|
|
|
if (!allRendered) {
|
|
|
|
// need to wait more
|
|
|
|
// TODO: what if one does not need to be rendered (no damage)?
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
Compositor::self()->bufferSwapComplete();
|
|
|
|
|
2020-09-09 01:46:12 +00:00
|
|
|
for (auto *output : qAsConst(m_outputs)) {
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
output->resetRendered();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-23 11:29:05 +00:00
|
|
|
void WaylandBackend::flush()
|
|
|
|
{
|
|
|
|
if (m_connectionThreadObject) {
|
|
|
|
m_connectionThreadObject->flush();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-17 01:11:39 +00:00
|
|
|
WaylandOutput* WaylandBackend::getOutputAt(const QPointF &globalPosition)
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
{
|
|
|
|
const auto pos = globalPosition.toPoint();
|
|
|
|
auto checkPosition = [pos](WaylandOutput *output) {
|
|
|
|
return output->geometry().contains(pos);
|
|
|
|
};
|
2020-09-09 01:46:12 +00:00
|
|
|
auto it = std::find_if(m_outputs.constBegin(), m_outputs.constEnd(), checkPosition);
|
|
|
|
return it == m_outputs.constEnd() ? nullptr : *it;
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool WaylandBackend::supportsPointerLock()
|
|
|
|
{
|
|
|
|
return m_pointerConstraints && m_relativePointerManager;
|
|
|
|
}
|
|
|
|
|
|
|
|
void WaylandBackend::togglePointerLock()
|
2016-11-24 12:51:15 +00:00
|
|
|
{
|
|
|
|
if (!m_pointerConstraints) {
|
|
|
|
return;
|
|
|
|
}
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
if (!m_relativePointerManager) {
|
2016-11-24 12:51:15 +00:00
|
|
|
return;
|
|
|
|
}
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
if (!m_seat) {
|
2016-11-24 12:51:15 +00:00
|
|
|
return;
|
|
|
|
}
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
auto pointer = m_seat->pointer();
|
|
|
|
if (!pointer) {
|
2016-11-24 12:51:15 +00:00
|
|
|
return;
|
|
|
|
}
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
if (m_outputs.isEmpty()) {
|
2016-11-24 12:51:15 +00:00
|
|
|
return;
|
|
|
|
}
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
|
|
|
|
for (auto output : m_outputs) {
|
|
|
|
output->lockPointer(m_seat->pointer(), !m_pointerLockRequested);
|
|
|
|
}
|
|
|
|
m_pointerLockRequested = !m_pointerLockRequested;
|
2016-11-24 12:51:15 +00:00
|
|
|
flush();
|
|
|
|
}
|
|
|
|
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
bool WaylandBackend::pointerIsLocked()
|
2016-11-24 12:51:15 +00:00
|
|
|
{
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
for (auto *output : m_outputs) {
|
|
|
|
if (output->pointerIsLocked()) {
|
|
|
|
return true;
|
2016-11-24 12:51:15 +00:00
|
|
|
}
|
|
|
|
}
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
return false;
|
2016-11-24 12:51:15 +00:00
|
|
|
}
|
|
|
|
|
2017-10-15 20:24:49 +00:00
|
|
|
QVector<CompositingType> WaylandBackend::supportedCompositors() const
|
|
|
|
{
|
2019-02-16 19:50:46 +00:00
|
|
|
if (selectedCompositor() != NoCompositing) {
|
|
|
|
return {selectedCompositor()};
|
|
|
|
}
|
2017-10-15 20:24:49 +00:00
|
|
|
#if HAVE_WAYLAND_EGL
|
|
|
|
return QVector<CompositingType>{OpenGLCompositing, QPainterCompositing};
|
|
|
|
#else
|
|
|
|
return QVector<CompositingType>{QPainterCompositing};
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
[platforms/wayland] Multi output support
Summary:
This patch rewrites large parts of the Wayland platform plugin, in order to
facilitate the testing of multi output behavior in nested KWin sessions.
For that a new class WaylandOutput is introduced, which is based on
AbstractOutput and by that shares functionality with our virtual and DRM
platform plugins.
The EGL/GBM and QPainter backends have been remodelled after the DRM one,
sharing similiarities there as well now.
Pointer grabbing has been rewritten to support multiple outputs, now using
pointer locking instead of confining and drawing in this case onto a sub-
surface, which get dynamically recreated in between the different output
surfaces while the cursor is being moved.
Window resizing is possible if host supports xdg-shell, but currently the
mode size does not yet fill the new window size.
The number of outputs can be set by command line argument `--output-count`,
scaling is also supported by setting the argument `--scale`.
Further steps could be:
* Enabling automatic fill of resized windows via Wayland mode change
* Multiple diverging initial sizes and scale factors for mulitple outputs
**Watch it in action:** https://youtu.be/FYItn1jvkbI
Test Plan: Tested it in live session.
Reviewers: #kwin, davidedmundson
Reviewed By: #kwin, davidedmundson
Subscribers: davidedmundson, zzag, kwin
Tags: #kwin
Differential Revision: https://phabricator.kde.org/D18465
2019-02-22 09:57:07 +00:00
|
|
|
Outputs WaylandBackend::outputs() const
|
|
|
|
{
|
|
|
|
return m_outputs;
|
|
|
|
}
|
|
|
|
|
|
|
|
Outputs WaylandBackend::enabledOutputs() const
|
|
|
|
{
|
|
|
|
// all outputs are enabled
|
|
|
|
return m_outputs;
|
|
|
|
}
|
2017-10-15 20:24:49 +00:00
|
|
|
|
2020-07-22 17:31:23 +00:00
|
|
|
DmaBufTexture *WaylandBackend::createDmaBufTexture(const QSize& size)
|
|
|
|
{
|
2020-10-06 23:36:18 +00:00
|
|
|
#if HAVE_GBM && HAVE_WAYLAND_EGL
|
2020-07-22 17:31:23 +00:00
|
|
|
return GbmDmaBuf::createBuffer(size, m_gbmDevice);
|
2020-10-06 23:36:18 +00:00
|
|
|
#else
|
|
|
|
return nullptr;
|
|
|
|
#endif
|
2020-07-22 17:31:23 +00:00
|
|
|
}
|
|
|
|
|
2013-06-17 07:35:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
} // KWin
|