yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/src/wayland/relativepointer_v1.cpp

99 lines
3.5 KiB
C++
Raw Normal View History

Port relative-pointer-v1 interface to the new design
2020-11-03 16:24:03 +00:00
/*
SPDX-FileCopyrightText: 2016 Martin Gräßlin <mgraesslin@kde.org>
SPDX-FileCopyrightText: 2020 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
*/
wayland: Drop "_interface" from filenames The cpp files in the wayland directory are named after protocol names. "_interface" does not contribute anything new.
2023-09-13 05:52:59 +00:00
#include "relativepointer_v1.h"
Rewrite wl_pointer implementation with new approach With this design, a single PointerInterface manages multiple wl_pointer objects. This makes the API tidier and allows implementing things such as keyboard grabs more easier. In addition to that, the PointerInterface doesn't inject its own frame events anymore. It's up to the compositor to decide when it has to be sent. However, the PointerInterface may still send a frame event if the pointer focus changes. Besides re-writing the pointer interface, this change, unfortunately, also affects the implementation of pointer-gestures and relative-pointer protocols because previously they were coupled to individual instances of PointerInterface.
2021-02-12 22:29:45 +00:00
#include "clientconnection.h"
Port relative-pointer-v1 interface to the new design
2020-11-03 16:24:03 +00:00
#include "display.h"
wayland: Drop "_interface" from filenames The cpp files in the wayland directory are named after protocol names. "_interface" does not contribute anything new.
2023-09-13 05:52:59 +00:00
#include "pointer_p.h"
#include "relativepointer_v1_p.h"
#include "seat.h"
#include "surface.h"
Port relative-pointer-v1 interface to the new design
2020-11-03 16:24:03 +00:00
wayland: Integrate KWaylandServer classes into KWin namespace
2023-09-13 17:59:29 +00:00
namespace KWin
Port relative-pointer-v1 interface to the new design
2020-11-03 16:24:03 +00:00
{
static const int s_version = 1;
RelativePointerManagerV1InterfacePrivate::RelativePointerManagerV1InterfacePrivate(Display *display)
: QtWaylandServer::zwp_relative_pointer_manager_v1(*display, s_version)
{
}
void RelativePointerManagerV1InterfacePrivate::zwp_relative_pointer_manager_v1_destroy(Resource *resource)
{
wl_resource_destroy(resource->handle);
}
Run clang-format If you want git blame to ignore formatting revisions run: git config blame.ignoreRevsFile .git-blame-ignore-revs
2021-08-29 05:11:06 +00:00
void RelativePointerManagerV1InterfacePrivate::zwp_relative_pointer_manager_v1_get_relative_pointer(Resource *resource,
uint32_t id,
struct ::wl_resource *pointer_resource)
Port relative-pointer-v1 interface to the new design
2020-11-03 16:24:03 +00:00
{
PointerInterface *pointer = PointerInterface::get(pointer_resource);
if (!pointer) {
Run clang-format If you want git blame to ignore formatting revisions run: git config blame.ignoreRevsFile .git-blame-ignore-revs
2021-08-29 05:11:06 +00:00
wl_resource_post_error(resource->handle, WL_DISPLAY_ERROR_INVALID_OBJECT, "invalid pointer");
Port relative-pointer-v1 interface to the new design
2020-11-03 16:24:03 +00:00
return;
}
Rewrite wl_pointer implementation with new approach With this design, a single PointerInterface manages multiple wl_pointer objects. This makes the API tidier and allows implementing things such as keyboard grabs more easier. In addition to that, the PointerInterface doesn't inject its own frame events anymore. It's up to the compositor to decide when it has to be sent. However, the PointerInterface may still send a frame event if the pointer focus changes. Besides re-writing the pointer interface, this change, unfortunately, also affects the implementation of pointer-gestures and relative-pointer protocols because previously they were coupled to individual instances of PointerInterface.
2021-02-12 22:29:45 +00:00
RelativePointerV1Interface *relativePointer = RelativePointerV1Interface::get(pointer);
relativePointer->add(resource->client(), id, resource->version());
Port relative-pointer-v1 interface to the new design
2020-11-03 16:24:03 +00:00
}
RelativePointerManagerV1Interface::RelativePointerManagerV1Interface(Display *display, QObject *parent)
: QObject(parent)
, d(new RelativePointerManagerV1InterfacePrivate(display))
{
}
RelativePointerManagerV1Interface::~RelativePointerManagerV1Interface()
{
}
Rewrite wl_pointer implementation with new approach With this design, a single PointerInterface manages multiple wl_pointer objects. This makes the API tidier and allows implementing things such as keyboard grabs more easier. In addition to that, the PointerInterface doesn't inject its own frame events anymore. It's up to the compositor to decide when it has to be sent. However, the PointerInterface may still send a frame event if the pointer focus changes. Besides re-writing the pointer interface, this change, unfortunately, also affects the implementation of pointer-gestures and relative-pointer protocols because previously they were coupled to individual instances of PointerInterface.
2021-02-12 22:29:45 +00:00
RelativePointerV1Interface::RelativePointerV1Interface(PointerInterface *pointer)
: pointer(pointer)
Port relative-pointer-v1 interface to the new design
2020-11-03 16:24:03 +00:00
{
}
Rewrite wl_pointer implementation with new approach With this design, a single PointerInterface manages multiple wl_pointer objects. This makes the API tidier and allows implementing things such as keyboard grabs more easier. In addition to that, the PointerInterface doesn't inject its own frame events anymore. It's up to the compositor to decide when it has to be sent. However, the PointerInterface may still send a frame event if the pointer focus changes. Besides re-writing the pointer interface, this change, unfortunately, also affects the implementation of pointer-gestures and relative-pointer protocols because previously they were coupled to individual instances of PointerInterface.
2021-02-12 22:29:45 +00:00
RelativePointerV1Interface *RelativePointerV1Interface::get(PointerInterface *pointer)
Port relative-pointer-v1 interface to the new design
2020-11-03 16:24:03 +00:00
{
if (pointer) {
Rewrite wl_pointer implementation with new approach With this design, a single PointerInterface manages multiple wl_pointer objects. This makes the API tidier and allows implementing things such as keyboard grabs more easier. In addition to that, the PointerInterface doesn't inject its own frame events anymore. It's up to the compositor to decide when it has to be sent. However, the PointerInterface may still send a frame event if the pointer focus changes. Besides re-writing the pointer interface, this change, unfortunately, also affects the implementation of pointer-gestures and relative-pointer protocols because previously they were coupled to individual instances of PointerInterface.
2021-02-12 22:29:45 +00:00
PointerInterfacePrivate *pointerPrivate = PointerInterfacePrivate::get(pointer);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
return pointerPrivate->relativePointersV1.get();
Port relative-pointer-v1 interface to the new design
2020-11-03 16:24:03 +00:00
}
Rewrite wl_pointer implementation with new approach With this design, a single PointerInterface manages multiple wl_pointer objects. This makes the API tidier and allows implementing things such as keyboard grabs more easier. In addition to that, the PointerInterface doesn't inject its own frame events anymore. It's up to the compositor to decide when it has to be sent. However, the PointerInterface may still send a frame event if the pointer focus changes. Besides re-writing the pointer interface, this change, unfortunately, also affects the implementation of pointer-gestures and relative-pointer protocols because previously they were coupled to individual instances of PointerInterface.
2021-02-12 22:29:45 +00:00
return nullptr;
Port relative-pointer-v1 interface to the new design
2020-11-03 16:24:03 +00:00
}
Rewrite wl_pointer implementation with new approach With this design, a single PointerInterface manages multiple wl_pointer objects. This makes the API tidier and allows implementing things such as keyboard grabs more easier. In addition to that, the PointerInterface doesn't inject its own frame events anymore. It's up to the compositor to decide when it has to be sent. However, the PointerInterface may still send a frame event if the pointer focus changes. Besides re-writing the pointer interface, this change, unfortunately, also affects the implementation of pointer-gestures and relative-pointer protocols because previously they were coupled to individual instances of PointerInterface.
2021-02-12 22:29:45 +00:00
void RelativePointerV1Interface::zwp_relative_pointer_v1_destroy(Resource *resource)
Port relative-pointer-v1 interface to the new design
2020-11-03 16:24:03 +00:00
{
Rewrite wl_pointer implementation with new approach With this design, a single PointerInterface manages multiple wl_pointer objects. This makes the API tidier and allows implementing things such as keyboard grabs more easier. In addition to that, the PointerInterface doesn't inject its own frame events anymore. It's up to the compositor to decide when it has to be sent. However, the PointerInterface may still send a frame event if the pointer focus changes. Besides re-writing the pointer interface, this change, unfortunately, also affects the implementation of pointer-gestures and relative-pointer protocols because previously they were coupled to individual instances of PointerInterface.
2021-02-12 22:29:45 +00:00
wl_resource_destroy(resource->handle);
Port relative-pointer-v1 interface to the new design
2020-11-03 16:24:03 +00:00
}
use std::chrono::microseconds for time in input events
2022-12-21 00:55:20 +00:00
void RelativePointerV1Interface::sendRelativeMotion(const QPointF &delta, const QPointF &deltaNonAccelerated, std::chrono::microseconds time)
Port relative-pointer-v1 interface to the new design
2020-11-03 16:24:03 +00:00
{
Rewrite wl_pointer implementation with new approach With this design, a single PointerInterface manages multiple wl_pointer objects. This makes the API tidier and allows implementing things such as keyboard grabs more easier. In addition to that, the PointerInterface doesn't inject its own frame events anymore. It's up to the compositor to decide when it has to be sent. However, the PointerInterface may still send a frame event if the pointer focus changes. Besides re-writing the pointer interface, this change, unfortunately, also affects the implementation of pointer-gestures and relative-pointer protocols because previously they were coupled to individual instances of PointerInterface.
2021-02-12 22:29:45 +00:00
if (!pointer->focusedSurface()) {
return;
}
Introduce client level scale overrides This allows for compositor managed different co-ordinate space between kwin's logical co-ordinate space and a client's logical co-ordinate space. When combined with a modified kwin!1959 this allows us to set a DPI in xrdb and mark all xwayland windows as being 2x (or other) and avoid upscales for xwayland clients in a way that doesn't impact other wayland clients or require third-party changes. Any use of fractional values is in layers we control instead of over the wire. kwayland-server is the right place for this abstraction as we need Outputs to differ on a per resource basis. Something we can't control from within kwin. Right now only protocols used by Xwayland are covered. If we covered remaining protocols we can offer user-control on all remaining clients which could open up other possibilities such as a user controlled dynamic resizing, or adapt to possible future protocol changes with wayland scaling.
2022-04-25 14:07:34 +00:00
auto scaleOverride = pointer->focusedSurface()->scaleOverride();
Rewrite wl_pointer implementation with new approach With this design, a single PointerInterface manages multiple wl_pointer objects. This makes the API tidier and allows implementing things such as keyboard grabs more easier. In addition to that, the PointerInterface doesn't inject its own frame events anymore. It's up to the compositor to decide when it has to be sent. However, the PointerInterface may still send a frame event if the pointer focus changes. Besides re-writing the pointer interface, this change, unfortunately, also affects the implementation of pointer-gestures and relative-pointer protocols because previously they were coupled to individual instances of PointerInterface.
2021-02-12 22:29:45 +00:00
ClientConnection *focusedClient = pointer->focusedSurface()->client();
const QList<Resource *> pointerResources = resourceMap().values(focusedClient->client());
for (Resource *pointerResource : pointerResources) {
if (pointerResource->client() == focusedClient->client()) {
Run clang-format If you want git blame to ignore formatting revisions run: git config blame.ignoreRevsFile .git-blame-ignore-revs
2021-08-29 05:11:06 +00:00
send_relative_motion(pointerResource->handle,
use std::chrono::microseconds for time in input events
2022-12-21 00:55:20 +00:00
time.count() >> 32,
time.count() & 0xffffffff,
wayland: Fix missing relative motion events Use isNull on QSizeF to check for a zero delta instead of comparing it with a default-constructed QSizeF, which in practice initializes to (-1.0,-1.0). This caused relative motion events to be omitted if the delta happened to be equal to (-1.0,-1.0), causing mouse jumping in some applications. BUG: 444510 Signed-off-by: John Brooks <john@fastquake.com>
2022-10-25 08:18:45 +00:00
wl_fixed_from_double(delta.x() * scaleOverride),
wl_fixed_from_double(delta.y() * scaleOverride),
wl_fixed_from_double(deltaNonAccelerated.x() * scaleOverride),
wl_fixed_from_double(deltaNonAccelerated.y() * scaleOverride));
Rewrite wl_pointer implementation with new approach With this design, a single PointerInterface manages multiple wl_pointer objects. This makes the API tidier and allows implementing things such as keyboard grabs more easier. In addition to that, the PointerInterface doesn't inject its own frame events anymore. It's up to the compositor to decide when it has to be sent. However, the PointerInterface may still send a frame event if the pointer focus changes. Besides re-writing the pointer interface, this change, unfortunately, also affects the implementation of pointer-gestures and relative-pointer protocols because previously they were coupled to individual instances of PointerInterface.
2021-02-12 22:29:45 +00:00
}
}
Port relative-pointer-v1 interface to the new design
2020-11-03 16:24:03 +00:00
}
wayland: Integrate KWaylandServer classes into KWin namespace
2023-09-13 17:59:29 +00:00
} // namespace KWin
Add explicit moc includes to sources for moc-covered headers * speeds up incremental builds as changes to a header will not always need the full mocs_compilation.cpp for all the target's headers rebuild, while having a moc file sourced into a source file only adds minor extra costs, due to small own code and the used headers usually already covered by the source file, being for the same class/struct * seems to not slow down clean builds, due to empty mocs_compilation.cpp resulting in those quickly processed, while the minor extra cost of the sourced moc files does not outweigh that in summary. Measured times actually improved by some percent points. (ideally CMake would just skip empty mocs_compilation.cpp & its object file one day) * enables compiler to see all methods of a class in same compilation unit to do some sanity checks * potentially more inlining in general, due to more in the compilation unit * allows to keep using more forward declarations in the header, as with the moc code being sourced into the cpp file there definitions can be ensured and often are already for the needs of the normal class methods
2023-07-05 06:30:14 +00:00
wayland: Drop "_interface" from filenames The cpp files in the wayland directory are named after protocol names. "_interface" does not contribute anything new.
2023-09-13 05:52:59 +00:00
#include "moc_relativepointer_v1.cpp"
Reference in a new issue Copy permalink