yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/autotests/integration/pointer_input.cpp

1855 lines
77 KiB
C++
Raw Normal View History

Prettify license headers
2020-08-02 22:22:19 +00:00
/*
KWin - the KDE window manager
This file is part of the KDE project.
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
Prettify license headers
2020-08-02 22:22:19 +00:00
SPDX-FileCopyrightText: 2016 Martin Gräßlin <mgraesslin@kde.org>
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
Prettify license headers
2020-08-02 22:22:19 +00:00
SPDX-License-Identifier: GPL-2.0-or-later
*/
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
#include "kwin_wayland_test.h"
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
#include "cursor.h"
#include "deleted.h"
Ensure PointerInputRedirection::processMotion finishes prior to warping Summary: Consider the following situation: we have three InputEventFilter linked in the sequence A - B - C. The input filters are processing pointer motion events. The expected behavior is that the new motion is processed in the sequence A -> B -> C So far this did not work correctly if the pointer gets warped during the processing. If e.g. filter B warps the pointer we get a motion sequence: A (1) -> B (1) -> A (2) -> B (2) -> C (2) -> C (1) The filters following the one warping the pointer get first the newer than the older position. This is obviously wrong. Unfortunately it is not just a theoretical condition, but a condition happening when interacting with the screenedges, which warp the pointer. This change introduces a PositionUpdateBlocker in PointerInputRedirection::processMotion to ensure that a processMotion call finishes prior to the next update. If the PositionUpdateBlocker is blocked the new position gets scheduled and processed once the PositionUpdateBlocker gets destroyed. With this we get the expected sequence for B warping pointer: A (1) -> B (1) -> C (1) -> A (2) -> B (2) -> C (2) This should hopefully improve the interaction with screen edges on Wayland. CCBUG: 374867 Test Plan: Added an auto test demonstrating the issue of incorrect ordering caused by screenedges. Prior to the change the test is failing. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5182
2017-03-26 13:53:09 +00:00
#include "effects.h"
[autotest] Validate set options in PointerInputTest::testModifierClickUnrestrictedMove Just to be sure, the code did what we wanted it to do.
2016-04-06 15:25:24 +00:00
#include "options.h"
Rename AbstractOutput to Output AbstractOutput is not so Abstract and it's common to avoid the word "Abstract" in class names as it doesn't contribute any new information. It also significantly reduces the line width in some places.
2022-04-14 12:33:28 +00:00
#include "output.h"
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
#include "platform.h"
#include "pointer_input.h"
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
#include "screenedge.h"
#include "screens.h"
Port Workspace::topClientOnDesktop() to VirtualDesktop This patch has one behavioral change - raiseOrLowerClient() will not work if the client is not on the current virtual desktop. However, raiseOrLowerClient() can be called only in two cases: * user triggers the raise or lower shortcut for the active client. Since the active client is on the current virtual desktop, it's not an issue * an x11 window restacks itself. It makes no sense if an x11 window restacks itself while it's inactive or not on current virtual desktop. Also, the Opposite restack mode is rarely used, some window managers don't even bother implementing it. So, having such a constraint should not be a problem. The main reason for not allowing raiseOrLowerClient() for windows that are not on the current virtual desktop is that a window can be on multiple virtual desktops. If a window is on A and B virtual desktops, the only logical option is to toggle stacking position if the window is on the current desktop. It's the only viable option as kwin does not maintain per virtual desktop stacking order.
2021-08-13 08:41:57 +00:00
#include "virtualdesktops.h"
Integrate kwaylandserver This makes KWin switch to in-tree copy of KWaylandServer codebase. KWaylandServer namespace has been left as is. It will be addressed later by renaming classes in order to fit in the KWin namespace.
2022-04-22 09:27:33 +00:00
#include "wayland/clientconnection.h"
#include "wayland/seat_interface.h"
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
#include "wayland_server.h"
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
#include "window.h"
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
#include "workspace.h"
[wayland] Rework Xcursor theme loading code Currently in order to load an Xcursor theme, kwin uses libwayland api, which looks really awkward because of the way how the compositor talks to itself via the internal connection. The main motivation behind this change is to limit the usage of kwayland client api in kwin.
2020-05-18 19:37:41 +00:00
#include "xcursortheme.h"
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
#include <kwineffects.h>
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
#include <KWayland/Client/buffer.h>
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
#include <KWayland/Client/compositor.h>
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
#include <KWayland/Client/connection_thread.h>
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
#include <KWayland/Client/pointer.h>
Adapt to input region changes in kwayland-server SurfaceInterface::inputIsInfinite() has been dropped. If the surface has no any input region specified, SurfaceInterface::input() will return a region that corresponds to the rect of the surface (0, 0, width, height). While the new design is more robust, for example it's no longer possible to forget to check SurfaceInterface::inputIsInfinite(), it has shown some issues in the input stack of kwin. Currently, acceptsInput() will return false if you attempt to click the server-side decoration for a surface whose input region is not empty. Therefore, it's possible for an application to set an input region with a width and a height of 1. If user doesn't know about KSysGuard or the possibility of closing apps via the task manager, they won't be able to close such an application. Another issue is that if an application has specified an empty input region on purpose, user will be still able click it. With the new behavior of SurfaceInterface::input(), this is no longer an issue and it is handled properly by kwin.
2020-10-17 12:47:25 +00:00
#include <KWayland/Client/region.h>
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
#include <KWayland/Client/seat.h>
Cancel popup if the user clicked window decoration of parent window Summary: So far the window decoration was not considered and e.g. right clicking the window decoration resulted in two open popups - one by KWin and one by the application. This change addresses the problem by ensuring the popup gets cancelled if the decoration is clicked. It's considered not being part of the window. Test Plan: Added test case which fails without the change Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5388
2017-04-10 16:19:45 +00:00
#include <KWayland/Client/server_decoration.h>
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
#include <KWayland/Client/shm_pool.h>
#include <KWayland/Client/surface.h>
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
#include <linux/input.h>
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
namespace KWin
{
[wayland] Rework Xcursor theme loading code Currently in order to load an Xcursor theme, kwin uses libwayland api, which looks really awkward because of the way how the compositor talks to itself via the internal connection. The main motivation behind this change is to limit the usage of kwayland client api in kwin.
2020-05-18 19:37:41 +00:00
static PlatformCursorImage loadReferenceThemeCursor_helper(const KXcursorTheme &theme,
const QByteArray &name)
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
{
[wayland] Rework Xcursor theme loading code Currently in order to load an Xcursor theme, kwin uses libwayland api, which looks really awkward because of the way how the compositor talks to itself via the internal connection. The main motivation behind this change is to limit the usage of kwayland client api in kwin.
2020-05-18 19:37:41 +00:00
const QVector<KXcursorSprite> sprites = theme.shape(name);
if (sprites.isEmpty()) {
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
return PlatformCursorImage();
}
wayland: Fix loading of HiDPI cursors Xcursors don't support hidpi so if a hidpi cursor is needed, kwin will scale the desired size by the scale factor and ask Xcursor helpers to load a theme with the given name and the size. However, the theme loading code doesn't take into account that Xcursor theme loading helpers may not return cursor sprites of size size * scale if the theme has no such a size. For example, if the cursor theme only provides 24, 36, and 48 sizes and kwin attempts to load cursors of size 48 with a scale factor of 2, we will get cursors of size 48 instead of 96. Unfortunately, this will result in the issue where the cursor shrinks when hovering decorations because kwin doesn't know that the effective scale factor (1) is different from the requested scale factor (2). In order to fix loading of HiDPI cursors, we need to approximate the effective scale factor of every cursor sprite as we load it.
2021-05-02 10:37:45 +00:00
return PlatformCursorImage(sprites.constFirst().data(), sprites.constFirst().hotspot());
[wayland] Rework Xcursor theme loading code Currently in order to load an Xcursor theme, kwin uses libwayland api, which looks really awkward because of the way how the compositor talks to itself via the internal connection. The main motivation behind this change is to limit the usage of kwayland client api in kwin.
2020-05-18 19:37:41 +00:00
}
static PlatformCursorImage loadReferenceThemeCursor(const QByteArray &name)
{
const Cursor *pointerCursor = Cursors::self()->mouse();
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
wayland: Rework Xcursor theme loading Xcursor loading code has hardcoded search paths, in order to take into account distros installing app data in a different location, libwayland-cursor sets the ICONDIR to the icon directory computed based on the install prefix. However, that won't work with gitlab CI because it relocates binaries. A more robust way to find cursors would be to use QStandardPaths to find all the icon directories on the system. Another advantage of using own cursor loading code is that it allows us to reuse cursor images that are symlinks. For example, with breeze_cursors, almost half of the files in the cursors directory are symlinks. The main disadvantage of this approach is that we would have to keep the search paths up to date. However, on the hand, there are not that many of them, e.g. ~/.icons, ~/.local/share/icons, /usr/share/icons, /usr/local/share/icons. The last three are implicitly handled by the QStandardPaths.
2022-01-27 20:47:11 +00:00
const KXcursorTheme theme(pointerCursor->themeName(), pointerCursor->themeSize(), screens()->maxScale());
[wayland] Rework Xcursor theme loading code Currently in order to load an Xcursor theme, kwin uses libwayland api, which looks really awkward because of the way how the compositor talks to itself via the internal connection. The main motivation behind this change is to limit the usage of kwayland client api in kwin.
2020-05-18 19:37:41 +00:00
if (theme.isEmpty()) {
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
return PlatformCursorImage();
}
[wayland] Rework Xcursor theme loading code Currently in order to load an Xcursor theme, kwin uses libwayland api, which looks really awkward because of the way how the compositor talks to itself via the internal connection. The main motivation behind this change is to limit the usage of kwayland client api in kwin.
2020-05-18 19:37:41 +00:00
PlatformCursorImage platformCursorImage = loadReferenceThemeCursor_helper(theme, name);
if (!platformCursorImage.isNull()) {
return platformCursorImage;
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
}
[wayland] Rework Xcursor theme loading code Currently in order to load an Xcursor theme, kwin uses libwayland api, which looks really awkward because of the way how the compositor talks to itself via the internal connection. The main motivation behind this change is to limit the usage of kwayland client api in kwin.
2020-05-18 19:37:41 +00:00
const QVector<QByteArray> alternativeNames = Cursor::cursorAlternativeNames(name);
for (const QByteArray &alternativeName : alternativeNames) {
platformCursorImage = loadReferenceThemeCursor_helper(theme, alternativeName);
if (!platformCursorImage.isNull()) {
break;
}
}
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
[wayland] Rework Xcursor theme loading code Currently in order to load an Xcursor theme, kwin uses libwayland api, which looks really awkward because of the way how the compositor talks to itself via the internal connection. The main motivation behind this change is to limit the usage of kwayland client api in kwin.
2020-05-18 19:37:41 +00:00
return platformCursorImage;
}
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
[wayland] Rework Xcursor theme loading code Currently in order to load an Xcursor theme, kwin uses libwayland api, which looks really awkward because of the way how the compositor talks to itself via the internal connection. The main motivation behind this change is to limit the usage of kwayland client api in kwin.
2020-05-18 19:37:41 +00:00
static PlatformCursorImage loadReferenceThemeCursor(const CursorShape &shape)
{
return loadReferenceThemeCursor(shape.name());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
}
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
static const QString s_socketName = QStringLiteral("wayland_test_kwin_pointer_input-0");
class PointerInputTest : public QObject
{
Q_OBJECT
private Q_SLOTS:
void initTestCase();
void init();
void cleanup();
void testWarpingUpdatesFocus();
void testWarpingGeneratesPointerMotion();
Ensure PointerInputRedirection::processMotion finishes prior to warping Summary: Consider the following situation: we have three InputEventFilter linked in the sequence A - B - C. The input filters are processing pointer motion events. The expected behavior is that the new motion is processed in the sequence A -> B -> C So far this did not work correctly if the pointer gets warped during the processing. If e.g. filter B warps the pointer we get a motion sequence: A (1) -> B (1) -> A (2) -> B (2) -> C (2) -> C (1) The filters following the one warping the pointer get first the newer than the older position. This is obviously wrong. Unfortunately it is not just a theoretical condition, but a condition happening when interacting with the screenedges, which warp the pointer. This change introduces a PositionUpdateBlocker in PointerInputRedirection::processMotion to ensure that a processMotion call finishes prior to the next update. If the PositionUpdateBlocker is blocked the new position gets scheduled and processed once the PositionUpdateBlocker gets destroyed. With this we get the expected sequence for B warping pointer: A (1) -> B (1) -> C (1) -> A (2) -> B (2) -> C (2) This should hopefully improve the interaction with screen edges on Wayland. CCBUG: 374867 Test Plan: Added an auto test demonstrating the issue of incorrect ordering caused by screenedges. Prior to the change the test is failing. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5182
2017-03-26 13:53:09 +00:00
void testWarpingDuringFilter();
autotests: Test moving pointer between windows
2022-02-23 20:48:18 +00:00
void testWarpingBetweenWindows();
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
void testUpdateFocusAfterScreenChange();
unit test for focusing loss problem on maximize BUG: 411884
2021-07-16 13:25:39 +00:00
void testUpdateFocusOnDecorationDestroy();
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
void testModifierClickUnrestrictedMove_data();
void testModifierClickUnrestrictedMove();
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
void testModifierClickUnrestrictedMoveGlobalShortcutsDisabled();
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
void testModifierScrollOpacity_data();
void testModifierScrollOpacity();
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
void testModifierScrollOpacityGlobalShortcutsDisabled();
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
void testScrollAction();
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
void testFocusFollowsMouse();
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
void testMouseActionInactiveWindow_data();
void testMouseActionInactiveWindow();
void testMouseActionActiveWindow_data();
void testMouseActionActiveWindow();
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
void testCursorImage();
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
void testEffectOverrideCursorImage();
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
void testPopup();
Cancel popup if the user clicked window decoration of parent window Summary: So far the window decoration was not considered and e.g. right clicking the window decoration resulted in two open popups - one by KWin and one by the application. This change addresses the problem by ensuring the popup gets cancelled if the decoration is clicked. It's considered not being part of the window. Test Plan: Added test case which fails without the change Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5388
2017-04-10 16:19:45 +00:00
void testDecoCancelsPopup();
Don't update the focused pointer Surface if a button is pressed Summary: During pointer motion we already had the condition that an update of focused pointer surface can only happen when no button is pressed. But there are more conditions where we try to update the focused pointer even if a button is pressed. E.g. if the stacking order changes. This happens when trying to move one of Qt's dock widgets: 1. Press inside a dock widget 2. Qt opens another window, which is underneath the cursor 3. KWin sends pointer leave to parent window 4. dock widget movement breaks This change ensures that also this sequence works as expected and the pointer gets only updated when there are no buttons pressed, no matter from where we go into the update code path. BUG: 372876 Test Plan: Dock widgets in Dolphin can be moved now. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5461
2017-04-15 09:36:21 +00:00
void testWindowUnderCursorWhileButtonPressed();
[wayland] Confine pointer to screen geometry Summary: If the new pointer position is "off screen", PointerInputRedirection just ignores that new position. So, pointer remains on its previous position. In some particular cases, like reaching default panel, it degrades desktop experience because one have to slowly move pointer in order to reach what he/she wants. This change addresses that problem by confining the new pointer position to screen geometry. BUG: 374867 FIXED-IN: 5.13.4 Test Plan: Ran tests Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14036
2018-07-10 18:09:22 +00:00
void testConfineToScreenGeometry_data();
void testConfineToScreenGeometry();
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
void testResizeCursor_data();
void testResizeCursor();
void testMoveCursor();
[autotests] Don't test wl-shell clients Summary: This change removes all traces of wl-shell in the test suite. That's a prerequisite for dropping wl-shell support in KWin. Given that wl-shell and xdg-shell are not interchangeable, some tests were removed and initialization sequence in some tests was adjusted. The most notable change is ensuring that each plasmashell window sets its role and initial position before committing the surface. Setting those properties before the first surface commit is important because our window placement code needs to know window type in order to avoid maximizing panels, popups, etc. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23561
2019-08-27 15:01:14 +00:00
void testHideShowCursor();
Adapt to input region changes in kwayland-server SurfaceInterface::inputIsInfinite() has been dropped. If the surface has no any input region specified, SurfaceInterface::input() will return a region that corresponds to the rect of the surface (0, 0, width, height). While the new design is more robust, for example it's no longer possible to forget to check SurfaceInterface::inputIsInfinite(), it has shown some issues in the input stack of kwin. Currently, acceptsInput() will return false if you attempt to click the server-side decoration for a surface whose input region is not empty. Therefore, it's possible for an application to set an input region with a width and a height of 1. If user doesn't know about KSysGuard or the possibility of closing apps via the task manager, they won't be able to close such an application. Another issue is that if an application has specified an empty input region on purpose, user will be still able click it. With the new behavior of SurfaceInterface::input(), this is no longer an issue and it is handled properly by kwin.
2020-10-17 12:47:25 +00:00
void testDefaultInputRegion();
void testEmptyInputRegion();
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
private:
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
void render(KWayland::Client::Surface *surface, const QSize &size = QSize(100, 50));
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
KWayland::Client::Compositor *m_compositor = nullptr;
KWayland::Client::Seat *m_seat = nullptr;
};
void PointerInputTest::initTestCase()
{
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
qRegisterMetaType<KWin::Window *>();
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
qRegisterMetaType<KWin::Deleted *>();
Introduce started signal in Application The new signal is emitted when the Application has fully been initialized. It allows us to change the startup sequence, for example create workspace before starting the Xwayland server, without making any adjustments in our test suit.
2020-07-07 09:32:29 +00:00
QSignalSpy applicationStartedSpy(kwinApp(), &Application::started);
QVERIFY(applicationStartedSpy.isValid());
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
Avoid converting socket name between QString and QByteArray back and forth It only contributes overhead.
2020-12-09 13:06:15 +00:00
QVERIFY(waylandServer()->init(s_socketName));
[platforms/virtual] Create output devices Summary: Create output devices in virtual backend. For that the setVirtualOutputs call can only come after the Wayland server has been initiliazied such that the display exists to create the output and output device interfaces. Tests have been adjusted for that. Test Plan: ``` 98% tests passed, 3 tests failed out of 148 Total Test time (real) = 362.97 sec The following tests FAILED: 33 - kwin-testInternalWindow (Failed) 39 - kwin-testPointerInput (Failed) 101 - kwin-testMoveResize (Failed) ``` Failing of these tests looks unrelated to the change. Reviewers: #kwin Subscribers: kwin Tags: #kwin Maniphest Tasks: T11459 Differential Revision: https://phabricator.kde.org/D23477
2019-08-26 21:16:53 +00:00
QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
[autotests] Try to detect whether distro calls cursor theme DMZ-White or Vanilla-DMZ Some distributions (e.g. Arch, FreeBSD) call the DMZ-White cursor theme Vanilla-DMZ. Due to that our tests are failing even if the correct theme is installed (see also T6623). This change tries to detect whether DMZ-White is installed by looking into the GenericDataLocation. If not found we set to Vanilla-DMZ. No guarantee that the check works for all setups, but it's only tests...
2017-09-24 12:51:35 +00:00
if (!QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("icons/DMZ-White/index.theme")).isEmpty()) {
qputenv("XCURSOR_THEME", QByteArrayLiteral("DMZ-White"));
} else {
// might be vanilla-dmz (e.g. Arch, FreeBSD)
qputenv("XCURSOR_THEME", QByteArrayLiteral("Vanilla-DMZ"));
}
[autotests] Use DMZ-White as cursor theme On build.kde.org we cannot use the breeze cursor theme. Instead we have DMZ-White (debian package dmz-cursor-theme). This change adjusts the PointerInput test to enforce DMZ-White and uses SizeAllCursor instead of OpenHandCursor as that one seems to be missing in that theme. Hopefully with these changes the test starts to pass on build.kde.org.
2016-04-05 06:36:53 +00:00
qputenv("XCURSOR_SIZE", QByteArrayLiteral("24"));
[autotests] Force more tests to use evdev as XKB_DEFAULT_RULES Should help fixing the tests on FreeBSD.
2017-09-18 19:05:34 +00:00
qputenv("XKB_DEFAULT_RULES", "evdev");
[autotests] Specify XCUROSR_THEME and XCURSOR_SIZE in pointer input test Try to fix test on CI system. With neither a config nor the env variables the cursor selection falls back to the default cursor theme, which might not contain the cursors we need.
2016-02-25 12:51:45 +00:00
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
kwinApp()->start();
Introduce started signal in Application The new signal is emitted when the Application has fully been initialized. It allows us to change the startup sequence, for example create workspace before starting the Xwayland server, without making any adjustments in our test suit.
2020-07-07 09:32:29 +00:00
QVERIFY(applicationStartedSpy.wait());
autotests: Port common screen check preamble to AbstractOutput
2021-08-31 07:03:05 +00:00
const auto outputs = kwinApp()->platform()->enabledOutputs();
QCOMPARE(outputs.count(), 2);
QCOMPARE(outputs[0]->geometry(), QRect(0, 0, 1280, 1024));
QCOMPARE(outputs[1]->geometry(), QRect(1280, 0, 1280, 1024));
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
setenv("QT_QPA_PLATFORM", "wayland", true);
Ensure we start our tests with wayland already initialised When debugging modifier_only_shortcut_test in _waylandonly mode I saw that it was failing, among other things, because some aspects were not initialised. This changes every test we have to run the new Test::initWaylandWorkspace() that calls waylandServer()->initWorkspace() but also makes sure that WaylandServer::initialized is emitted before we proceed.
2021-05-08 00:08:22 +00:00
Test::initWaylandWorkspace();
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
}
void PointerInputTest::init()
{
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat | Test::AdditionalWaylandInterface::Decoration | Test::AdditionalWaylandInterface::XdgDecorationV1));
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
QVERIFY(Test::waitForWaylandPointer());
m_compositor = Test::waylandCompositor();
m_seat = Test::waylandSeat();
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
Move active output tracking to workspace Active output is a window management concept. It indicates what output new windows have to be placed on if they have no output hint. So Workspace seems to be a better place for it than the Screens class, which is obsolete.
2021-08-28 18:58:29 +00:00
workspace()->setActiveOutput(QPoint(640, 512));
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(QPoint(640, 512));
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
}
void PointerInputTest::cleanup()
{
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Test::destroyWaylandConnection();
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
}
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
void PointerInputTest::render(KWayland::Client::Surface *surface, const QSize &size)
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
{
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Test::render(surface, size, Qt::blue);
Test::flushWaylandConnection();
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
}
void PointerInputTest::testWarpingUpdatesFocus()
{
// this test verifies that warping the pointer creates pointer enter and leave events
using namespace KWayland::Client;
// create pointer and signal spy for enter and leave signals
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy enteredSpy(pointer, &Pointer::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy leftSpy(pointer, &Pointer::left);
QVERIFY(leftSpy.isValid());
// create a window
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface = Test::createSurface(m_compositor);
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(surface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface, surface);
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window = workspace()->activeClient();
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(window);
// currently there should not be a focused pointer surface
QVERIFY(!waylandServer()->seat()->focusedPointerSurface());
QVERIFY(!pointer->enteredSurface());
// enter
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(QPoint(25, 25));
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 1);
[wayland] Ensure that pointer enter event carries the correct coordinates So far KWin's pointer surface enter handling was: 1. update fouced surface 2. update the global position On client side this resulted in: 1. Enter with incorrect coordinates 2. move event to correct coordinate With QtWayland this results in the case of multiple surfaces in one application that Qt doesn't properly process the enter event and the Window never getting pointer focus and not reacting on any pointer input events. The root problem is that the KWayland server API is not ideal for supporting this situation. There is an API call for setting the global position (which causes a pointer motion for the focused surface) and an API call to update the focused surface. But a combination for both is (still) missing. This change addresses the problem by first unsetting the entered surface, then updating the global position and afterwards setting the new surface. Thus the position is correct. While this needs to be made better in KWayland, this is an urgency bug fix to get the behavior correct and thus first working around the API deficit and not first extending in KWayland. Reviewed-By: bshah
2016-08-04 08:39:23 +00:00
QCOMPARE(enteredSpy.first().at(1).toPointF(), QPointF(25, 25));
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
// window should have focus
QCOMPARE(pointer->enteredSurface(), surface);
// also on the server
QCOMPARE(waylandServer()->seat()->focusedPointerSurface(), window->surface());
// and out again
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
Cursors::self()->mouse()->setPos(QPoint(250, 250));
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(leftSpy.wait());
QCOMPARE(leftSpy.count(), 1);
// there should not be a focused pointer surface anymore
QVERIFY(!waylandServer()->seat()->focusedPointerSurface());
QVERIFY(!pointer->enteredSurface());
}
void PointerInputTest::testWarpingGeneratesPointerMotion()
{
// this test verifies that warping the pointer creates pointer motion events
using namespace KWayland::Client;
// create pointer and signal spy for enter and motion
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy enteredSpy(pointer, &Pointer::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy movedSpy(pointer, &Pointer::motion);
QVERIFY(movedSpy.isValid());
// create a window
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface = Test::createSurface(m_compositor);
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(surface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface, surface);
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window = workspace()->activeClient();
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(window);
// enter
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerMotion(QPointF(25, 25), 1);
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(enteredSpy.wait());
[wayland] Ensure that pointer enter event carries the correct coordinates So far KWin's pointer surface enter handling was: 1. update fouced surface 2. update the global position On client side this resulted in: 1. Enter with incorrect coordinates 2. move event to correct coordinate With QtWayland this results in the case of multiple surfaces in one application that Qt doesn't properly process the enter event and the Window never getting pointer focus and not reacting on any pointer input events. The root problem is that the KWayland server API is not ideal for supporting this situation. There is an API call for setting the global position (which causes a pointer motion for the focused surface) and an API call to update the focused surface. But a combination for both is (still) missing. This change addresses the problem by first unsetting the entered surface, then updating the global position and afterwards setting the new surface. Thus the position is correct. While this needs to be made better in KWayland, this is an urgency bug fix to get the behavior correct and thus first working around the API deficit and not first extending in KWayland. Reviewed-By: bshah
2016-08-04 08:39:23 +00:00
QCOMPARE(enteredSpy.first().at(1).toPointF(), QPointF(25, 25));
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
// now warp
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(QPoint(26, 26));
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QVERIFY(movedSpy.wait());
[wayland] Ensure that pointer enter event carries the correct coordinates So far KWin's pointer surface enter handling was: 1. update fouced surface 2. update the global position On client side this resulted in: 1. Enter with incorrect coordinates 2. move event to correct coordinate With QtWayland this results in the case of multiple surfaces in one application that Qt doesn't properly process the enter event and the Window never getting pointer focus and not reacting on any pointer input events. The root problem is that the KWayland server API is not ideal for supporting this situation. There is an API call for setting the global position (which causes a pointer motion for the focused surface) and an API call to update the focused surface. But a combination for both is (still) missing. This change addresses the problem by first unsetting the entered surface, then updating the global position and afterwards setting the new surface. Thus the position is correct. While this needs to be made better in KWayland, this is an urgency bug fix to get the behavior correct and thus first working around the API deficit and not first extending in KWayland. Reviewed-By: bshah
2016-08-04 08:39:23 +00:00
QCOMPARE(movedSpy.count(), 1);
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
QCOMPARE(movedSpy.last().first().toPointF(), QPointF(26, 26));
}
Ensure PointerInputRedirection::processMotion finishes prior to warping Summary: Consider the following situation: we have three InputEventFilter linked in the sequence A - B - C. The input filters are processing pointer motion events. The expected behavior is that the new motion is processed in the sequence A -> B -> C So far this did not work correctly if the pointer gets warped during the processing. If e.g. filter B warps the pointer we get a motion sequence: A (1) -> B (1) -> A (2) -> B (2) -> C (2) -> C (1) The filters following the one warping the pointer get first the newer than the older position. This is obviously wrong. Unfortunately it is not just a theoretical condition, but a condition happening when interacting with the screenedges, which warp the pointer. This change introduces a PositionUpdateBlocker in PointerInputRedirection::processMotion to ensure that a processMotion call finishes prior to the next update. If the PositionUpdateBlocker is blocked the new position gets scheduled and processed once the PositionUpdateBlocker gets destroyed. With this we get the expected sequence for B warping pointer: A (1) -> B (1) -> C (1) -> A (2) -> B (2) -> C (2) This should hopefully improve the interaction with screen edges on Wayland. CCBUG: 374867 Test Plan: Added an auto test demonstrating the issue of incorrect ordering caused by screenedges. Prior to the change the test is failing. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5182
2017-03-26 13:53:09 +00:00
void PointerInputTest::testWarpingDuringFilter()
{
// this test verifies that pointer motion is handled correctly if
// the pointer gets warped during processing of input events
using namespace KWayland::Client;
// create pointer
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy movedSpy(pointer, &Pointer::motion);
QVERIFY(movedSpy.isValid());
// warp cursor into expected geometry
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(10, 10);
Ensure PointerInputRedirection::processMotion finishes prior to warping Summary: Consider the following situation: we have three InputEventFilter linked in the sequence A - B - C. The input filters are processing pointer motion events. The expected behavior is that the new motion is processed in the sequence A -> B -> C So far this did not work correctly if the pointer gets warped during the processing. If e.g. filter B warps the pointer we get a motion sequence: A (1) -> B (1) -> A (2) -> B (2) -> C (2) -> C (1) The filters following the one warping the pointer get first the newer than the older position. This is obviously wrong. Unfortunately it is not just a theoretical condition, but a condition happening when interacting with the screenedges, which warp the pointer. This change introduces a PositionUpdateBlocker in PointerInputRedirection::processMotion to ensure that a processMotion call finishes prior to the next update. If the PositionUpdateBlocker is blocked the new position gets scheduled and processed once the PositionUpdateBlocker gets destroyed. With this we get the expected sequence for B warping pointer: A (1) -> B (1) -> C (1) -> A (2) -> B (2) -> C (2) This should hopefully improve the interaction with screen edges on Wayland. CCBUG: 374867 Test Plan: Added an auto test demonstrating the issue of incorrect ordering caused by screenedges. Prior to the change the test is failing. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5182
2017-03-26 13:53:09 +00:00
// create a window
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
Ensure PointerInputRedirection::processMotion finishes prior to warping Summary: Consider the following situation: we have three InputEventFilter linked in the sequence A - B - C. The input filters are processing pointer motion events. The expected behavior is that the new motion is processed in the sequence A -> B -> C So far this did not work correctly if the pointer gets warped during the processing. If e.g. filter B warps the pointer we get a motion sequence: A (1) -> B (1) -> A (2) -> B (2) -> C (2) -> C (1) The filters following the one warping the pointer get first the newer than the older position. This is obviously wrong. Unfortunately it is not just a theoretical condition, but a condition happening when interacting with the screenedges, which warp the pointer. This change introduces a PositionUpdateBlocker in PointerInputRedirection::processMotion to ensure that a processMotion call finishes prior to the next update. If the PositionUpdateBlocker is blocked the new position gets scheduled and processed once the PositionUpdateBlocker gets destroyed. With this we get the expected sequence for B warping pointer: A (1) -> B (1) -> C (1) -> A (2) -> B (2) -> C (2) This should hopefully improve the interaction with screen edges on Wayland. CCBUG: 374867 Test Plan: Added an auto test demonstrating the issue of incorrect ordering caused by screenedges. Prior to the change the test is failing. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5182
2017-03-26 13:53:09 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface = Test::createSurface(m_compositor);
Ensure PointerInputRedirection::processMotion finishes prior to warping Summary: Consider the following situation: we have three InputEventFilter linked in the sequence A - B - C. The input filters are processing pointer motion events. The expected behavior is that the new motion is processed in the sequence A -> B -> C So far this did not work correctly if the pointer gets warped during the processing. If e.g. filter B warps the pointer we get a motion sequence: A (1) -> B (1) -> A (2) -> B (2) -> C (2) -> C (1) The filters following the one warping the pointer get first the newer than the older position. This is obviously wrong. Unfortunately it is not just a theoretical condition, but a condition happening when interacting with the screenedges, which warp the pointer. This change introduces a PositionUpdateBlocker in PointerInputRedirection::processMotion to ensure that a processMotion call finishes prior to the next update. If the PositionUpdateBlocker is blocked the new position gets scheduled and processed once the PositionUpdateBlocker gets destroyed. With this we get the expected sequence for B warping pointer: A (1) -> B (1) -> C (1) -> A (2) -> B (2) -> C (2) This should hopefully improve the interaction with screen edges on Wayland. CCBUG: 374867 Test Plan: Added an auto test demonstrating the issue of incorrect ordering caused by screenedges. Prior to the change the test is failing. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5182
2017-03-26 13:53:09 +00:00
QVERIFY(surface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface, surface);
Ensure PointerInputRedirection::processMotion finishes prior to warping Summary: Consider the following situation: we have three InputEventFilter linked in the sequence A - B - C. The input filters are processing pointer motion events. The expected behavior is that the new motion is processed in the sequence A -> B -> C So far this did not work correctly if the pointer gets warped during the processing. If e.g. filter B warps the pointer we get a motion sequence: A (1) -> B (1) -> A (2) -> B (2) -> C (2) -> C (1) The filters following the one warping the pointer get first the newer than the older position. This is obviously wrong. Unfortunately it is not just a theoretical condition, but a condition happening when interacting with the screenedges, which warp the pointer. This change introduces a PositionUpdateBlocker in PointerInputRedirection::processMotion to ensure that a processMotion call finishes prior to the next update. If the PositionUpdateBlocker is blocked the new position gets scheduled and processed once the PositionUpdateBlocker gets destroyed. With this we get the expected sequence for B warping pointer: A (1) -> B (1) -> C (1) -> A (2) -> B (2) -> C (2) This should hopefully improve the interaction with screen edges on Wayland. CCBUG: 374867 Test Plan: Added an auto test demonstrating the issue of incorrect ordering caused by screenedges. Prior to the change the test is failing. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5182
2017-03-26 13:53:09 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window = workspace()->activeClient();
Ensure PointerInputRedirection::processMotion finishes prior to warping Summary: Consider the following situation: we have three InputEventFilter linked in the sequence A - B - C. The input filters are processing pointer motion events. The expected behavior is that the new motion is processed in the sequence A -> B -> C So far this did not work correctly if the pointer gets warped during the processing. If e.g. filter B warps the pointer we get a motion sequence: A (1) -> B (1) -> A (2) -> B (2) -> C (2) -> C (1) The filters following the one warping the pointer get first the newer than the older position. This is obviously wrong. Unfortunately it is not just a theoretical condition, but a condition happening when interacting with the screenedges, which warp the pointer. This change introduces a PositionUpdateBlocker in PointerInputRedirection::processMotion to ensure that a processMotion call finishes prior to the next update. If the PositionUpdateBlocker is blocked the new position gets scheduled and processed once the PositionUpdateBlocker gets destroyed. With this we get the expected sequence for B warping pointer: A (1) -> B (1) -> C (1) -> A (2) -> B (2) -> C (2) This should hopefully improve the interaction with screen edges on Wayland. CCBUG: 374867 Test Plan: Added an auto test demonstrating the issue of incorrect ordering caused by screenedges. Prior to the change the test is failing. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5182
2017-03-26 13:53:09 +00:00
QVERIFY(window);
QCOMPARE(window->pos(), QPoint(0, 0));
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QVERIFY(window->frameGeometry().contains(Cursors::self()->mouse()->pos()));
Ensure PointerInputRedirection::processMotion finishes prior to warping Summary: Consider the following situation: we have three InputEventFilter linked in the sequence A - B - C. The input filters are processing pointer motion events. The expected behavior is that the new motion is processed in the sequence A -> B -> C So far this did not work correctly if the pointer gets warped during the processing. If e.g. filter B warps the pointer we get a motion sequence: A (1) -> B (1) -> A (2) -> B (2) -> C (2) -> C (1) The filters following the one warping the pointer get first the newer than the older position. This is obviously wrong. Unfortunately it is not just a theoretical condition, but a condition happening when interacting with the screenedges, which warp the pointer. This change introduces a PositionUpdateBlocker in PointerInputRedirection::processMotion to ensure that a processMotion call finishes prior to the next update. If the PositionUpdateBlocker is blocked the new position gets scheduled and processed once the PositionUpdateBlocker gets destroyed. With this we get the expected sequence for B warping pointer: A (1) -> B (1) -> C (1) -> A (2) -> B (2) -> C (2) This should hopefully improve the interaction with screen edges on Wayland. CCBUG: 374867 Test Plan: Added an auto test demonstrating the issue of incorrect ordering caused by screenedges. Prior to the change the test is failing. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5182
2017-03-26 13:53:09 +00:00
// is PresentWindows effect for top left screen edge loaded
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QVERIFY(static_cast<EffectsHandlerImpl *>(effects)->isEffectLoaded("presentwindows"));
Ensure PointerInputRedirection::processMotion finishes prior to warping Summary: Consider the following situation: we have three InputEventFilter linked in the sequence A - B - C. The input filters are processing pointer motion events. The expected behavior is that the new motion is processed in the sequence A -> B -> C So far this did not work correctly if the pointer gets warped during the processing. If e.g. filter B warps the pointer we get a motion sequence: A (1) -> B (1) -> A (2) -> B (2) -> C (2) -> C (1) The filters following the one warping the pointer get first the newer than the older position. This is obviously wrong. Unfortunately it is not just a theoretical condition, but a condition happening when interacting with the screenedges, which warp the pointer. This change introduces a PositionUpdateBlocker in PointerInputRedirection::processMotion to ensure that a processMotion call finishes prior to the next update. If the PositionUpdateBlocker is blocked the new position gets scheduled and processed once the PositionUpdateBlocker gets destroyed. With this we get the expected sequence for B warping pointer: A (1) -> B (1) -> C (1) -> A (2) -> B (2) -> C (2) This should hopefully improve the interaction with screen edges on Wayland. CCBUG: 374867 Test Plan: Added an auto test demonstrating the issue of incorrect ordering caused by screenedges. Prior to the change the test is failing. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5182
2017-03-26 13:53:09 +00:00
QVERIFY(movedSpy.isEmpty());
quint32 timestamp = 0;
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerMotion(QPoint(0, 0), timestamp++);
Ensure PointerInputRedirection::processMotion finishes prior to warping Summary: Consider the following situation: we have three InputEventFilter linked in the sequence A - B - C. The input filters are processing pointer motion events. The expected behavior is that the new motion is processed in the sequence A -> B -> C So far this did not work correctly if the pointer gets warped during the processing. If e.g. filter B warps the pointer we get a motion sequence: A (1) -> B (1) -> A (2) -> B (2) -> C (2) -> C (1) The filters following the one warping the pointer get first the newer than the older position. This is obviously wrong. Unfortunately it is not just a theoretical condition, but a condition happening when interacting with the screenedges, which warp the pointer. This change introduces a PositionUpdateBlocker in PointerInputRedirection::processMotion to ensure that a processMotion call finishes prior to the next update. If the PositionUpdateBlocker is blocked the new position gets scheduled and processed once the PositionUpdateBlocker gets destroyed. With this we get the expected sequence for B warping pointer: A (1) -> B (1) -> C (1) -> A (2) -> B (2) -> C (2) This should hopefully improve the interaction with screen edges on Wayland. CCBUG: 374867 Test Plan: Added an auto test demonstrating the issue of incorrect ordering caused by screenedges. Prior to the change the test is failing. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5182
2017-03-26 13:53:09 +00:00
// screen edges push back
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(1, 1));
Ensure PointerInputRedirection::processMotion finishes prior to warping Summary: Consider the following situation: we have three InputEventFilter linked in the sequence A - B - C. The input filters are processing pointer motion events. The expected behavior is that the new motion is processed in the sequence A -> B -> C So far this did not work correctly if the pointer gets warped during the processing. If e.g. filter B warps the pointer we get a motion sequence: A (1) -> B (1) -> A (2) -> B (2) -> C (2) -> C (1) The filters following the one warping the pointer get first the newer than the older position. This is obviously wrong. Unfortunately it is not just a theoretical condition, but a condition happening when interacting with the screenedges, which warp the pointer. This change introduces a PositionUpdateBlocker in PointerInputRedirection::processMotion to ensure that a processMotion call finishes prior to the next update. If the PositionUpdateBlocker is blocked the new position gets scheduled and processed once the PositionUpdateBlocker gets destroyed. With this we get the expected sequence for B warping pointer: A (1) -> B (1) -> C (1) -> A (2) -> B (2) -> C (2) This should hopefully improve the interaction with screen edges on Wayland. CCBUG: 374867 Test Plan: Added an auto test demonstrating the issue of incorrect ordering caused by screenedges. Prior to the change the test is failing. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5182
2017-03-26 13:53:09 +00:00
QVERIFY(movedSpy.wait());
QCOMPARE(movedSpy.count(), 2);
QCOMPARE(movedSpy.at(0).first().toPoint(), QPoint(0, 0));
QCOMPARE(movedSpy.at(1).first().toPoint(), QPoint(1, 1));
}
autotests: Test moving pointer between windows
2022-02-23 20:48:18 +00:00
void PointerInputTest::testWarpingBetweenWindows()
{
// This test verifies that the compositor will send correct events when the pointer
// leaves one window and enters another window.
QScopedPointer<KWayland::Client::Pointer> pointer(m_seat->createPointer(m_seat));
QSignalSpy enteredSpy(pointer.data(), &KWayland::Client::Pointer::entered);
QSignalSpy leftSpy(pointer.data(), &KWayland::Client::Pointer::left);
QSignalSpy motionSpy(pointer.data(), &KWayland::Client::Pointer::motion);
// create windows
QScopedPointer<KWayland::Client::Surface> surface1(Test::createSurface());
QScopedPointer<Test::XdgToplevel> shellSurface1(Test::createXdgToplevelSurface(surface1.data()));
auto client1 = Test::renderAndWaitForShown(surface1.data(), QSize(100, 50), Qt::cyan);
QScopedPointer<KWayland::Client::Surface> surface2(Test::createSurface());
QScopedPointer<Test::XdgToplevel> shellSurface2(Test::createXdgToplevelSurface(surface2.data()));
auto client2 = Test::renderAndWaitForShown(surface2.data(), QSize(200, 100), Qt::red);
// place windows side by side
client1->move(QPoint(0, 0));
client2->move(QPoint(100, 0));
quint32 timestamp = 0;
// put the pointer at the center of the first window
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerMotion(client1->frameGeometry().center(), timestamp++);
autotests: Test moving pointer between windows
2022-02-23 20:48:18 +00:00
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 1);
QCOMPARE(enteredSpy.last().at(1).toPointF(), QPointF(49, 24));
QCOMPARE(leftSpy.count(), 0);
QCOMPARE(motionSpy.count(), 0);
QCOMPARE(pointer->enteredSurface(), surface1.data());
// put the pointer at the center of the second window
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerMotion(client2->frameGeometry().center(), timestamp++);
autotests: Test moving pointer between windows
2022-02-23 20:48:18 +00:00
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 2);
QCOMPARE(enteredSpy.last().at(1).toPointF(), QPointF(99, 49));
QCOMPARE(leftSpy.count(), 1);
QCOMPARE(motionSpy.count(), 0);
QCOMPARE(pointer->enteredSurface(), surface2.data());
}
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
void PointerInputTest::testUpdateFocusAfterScreenChange()
{
// this test verifies that a pointer enter event is generated when the cursor changes to another
// screen due to removal of screen
using namespace KWayland::Client;
// create pointer and signal spy for enter and motion
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy enteredSpy(pointer, &Pointer::entered);
QVERIFY(enteredSpy.isValid());
autotests: Fix PointerInputTest The "Active screen follows mouse" option may make the test fail. We want it to pass no matter what the current value of the option is.
2020-12-03 09:37:28 +00:00
QSignalSpy leftSpy(pointer, &Pointer::left);
QVERIFY(leftSpy.isValid());
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
// create a window
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface = Test::createSurface(m_compositor);
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
QVERIFY(surface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface, surface);
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
QVERIFY(shellSurface);
render(surface, QSize(1280, 1024));
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window = workspace()->activeClient();
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
QVERIFY(window);
autotests: Fix PointerInputTest The "Active screen follows mouse" option may make the test fail. We want it to pass no matter what the current value of the option is.
2020-12-03 09:37:28 +00:00
QVERIFY(window->frameGeometry().contains(Cursors::self()->mouse()->pos()));
wayland: Adjust kwin to PointerInterface changes
2021-02-22 10:51:26 +00:00
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 1);
autotests: Fix PointerInputTest The "Active screen follows mouse" option may make the test fail. We want it to pass no matter what the current value of the option is.
2020-12-03 09:37:28 +00:00
// move the cursor to the second screen
Cursors::self()->mouse()->setPos(1500, 300);
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QVERIFY(!window->frameGeometry().contains(Cursors::self()->mouse()->pos()));
autotests: Fix PointerInputTest The "Active screen follows mouse" option may make the test fail. We want it to pass no matter what the current value of the option is.
2020-12-03 09:37:28 +00:00
QVERIFY(leftSpy.wait());
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
QSignalSpy screensChangedSpy(screens(), &Screens::changed);
QVERIFY(screensChangedSpy.isValid());
// now let's remove the screen containing the cursor
[platforms/virtual] Add virtual output class Summary: This matches the DRM backend more closely and allows mid-test removal and addition of virtual outputs with different properties in the future. Test Plan: Before and after 93% tests passed. Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: graesslin, kwin, #kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D11351
2018-03-19 11:05:57 +00:00
QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs",
[autotests/integration] Fix PointerInputTest::testUpdateFocusAfterScreenChange Change the way how a screen is removed. This ensures that Xwayland doesn't die.
2016-07-20 12:42:22 +00:00
Qt::DirectConnection,
[platforms/virtual] Add virtual output class Summary: This matches the DRM backend more closely and allows mid-test removal and addition of virtual outputs with different properties in the future. Test Plan: Before and after 93% tests passed. Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: graesslin, kwin, #kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D11351
2018-03-19 11:05:57 +00:00
Q_ARG(int, 1),
[autotests/integration] Fix PointerInputTest::testUpdateFocusAfterScreenChange Change the way how a screen is removed. This ensures that Xwayland doesn't die.
2016-07-20 12:42:22 +00:00
Q_ARG(QVector<QRect>, QVector<QRect>{QRect(0, 0, 1280, 1024)}));
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
QVERIFY(screensChangedSpy.wait());
QCOMPARE(screens()->count(), 1);
// this should have warped the cursor
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(639, 511));
QVERIFY(window->frameGeometry().contains(Cursors::self()->mouse()->pos()));
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
// and we should get an enter event
wayland: Adjust kwin to PointerInterface changes
2021-02-22 10:51:26 +00:00
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 2);
[autotest] Add test case for update pointer focus after screen change The test removes the second screen while the cursor is on it. This should warp the pointer to the center of first screen and trigger a focus enter event. As can be seen by the expect failures currently it's bound to libinput and also doesn't process the event as if it were a pointer event.
2016-02-11 13:20:06 +00:00
}
unit test for focusing loss problem on maximize BUG: 411884
2021-07-16 13:25:39 +00:00
void PointerInputTest::testUpdateFocusOnDecorationDestroy()
{
// This test verifies that a maximized client gets it's pointer focus
// if decoration was focused and then destroyed on maximize with BorderlessMaximizedWindows option.
// create pointer for focus tracking
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy buttonStateChangedSpy(pointer, &KWayland::Client::Pointer::buttonStateChanged);
QVERIFY(buttonStateChangedSpy.isValid());
// Enable the borderless maximized windows option.
auto group = kwinApp()->config()->group("Windows");
group.writeEntry("BorderlessMaximizedWindows", true);
group.sync();
Workspace::self()->slotReconfigure();
QCOMPARE(options->borderlessMaximizedWindows(), true);
// Create the test client.
QScopedPointer<KWayland::Client::Surface> surface(Test::createSurface());
autotests: Pass parent object as last argument to createXdgToplevelSurface() and createXdgPopupSurface() It's more common to see the parent object being the last argument in Qt and this way you won't need to specify nullptr parent explicitly if the xdg-popup or the xdg-toplevel surface doesn't need to be configured implicitly, which makes tests slightly easier to read.
2021-12-09 07:47:55 +00:00
QScopedPointer<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.data(), Test::CreationSetup::CreateOnly));
unit test for focusing loss problem on maximize BUG: 411884
2021-07-16 13:25:39 +00:00
QScopedPointer<Test::XdgToplevelDecorationV1> decoration(Test::createXdgToplevelDecorationV1(shellSurface.data()));
QSignalSpy toplevelConfigureRequestedSpy(shellSurface.data(), &Test::XdgToplevel::configureRequested);
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
QSignalSpy decorationConfigureRequestedSpy(decoration.data(), &Test::XdgToplevelDecorationV1::configureRequested);
decoration->set_mode(Test::XdgToplevelDecorationV1::mode_server_side);
surface->commit(KWayland::Client::Surface::CommitFlag::None);
// Wait for the initial configure event.
Test::XdgToplevel::States states;
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(surfaceConfigureRequestedSpy.count(), 1);
QCOMPARE(toplevelConfigureRequestedSpy.last().at(0).toSize(), QSize(0, 0));
states = toplevelConfigureRequestedSpy.last().at(1).value<Test::XdgToplevel::States>();
QVERIFY(!states.testFlag(Test::XdgToplevel::State::Activated));
QVERIFY(!states.testFlag(Test::XdgToplevel::State::Maximized));
// Map the client.
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
unit test for focusing loss problem on maximize BUG: 411884
2021-07-16 13:25:39 +00:00
QVERIFY(client);
QVERIFY(client->isActive());
QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeRestore);
QCOMPARE(client->isDecorated(), true);
// We should receive a configure event when the client becomes active.
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(surfaceConfigureRequestedSpy.count(), 2);
states = toplevelConfigureRequestedSpy.last().at(1).value<Test::XdgToplevel::States>();
QVERIFY(states.testFlag(Test::XdgToplevel::State::Activated));
QVERIFY(!states.testFlag(Test::XdgToplevel::State::Maximized));
// Simulate decoration hover
quint32 timestamp = 0;
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerMotion(client->frameGeometry().topLeft(), timestamp++);
unit test for focusing loss problem on maximize BUG: 411884
2021-07-16 13:25:39 +00:00
QVERIFY(input()->pointer()->decoration());
// Maximize when on decoration
workspace()->slotWindowMaximize();
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(surfaceConfigureRequestedSpy.count(), 3);
QCOMPARE(toplevelConfigureRequestedSpy.last().at(0).toSize(), QSize(1280, 1024));
states = toplevelConfigureRequestedSpy.last().at(1).value<Test::XdgToplevel::States>();
QVERIFY(states.testFlag(Test::XdgToplevel::State::Activated));
QVERIFY(states.testFlag(Test::XdgToplevel::State::Maximized));
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
QSignalSpy frameGeometryChangedSpy(client, &Window::frameGeometryChanged);
unit test for focusing loss problem on maximize BUG: 411884
2021-07-16 13:25:39 +00:00
QVERIFY(frameGeometryChangedSpy.isValid());
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Test::render(surface.data(), QSize(1280, 1024), Qt::blue);
QVERIFY(frameGeometryChangedSpy.wait());
QCOMPARE(client->frameGeometry(), QRect(0, 0, 1280, 1024));
QCOMPARE(client->maximizeMode(), MaximizeFull);
QCOMPARE(client->requestedMaximizeMode(), MaximizeFull);
QCOMPARE(client->isDecorated(), false);
// Window should have focus, BUG 411884
QVERIFY(!input()->pointer()->decoration());
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonPressed(BTN_LEFT, timestamp++);
Test::pointerButtonReleased(BTN_LEFT, timestamp++);
unit test for focusing loss problem on maximize BUG: 411884
2021-07-16 13:25:39 +00:00
QVERIFY(buttonStateChangedSpy.wait());
QCOMPARE(pointer->enteredSurface(), surface.data());
// Destroy the client.
shellSurface.reset();
QVERIFY(Test::waitForWindowDestroyed(client));
}
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
void PointerInputTest::testModifierClickUnrestrictedMove_data()
{
QTest::addColumn<int>("modifierKey");
QTest::addColumn<int>("mouseButton");
QTest::addColumn<QString>("modKey");
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
QTest::addColumn<bool>("capsLock");
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
const QString alt = QStringLiteral("Alt");
const QString meta = QStringLiteral("Meta");
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QTest::newRow("Left Alt + Left Click") << KEY_LEFTALT << BTN_LEFT << alt << false;
QTest::newRow("Left Alt + Right Click") << KEY_LEFTALT << BTN_RIGHT << alt << false;
QTest::newRow("Left Alt + Middle Click") << KEY_LEFTALT << BTN_MIDDLE << alt << false;
QTest::newRow("Right Alt + Left Click") << KEY_RIGHTALT << BTN_LEFT << alt << false;
QTest::newRow("Right Alt + Right Click") << KEY_RIGHTALT << BTN_RIGHT << alt << false;
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
QTest::newRow("Right Alt + Middle Click") << KEY_RIGHTALT << BTN_MIDDLE << alt << false;
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
// now everything with meta
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QTest::newRow("Left Meta + Left Click") << KEY_LEFTMETA << BTN_LEFT << meta << false;
QTest::newRow("Left Meta + Right Click") << KEY_LEFTMETA << BTN_RIGHT << meta << false;
QTest::newRow("Left Meta + Middle Click") << KEY_LEFTMETA << BTN_MIDDLE << meta << false;
QTest::newRow("Right Meta + Left Click") << KEY_RIGHTMETA << BTN_LEFT << meta << false;
QTest::newRow("Right Meta + Right Click") << KEY_RIGHTMETA << BTN_RIGHT << meta << false;
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
QTest::newRow("Right Meta + Middle Click") << KEY_RIGHTMETA << BTN_MIDDLE << meta << false;
// and with capslock
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QTest::newRow("Left Alt + Left Click/CapsLock") << KEY_LEFTALT << BTN_LEFT << alt << true;
QTest::newRow("Left Alt + Right Click/CapsLock") << KEY_LEFTALT << BTN_RIGHT << alt << true;
QTest::newRow("Left Alt + Middle Click/CapsLock") << KEY_LEFTALT << BTN_MIDDLE << alt << true;
QTest::newRow("Right Alt + Left Click/CapsLock") << KEY_RIGHTALT << BTN_LEFT << alt << true;
QTest::newRow("Right Alt + Right Click/CapsLock") << KEY_RIGHTALT << BTN_RIGHT << alt << true;
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
QTest::newRow("Right Alt + Middle Click/CapsLock") << KEY_RIGHTALT << BTN_MIDDLE << alt << true;
// now everything with meta
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QTest::newRow("Left Meta + Left Click/CapsLock") << KEY_LEFTMETA << BTN_LEFT << meta << true;
QTest::newRow("Left Meta + Right Click/CapsLock") << KEY_LEFTMETA << BTN_RIGHT << meta << true;
QTest::newRow("Left Meta + Middle Click/CapsLock") << KEY_LEFTMETA << BTN_MIDDLE << meta << true;
QTest::newRow("Right Meta + Left Click/CapsLock") << KEY_RIGHTMETA << BTN_LEFT << meta << true;
QTest::newRow("Right Meta + Right Click/CapsLock") << KEY_RIGHTMETA << BTN_RIGHT << meta << true;
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
QTest::newRow("Right Meta + Middle Click/CapsLock") << KEY_RIGHTMETA << BTN_MIDDLE << meta << true;
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
}
void PointerInputTest::testModifierClickUnrestrictedMove()
{
// this test ensures that Alt+mouse button press triggers unrestricted move
using namespace KWayland::Client;
// create pointer and signal spy for button events
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy buttonSpy(pointer, &Pointer::buttonStateChanged);
QVERIFY(buttonSpy.isValid());
// first modify the config for this run
QFETCH(QString, modKey);
KConfigGroup group = kwinApp()->config()->group("MouseBindings");
group.writeEntry("CommandAllKey", modKey);
group.writeEntry("CommandAll1", "Move");
group.writeEntry("CommandAll2", "Move");
group.writeEntry("CommandAll3", "Move");
group.sync();
workspace()->slotReconfigure();
[autotest] Validate set options in PointerInputTest::testModifierClickUnrestrictedMove Just to be sure, the code did what we wanted it to do.
2016-04-06 15:25:24 +00:00
QCOMPARE(options->commandAllModifier(), modKey == QStringLiteral("Alt") ? Qt::AltModifier : Qt::MetaModifier);
QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
QCOMPARE(options->commandAll2(), Options::MouseUnrestrictedMove);
QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedMove);
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
// create a window
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface = Test::createSurface(m_compositor);
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
QVERIFY(surface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface, surface);
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window = workspace()->activeClient();
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
QVERIFY(window);
// move cursor on window
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(window->frameGeometry().center());
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
// simulate modifier+click
quint32 timestamp = 1;
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
QFETCH(bool, capsLock);
if (capsLock) {
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyPressed(KEY_CAPSLOCK, timestamp++);
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
}
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
QFETCH(int, modifierKey);
QFETCH(int, mouseButton);
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyPressed(modifierKey, timestamp++);
Prepend "Interactive" to interactive move resize methods This is to improve code readability and make it easier to differentiate between methods that are used during interactive move-resize and normal move-resize methods in the future.
2021-04-30 18:06:58 +00:00
QVERIFY(!window->isInteractiveMove());
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonPressed(mouseButton, timestamp++);
Prepend "Interactive" to interactive move resize methods This is to improve code readability and make it easier to differentiate between methods that are used during interactive move-resize and normal move-resize methods in the future.
2021-04-30 18:06:58 +00:00
QVERIFY(window->isInteractiveMove());
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
// release modifier should not change it
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyReleased(modifierKey, timestamp++);
Prepend "Interactive" to interactive move resize methods This is to improve code readability and make it easier to differentiate between methods that are used during interactive move-resize and normal move-resize methods in the future.
2021-04-30 18:06:58 +00:00
QVERIFY(window->isInteractiveMove());
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
// but releasing the key should end move/resize
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonReleased(mouseButton, timestamp++);
Prepend "Interactive" to interactive move resize methods This is to improve code readability and make it easier to differentiate between methods that are used during interactive move-resize and normal move-resize methods in the future.
2021-04-30 18:06:58 +00:00
QVERIFY(!window->isInteractiveMove());
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
if (capsLock) {
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyReleased(KEY_CAPSLOCK, timestamp++);
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
}
Implement modifier+click in InputRedirection for Wayland This change implements the mouse command for modifier (alt/meta) plus click in InputRedirection so that it also works on Wayland. Modifier plus mouse wheel is not implemented yet. For easier code in Options a new method is added which provides the configured modifier as a Qt::KeyboardModifier instead of a Qt::Key code. Test case is added which simulates all variants of modifiers plus supported mouse buttons to trigger move.
2016-02-17 16:04:11 +00:00
// all of that should not have triggered button events on the surface
QCOMPARE(buttonSpy.count(), 0);
// also waiting shouldn't give us the event
QVERIFY(!buttonSpy.wait(100));
}
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
void PointerInputTest::testModifierClickUnrestrictedMoveGlobalShortcutsDisabled()
{
// this test ensures that Alt+mouse button press triggers unrestricted move
using namespace KWayland::Client;
// create pointer and signal spy for button events
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy buttonSpy(pointer, &Pointer::buttonStateChanged);
QVERIFY(buttonSpy.isValid());
// first modify the config for this run
KConfigGroup group = kwinApp()->config()->group("MouseBindings");
Change CommandAllKey to Meta Summary: Alt + Left Click to move windows has a tendency to conflict with creative workflow apps. While Alt can be changed to Meta in KWin's settings, Alt + Left Click shortcuts often cannot be customized in apps. Rather than making every user who runs into this problem change their settings, we should change our default settings to improve KWin's default usability. The fact that Alt + Left Click to move windows is older does not matter. We are trying to use Meta for global/shell shortcuts anyway. BUG: 399375 Test Plan: The relevant parts of the relevant tests pass. kwin-testInternalWindow fails, but for unrelated reasons that have something to do with XWayland.
2020-05-06 09:17:44 +00:00
group.writeEntry("CommandAllKey", "Meta");
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
group.writeEntry("CommandAll1", "Move");
group.writeEntry("CommandAll2", "Move");
group.writeEntry("CommandAll3", "Move");
group.sync();
workspace()->slotReconfigure();
Change CommandAllKey to Meta Summary: Alt + Left Click to move windows has a tendency to conflict with creative workflow apps. While Alt can be changed to Meta in KWin's settings, Alt + Left Click shortcuts often cannot be customized in apps. Rather than making every user who runs into this problem change their settings, we should change our default settings to improve KWin's default usability. The fact that Alt + Left Click to move windows is older does not matter. We are trying to use Meta for global/shell shortcuts anyway. BUG: 399375 Test Plan: The relevant parts of the relevant tests pass. kwin-testInternalWindow fails, but for unrelated reasons that have something to do with XWayland.
2020-05-06 09:17:44 +00:00
QCOMPARE(options->commandAllModifier(), Qt::MetaModifier);
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
QCOMPARE(options->commandAll2(), Options::MouseUnrestrictedMove);
QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedMove);
// create a window
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface = Test::createSurface(m_compositor);
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
QVERIFY(surface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface, surface);
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window = workspace()->activeClient();
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
QVERIFY(window);
// disable global shortcuts
QVERIFY(!workspace()->globalShortcutsDisabled());
workspace()->disableGlobalShortcutsForClient(true);
QVERIFY(workspace()->globalShortcutsDisabled());
// move cursor on window
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(window->frameGeometry().center());
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
// simulate modifier+click
quint32 timestamp = 1;
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
Prepend "Interactive" to interactive move resize methods This is to improve code readability and make it easier to differentiate between methods that are used during interactive move-resize and normal move-resize methods in the future.
2021-04-30 18:06:58 +00:00
QVERIFY(!window->isInteractiveMove());
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonPressed(BTN_LEFT, timestamp++);
Prepend "Interactive" to interactive move resize methods This is to improve code readability and make it easier to differentiate between methods that are used during interactive move-resize and normal move-resize methods in the future.
2021-04-30 18:06:58 +00:00
QVERIFY(!window->isInteractiveMove());
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
// release modifier should not change it
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
Prepend "Interactive" to interactive move resize methods This is to improve code readability and make it easier to differentiate between methods that are used during interactive move-resize and normal move-resize methods in the future.
2021-04-30 18:06:58 +00:00
QVERIFY(!window->isInteractiveMove());
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonReleased(BTN_LEFT, timestamp++);
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
workspace()->disableGlobalShortcutsForClient(false);
}
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
void PointerInputTest::testModifierScrollOpacity_data()
{
QTest::addColumn<int>("modifierKey");
QTest::addColumn<QString>("modKey");
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
QTest::addColumn<bool>("capsLock");
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
const QString alt = QStringLiteral("Alt");
const QString meta = QStringLiteral("Meta");
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QTest::newRow("Left Alt") << KEY_LEFTALT << alt << false;
QTest::newRow("Right Alt") << KEY_RIGHTALT << alt << false;
QTest::newRow("Left Meta") << KEY_LEFTMETA << meta << false;
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
QTest::newRow("Right Meta") << KEY_RIGHTMETA << meta << false;
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QTest::newRow("Left Alt/CapsLock") << KEY_LEFTALT << alt << true;
QTest::newRow("Right Alt/CapsLock") << KEY_RIGHTALT << alt << true;
QTest::newRow("Left Meta/CapsLock") << KEY_LEFTMETA << meta << true;
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
QTest::newRow("Right Meta/CapsLock") << KEY_RIGHTMETA << meta << true;
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
}
void PointerInputTest::testModifierScrollOpacity()
{
// this test verifies that mod+wheel performs a window operation and does not
// pass the wheel to the window
using namespace KWayland::Client;
// create pointer and signal spy for button events
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy axisSpy(pointer, &Pointer::axisChanged);
QVERIFY(axisSpy.isValid());
// first modify the config for this run
QFETCH(QString, modKey);
KConfigGroup group = kwinApp()->config()->group("MouseBindings");
group.writeEntry("CommandAllKey", modKey);
group.writeEntry("CommandAllWheel", "change opacity");
group.sync();
workspace()->slotReconfigure();
// create a window
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface = Test::createSurface(m_compositor);
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
QVERIFY(surface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface, surface);
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window = workspace()->activeClient();
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
QVERIFY(window);
// set the opacity to 0.5
window->setOpacity(0.5);
QCOMPARE(window->opacity(), 0.5);
// move cursor on window
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(window->frameGeometry().center());
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
// simulate modifier+wheel
quint32 timestamp = 1;
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
QFETCH(bool, capsLock);
if (capsLock) {
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyPressed(KEY_CAPSLOCK, timestamp++);
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
}
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
QFETCH(int, modifierKey);
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyPressed(modifierKey, timestamp++);
Test::pointerAxisVertical(-5, timestamp++);
Fix scroll direction on window wheel command Experimental testing in real world showed it's just a signing issue in this specific case. The events passed to wayland clients scroll in correct direction.
2016-02-18 09:11:20 +00:00
QCOMPARE(window->opacity(), 0.6);
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerAxisVertical(5, timestamp++);
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
QCOMPARE(window->opacity(), 0.5);
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyReleased(modifierKey, timestamp++);
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
if (capsLock) {
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyReleased(KEY_CAPSLOCK, timestamp++);
Ignore non-relevant modifiers when evaluating mouse actions Summary: E.g. CapsLock should not prevent Alt+left click move. BUG: 372809 Reviewers: #kwin, #plasma_on_wayland, broulik Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3467
2016-11-23 08:06:08 +00:00
}
Add support for modifier+wheel action Implemented in the ForwardEventFilter: before forwarding the event to the window we check whether a modifier is pressed and perform the wheel command. Possible improvements: each axis event triggers the same change, there is no adjusted scaling.
2016-02-18 07:27:28 +00:00
// axis should have been filtered out
QCOMPARE(axisSpy.count(), 0);
QVERIFY(!axisSpy.wait(100));
}
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
void PointerInputTest::testModifierScrollOpacityGlobalShortcutsDisabled()
{
// this test verifies that mod+wheel performs a window operation and does not
// pass the wheel to the window
using namespace KWayland::Client;
// create pointer and signal spy for button events
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy axisSpy(pointer, &Pointer::axisChanged);
QVERIFY(axisSpy.isValid());
// first modify the config for this run
KConfigGroup group = kwinApp()->config()->group("MouseBindings");
Change CommandAllKey to Meta Summary: Alt + Left Click to move windows has a tendency to conflict with creative workflow apps. While Alt can be changed to Meta in KWin's settings, Alt + Left Click shortcuts often cannot be customized in apps. Rather than making every user who runs into this problem change their settings, we should change our default settings to improve KWin's default usability. The fact that Alt + Left Click to move windows is older does not matter. We are trying to use Meta for global/shell shortcuts anyway. BUG: 399375 Test Plan: The relevant parts of the relevant tests pass. kwin-testInternalWindow fails, but for unrelated reasons that have something to do with XWayland.
2020-05-06 09:17:44 +00:00
group.writeEntry("CommandAllKey", "Meta");
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
group.writeEntry("CommandAllWheel", "change opacity");
group.sync();
workspace()->slotReconfigure();
// create a window
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface = Test::createSurface(m_compositor);
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
QVERIFY(surface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface, surface);
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window = workspace()->activeClient();
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
QVERIFY(window);
// set the opacity to 0.5
window->setOpacity(0.5);
QCOMPARE(window->opacity(), 0.5);
// move cursor on window
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(window->frameGeometry().center());
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
// disable global shortcuts
QVERIFY(!workspace()->globalShortcutsDisabled());
workspace()->disableGlobalShortcutsForClient(true);
QVERIFY(workspace()->globalShortcutsDisabled());
// simulate modifier+wheel
quint32 timestamp = 1;
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
Test::pointerAxisVertical(-5, timestamp++);
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
QCOMPARE(window->opacity(), 0.5);
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerAxisVertical(5, timestamp++);
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
QCOMPARE(window->opacity(), 0.5);
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
Disable modifier window actions if global shortcuts are disabled Summary: Same is done on X11 (see Client::updateMouseGrab), so we should have this on Wayland as well. Also adding the pointer confinement restriction for modifier + wheel. Test Plan: Run new and adjusted testcases with and without the change Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16025
2018-10-07 19:02:09 +00:00
workspace()->disableGlobalShortcutsForClient(false);
}
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
void PointerInputTest::testScrollAction()
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
{
// this test verifies that scroll on inactive window performs a mouse action
using namespace KWayland::Client;
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy axisSpy(pointer, &Pointer::axisChanged);
QVERIFY(axisSpy.isValid());
// first modify the config for this run
KConfigGroup group = kwinApp()->config()->group("MouseBindings");
group.writeEntry("CommandWindowWheel", "activate and scroll");
group.sync();
workspace()->slotReconfigure();
// create two windows
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface1 = Test::createSurface(m_compositor);
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
QVERIFY(surface1);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface1 = Test::createXdgToplevelSurface(surface1, surface1);
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
QVERIFY(shellSurface1);
render(surface1);
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window1 = workspace()->activeClient();
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
QVERIFY(window1);
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface2 = Test::createSurface(m_compositor);
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
QVERIFY(surface2);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface2 = Test::createXdgToplevelSurface(surface2, surface2);
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
QVERIFY(shellSurface2);
render(surface2);
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window2 = workspace()->activeClient();
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
QVERIFY(window2);
QVERIFY(window1 != window2);
// move cursor to the inactive window
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(window1->frameGeometry().center());
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
quint32 timestamp = 1;
QVERIFY(!window1->isActive());
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerAxisVertical(5, timestamp++);
Implement whell command in input handling With that all the actions are implemented just like on X11. There are two not yet implemented differences: * hide splash window when clicking it * replay event on special window
2016-02-18 08:18:39 +00:00
QVERIFY(window1->isActive());
// but also the wheel event should be passed to the window
QVERIFY(axisSpy.wait());
// we need to wait a little bit, otherwise the test crashes in effectshandler, needs fixing
QTest::qWait(100);
}
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
void PointerInputTest::testFocusFollowsMouse()
{
using namespace KWayland::Client;
// need to create a pointer, otherwise it doesn't accept focus
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
// move cursor out of the way of first window to be created
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(900, 900);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
// first modify the config for this run
KConfigGroup group = kwinApp()->config()->group("Windows");
group.writeEntry("AutoRaise", true);
group.writeEntry("AutoRaiseInterval", 20);
group.writeEntry("DelayFocusInterval", 200);
group.writeEntry("FocusPolicy", "FocusFollowsMouse");
group.sync();
workspace()->slotReconfigure();
// verify the settings
QCOMPARE(options->focusPolicy(), Options::FocusFollowsMouse);
QVERIFY(options->isAutoRaise());
QCOMPARE(options->autoRaiseInterval(), 20);
QCOMPARE(options->delayFocusInterval(), 200);
// create two windows
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface1 = Test::createSurface(m_compositor);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QVERIFY(surface1);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface1 = Test::createXdgToplevelSurface(surface1, surface1);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QVERIFY(shellSurface1);
render(surface1, QSize(800, 800));
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window1 = workspace()->activeClient();
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QVERIFY(window1);
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface2 = Test::createSurface(m_compositor);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QVERIFY(surface2);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface2 = Test::createXdgToplevelSurface(surface2, surface2);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QVERIFY(shellSurface2);
render(surface2, QSize(800, 800));
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window2 = workspace()->activeClient();
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QVERIFY(window2);
QVERIFY(window1 != window2);
Port Workspace::topClientOnDesktop() to AbstractOutput
2021-08-28 14:28:54 +00:00
QCOMPARE(workspace()->topClientOnDesktop(VirtualDesktopManager::self()->currentDesktop()), window2);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
// geometry of the two windows should be overlapping
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
QVERIFY(window1->frameGeometry().intersects(window2->frameGeometry()));
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
// signal spies for active window changed and stacking order changed
QSignalSpy activeWindowChangedSpy(workspace(), &Workspace::clientActivated);
QVERIFY(activeWindowChangedSpy.isValid());
QSignalSpy stackingOrderChangedSpy(workspace(), &Workspace::stackingOrderChanged);
QVERIFY(stackingOrderChangedSpy.isValid());
QVERIFY(!window1->isActive());
QVERIFY(window2->isActive());
// move on top of first window
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
QVERIFY(window1->frameGeometry().contains(10, 10));
QVERIFY(!window2->frameGeometry().contains(10, 10));
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(10, 10);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QVERIFY(stackingOrderChangedSpy.wait());
QCOMPARE(stackingOrderChangedSpy.count(), 1);
Port Workspace::topClientOnDesktop() to AbstractOutput
2021-08-28 14:28:54 +00:00
QCOMPARE(workspace()->topClientOnDesktop(VirtualDesktopManager::self()->currentDesktop()), window1);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QTRY_VERIFY(window1->isActive());
// move on second window, but move away before active window change delay hits
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(810, 810);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QVERIFY(stackingOrderChangedSpy.wait());
QCOMPARE(stackingOrderChangedSpy.count(), 2);
Port Workspace::topClientOnDesktop() to AbstractOutput
2021-08-28 14:28:54 +00:00
QCOMPARE(workspace()->topClientOnDesktop(VirtualDesktopManager::self()->currentDesktop()), window2);
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(10, 10);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QVERIFY(!activeWindowChangedSpy.wait(250));
QVERIFY(window1->isActive());
Port Workspace::topClientOnDesktop() to AbstractOutput
2021-08-28 14:28:54 +00:00
QCOMPARE(workspace()->topClientOnDesktop(VirtualDesktopManager::self()->currentDesktop()), window1);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
// as we moved back on window 1 that should been raised in the mean time
QCOMPARE(stackingOrderChangedSpy.count(), 3);
// quickly move on window 2 and back on window 1 should not raise window 2
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(810, 810);
Cursors::self()->mouse()->setPos(10, 10);
Invoke AbstractClient::enterEvent and ::leaveEvent on updating pointer window This implements auto raise and focus follows mouse for Wayland. The decoration interaction needs to be autotested.
2016-02-18 12:02:07 +00:00
QVERIFY(!stackingOrderChangedSpy.wait(250));
}
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
void PointerInputTest::testMouseActionInactiveWindow_data()
{
QTest::addColumn<quint32>("button");
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QTest::newRow("Left") << quint32(BTN_LEFT);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QTest::newRow("Middle") << quint32(BTN_MIDDLE);
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QTest::newRow("Right") << quint32(BTN_RIGHT);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
}
void PointerInputTest::testMouseActionInactiveWindow()
{
// this test performs the mouse button window action on an inactive window
// it should activate the window and raise it
using namespace KWayland::Client;
// first modify the config for this run - disable FocusFollowsMouse
KConfigGroup group = kwinApp()->config()->group("Windows");
group.writeEntry("FocusPolicy", "ClickToFocus");
group.sync();
group = kwinApp()->config()->group("MouseBindings");
group.writeEntry("CommandWindow1", "Activate, raise and pass click");
group.writeEntry("CommandWindow2", "Activate, raise and pass click");
group.writeEntry("CommandWindow3", "Activate, raise and pass click");
group.sync();
workspace()->slotReconfigure();
// create two windows
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface1 = Test::createSurface(m_compositor);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(surface1);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface1 = Test::createXdgToplevelSurface(surface1, surface1);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(shellSurface1);
render(surface1, QSize(800, 800));
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window1 = workspace()->activeClient();
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(window1);
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface2 = Test::createSurface(m_compositor);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(surface2);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface2 = Test::createXdgToplevelSurface(surface2, surface2);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(shellSurface2);
render(surface2, QSize(800, 800));
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window2 = workspace()->activeClient();
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(window2);
QVERIFY(window1 != window2);
Port Workspace::topClientOnDesktop() to AbstractOutput
2021-08-28 14:28:54 +00:00
QCOMPARE(workspace()->topClientOnDesktop(VirtualDesktopManager::self()->currentDesktop()), window2);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
// geometry of the two windows should be overlapping
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
QVERIFY(window1->frameGeometry().intersects(window2->frameGeometry()));
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
// signal spies for active window changed and stacking order changed
QSignalSpy activeWindowChangedSpy(workspace(), &Workspace::clientActivated);
QVERIFY(activeWindowChangedSpy.isValid());
QSignalSpy stackingOrderChangedSpy(workspace(), &Workspace::stackingOrderChanged);
QVERIFY(stackingOrderChangedSpy.isValid());
QVERIFY(!window1->isActive());
QVERIFY(window2->isActive());
// move on top of first window
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
QVERIFY(window1->frameGeometry().contains(10, 10));
QVERIFY(!window2->frameGeometry().contains(10, 10));
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(10, 10);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
// no focus follows mouse
QVERIFY(!stackingOrderChangedSpy.wait(200));
QVERIFY(stackingOrderChangedSpy.isEmpty());
QVERIFY(activeWindowChangedSpy.isEmpty());
QVERIFY(window2->isActive());
// and click
quint32 timestamp = 1;
QFETCH(quint32, button);
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonPressed(button, timestamp++);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
// should raise window1 and activate it
QCOMPARE(stackingOrderChangedSpy.count(), 1);
QVERIFY(!activeWindowChangedSpy.isEmpty());
Port Workspace::topClientOnDesktop() to AbstractOutput
2021-08-28 14:28:54 +00:00
QCOMPARE(workspace()->topClientOnDesktop(VirtualDesktopManager::self()->currentDesktop()), window1);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(window1->isActive());
QVERIFY(!window2->isActive());
// release again
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonReleased(button, timestamp++);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
}
void PointerInputTest::testMouseActionActiveWindow_data()
{
QTest::addColumn<bool>("clickRaise");
QTest::addColumn<quint32>("button");
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
for (quint32 i = BTN_LEFT; i < BTN_JOYSTICK; i++) {
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QByteArray number = QByteArray::number(i, 16);
QTest::newRow(QByteArrayLiteral("click raise/").append(number).constData()) << true << i;
QTest::newRow(QByteArrayLiteral("no click raise/").append(number).constData()) << false << i;
}
}
void PointerInputTest::testMouseActionActiveWindow()
{
// this test verifies the mouse action performed on an active window
// for all buttons it should trigger a window raise depending on the
// click raise option
using namespace KWayland::Client;
// create a button spy - all clicks should be passed through
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy buttonSpy(pointer, &Pointer::buttonStateChanged);
QVERIFY(buttonSpy.isValid());
// adjust config for this run
QFETCH(bool, clickRaise);
KConfigGroup group = kwinApp()->config()->group("Windows");
group.writeEntry("ClickRaise", clickRaise);
group.sync();
workspace()->slotReconfigure();
QCOMPARE(options->isClickRaise(), clickRaise);
// create two windows
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface1 = Test::createSurface(m_compositor);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(surface1);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface1 = Test::createXdgToplevelSurface(surface1, surface1);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(shellSurface1);
render(surface1, QSize(800, 800));
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window1 = workspace()->activeClient();
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(window1);
[autotests/wayland] Try to make PointerInputTest::testMouseActionActiveWindow more robust It's currently failing on build.kde.org. I'm not able to reproduce the failure localy so I can only interpret the failure. The failure looks like a window is still present in the next executed test case thus breaking the positioning. This change ensures that the window is properly gone before going into the next test case.
2016-05-23 09:19:29 +00:00
QSignalSpy window1DestroyedSpy(window1, &QObject::destroyed);
QVERIFY(window1DestroyedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface2 = Test::createSurface(m_compositor);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(surface2);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface2 = Test::createXdgToplevelSurface(surface2, surface2);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(shellSurface2);
render(surface2, QSize(800, 800));
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window2 = workspace()->activeClient();
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(window2);
QVERIFY(window1 != window2);
[autotests/wayland] Try to make PointerInputTest::testMouseActionActiveWindow more robust It's currently failing on build.kde.org. I'm not able to reproduce the failure localy so I can only interpret the failure. The failure looks like a window is still present in the next executed test case thus breaking the positioning. This change ensures that the window is properly gone before going into the next test case.
2016-05-23 09:19:29 +00:00
QSignalSpy window2DestroyedSpy(window2, &QObject::destroyed);
QVERIFY(window2DestroyedSpy.isValid());
Port Workspace::topClientOnDesktop() to AbstractOutput
2021-08-28 14:28:54 +00:00
QCOMPARE(workspace()->topClientOnDesktop(VirtualDesktopManager::self()->currentDesktop()), window2);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
// geometry of the two windows should be overlapping
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
QVERIFY(window1->frameGeometry().intersects(window2->frameGeometry()));
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
// lower the currently active window
workspace()->lowerClient(window2);
Port Workspace::topClientOnDesktop() to AbstractOutput
2021-08-28 14:28:54 +00:00
QCOMPARE(workspace()->topClientOnDesktop(VirtualDesktopManager::self()->currentDesktop()), window1);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
// signal spy for stacking order spy
QSignalSpy stackingOrderChangedSpy(workspace(), &Workspace::stackingOrderChanged);
QVERIFY(stackingOrderChangedSpy.isValid());
// move on top of second window
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
QVERIFY(!window1->frameGeometry().contains(900, 900));
QVERIFY(window2->frameGeometry().contains(900, 900));
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(900, 900);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
// and click
quint32 timestamp = 1;
QFETCH(quint32, button);
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonPressed(button, timestamp++);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
QVERIFY(buttonSpy.wait());
if (clickRaise) {
QCOMPARE(stackingOrderChangedSpy.count(), 1);
Port Workspace::topClientOnDesktop() to AbstractOutput
2021-08-28 14:28:54 +00:00
QTRY_COMPARE_WITH_TIMEOUT(workspace()->topClientOnDesktop(VirtualDesktopManager::self()->currentDesktop()), window2, 200);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
} else {
QCOMPARE(stackingOrderChangedSpy.count(), 0);
QVERIFY(!stackingOrderChangedSpy.wait(100));
Port Workspace::topClientOnDesktop() to AbstractOutput
2021-08-28 14:28:54 +00:00
QCOMPARE(workspace()->topClientOnDesktop(VirtualDesktopManager::self()->currentDesktop()), window1);
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
}
// release again
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonReleased(button, timestamp++);
[autotests/wayland] Try to make PointerInputTest::testMouseActionActiveWindow more robust It's currently failing on build.kde.org. I'm not able to reproduce the failure localy so I can only interpret the failure. The failure looks like a window is still present in the next executed test case thus breaking the positioning. This change ensures that the window is properly gone before going into the next test case.
2016-05-23 09:19:29 +00:00
delete surface1;
QVERIFY(window1DestroyedSpy.wait());
delete surface2;
QVERIFY(window2DestroyedSpy.wait());
Fix mouse action on (in)active window Small regression: the command didn't get updated at all, so it was always MouseNothing. To prevent such a regression to sneak in again the change comes with autotest for the action on inactive and active window.
2016-02-22 09:07:02 +00:00
}
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
void PointerInputTest::testCursorImage()
{
// this test verifies that the pointer image gets updated correctly from the client provided data
using namespace KWayland::Client;
// we need a pointer to get the enter event
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy enteredSpy(pointer, &Pointer::entered);
QVERIFY(enteredSpy.isValid());
// move cursor somewhere the new window won't open
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
auto cursor = Cursors::self()->mouse();
cursor->setPos(800, 800);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
auto p = input()->pointer();
// at the moment it should be the fallback cursor
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
const QImage fallbackCursor = cursor->image();
Do not unset cursor image when cursor enters a surface Summary: From Wayland documentation: "When a seat's focus enters a surface, the pointer image is undefined and a client should respond to this event by setting an appropriate pointer image with the set_cursor request." KWin's interpretation so far for the undefined pointer image was to remove the pointer image when entering a surface waiting for the client to set a cursor image. This can result in a short flicker as there might be a frame without a cursor image. This patch changes the behavior by keeping the previous image till the application set a new one. This brings some advantages: * if the application is not responding a cursor is still shown * if the same cursor is used as in the previous window we don't have a flicker CCBUG: 393639 Test Plan: I cannot see the flicker, so only tested with the adjusted tests Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D12631
2018-05-01 13:33:33 +00:00
QVERIFY(!fallbackCursor.isNull());
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
// create a window
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface = Test::createSurface(m_compositor);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
QVERIFY(surface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface, surface);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window = workspace()->activeClient();
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
QVERIFY(window);
Do not unset cursor image when cursor enters a surface Summary: From Wayland documentation: "When a seat's focus enters a surface, the pointer image is undefined and a client should respond to this event by setting an appropriate pointer image with the set_cursor request." KWin's interpretation so far for the undefined pointer image was to remove the pointer image when entering a surface waiting for the client to set a cursor image. This can result in a short flicker as there might be a frame without a cursor image. This patch changes the behavior by keeping the previous image till the application set a new one. This brings some advantages: * if the application is not responding a cursor is still shown * if the same cursor is used as in the previous window we don't have a flicker CCBUG: 393639 Test Plan: I cannot see the flicker, so only tested with the adjusted tests Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D12631
2018-05-01 13:33:33 +00:00
// move cursor to center of window, this should first set a null pointer, so we still show old cursor
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
cursor->setPos(window->frameGeometry().center());
Avoid QPointer in return types of Input methods QPointer is a really useful way to store a pointer over time. It doesn't make have any value as a return value used by a short-lived method. There isn't a good copy constructor, it's effectively the same as creating a new QWeakPointer reference that has to be cleaned up. Testing if something is null is still the same. A new QPointer can be made by the caller if it actually is needed. Input handling is a very hot path called many times a frame, so it's important to keep this light. focus() and at() are called a lot which added up to slightly over 1% of CPU time when moving the mouse about.
2020-09-07 08:11:07 +00:00
QCOMPARE(p->focus(), window);
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QCOMPARE(cursor->image(), fallbackCursor);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
QVERIFY(enteredSpy.wait());
// create a cursor on the pointer
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *cursorSurface = Test::createSurface(m_compositor);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
QVERIFY(cursorSurface);
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
QSignalSpy cursorRenderedSpy(cursorSurface, &KWayland::Client::Surface::frameRendered);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
QVERIFY(cursorRenderedSpy.isValid());
ARGB buffers are premultiplied D7460 in kwayland assumes all WL_SHM_FORMAT_ARGB8888 buffers have opacity premultipied RGB values. Kwin tests need updating to do the same. Rendering code did not need changing. Test Plan: Tests now pass Reviewers: #plasma, graesslin Reviewed By: #plasma, graesslin Subscribers: plasma-devel, kwin, #kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7607
2017-08-30 09:01:55 +00:00
QImage red = QImage(QSize(10, 10), QImage::Format_ARGB32_Premultiplied);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
red.fill(Qt::red);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
cursorSurface->attachBuffer(Test::waylandShmPool()->createBuffer(red));
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
cursorSurface->damage(QRect(0, 0, 10, 10));
cursorSurface->commit();
pointer->setCursor(cursorSurface, QPoint(5, 5));
QVERIFY(cursorRenderedSpy.wait());
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QCOMPARE(cursor->image(), red);
QCOMPARE(cursor->hotspot(), QPoint(5, 5));
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
// change hotspot
pointer->setCursor(cursorSurface, QPoint(6, 6));
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Test::flushWaylandConnection();
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QTRY_COMPARE(cursor->hotspot(), QPoint(6, 6));
QCOMPARE(cursor->image(), red);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
// change the buffer
ARGB buffers are premultiplied D7460 in kwayland assumes all WL_SHM_FORMAT_ARGB8888 buffers have opacity premultipied RGB values. Kwin tests need updating to do the same. Rendering code did not need changing. Test Plan: Tests now pass Reviewers: #plasma, graesslin Reviewed By: #plasma, graesslin Subscribers: plasma-devel, kwin, #kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7607
2017-08-30 09:01:55 +00:00
QImage blue = QImage(QSize(10, 10), QImage::Format_ARGB32_Premultiplied);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
blue.fill(Qt::blue);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
auto b = Test::waylandShmPool()->createBuffer(blue);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
cursorSurface->attachBuffer(b);
cursorSurface->damage(QRect(0, 0, 10, 10));
cursorSurface->commit();
QVERIFY(cursorRenderedSpy.wait());
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QTRY_COMPARE(cursor->image(), blue);
QCOMPARE(cursor->hotspot(), QPoint(6, 6));
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
Set correct DPR on wayland cursors received from remote buffers Summary: It will then be renderered appropriately when painting to the output buffer. Test Plan: Updated unit test, plus used with other relevant patches Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D13606
2018-06-23 17:17:51 +00:00
// scaled cursor
QImage blueScaled = QImage(QSize(20, 20), QImage::Format_ARGB32_Premultiplied);
[autotests] Fix PointerInputTest::testCursorImage() Summary: FAIL! : KWin::PointerInputTest::testCursorImage() Compared QImages differ in device pixel ratio. Actual (((p->cursorImage()))): 2 Expected (blueScaled): 1 Loc: [/home/vlad/Workspace/KDE/src/kde/workspace/kwin/autotests/integration/pointer_input.cpp(1058)] Test Plan: The test passes. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: davidedmundson, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27725
2020-02-28 17:06:19 +00:00
blueScaled.setDevicePixelRatio(2);
Set correct DPR on wayland cursors received from remote buffers Summary: It will then be renderered appropriately when painting to the output buffer. Test Plan: Updated unit test, plus used with other relevant patches Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D13606
2018-06-23 17:17:51 +00:00
blueScaled.fill(Qt::blue);
auto bs = Test::waylandShmPool()->createBuffer(blueScaled);
cursorSurface->attachBuffer(bs);
cursorSurface->setScale(2);
cursorSurface->damage(QRect(0, 0, 20, 20));
cursorSurface->commit();
QVERIFY(cursorRenderedSpy.wait());
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QTRY_COMPARE(cursor->image(), blueScaled);
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QCOMPARE(cursor->hotspot(), QPoint(6, 6)); // surface-local (so not changed)
Set correct DPR on wayland cursors received from remote buffers Summary: It will then be renderered appropriately when painting to the output buffer. Test Plan: Updated unit test, plus used with other relevant patches Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D13606
2018-06-23 17:17:51 +00:00
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
// hide the cursor
pointer->setCursor(nullptr);
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Test::flushWaylandConnection();
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QTRY_VERIFY(cursor->image().isNull());
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
// move cursor somewhere else, should reset to fallback cursor
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(window->frameGeometry().bottomLeft() + QPoint(20, 20));
Avoid QPointer in return types of Input methods QPointer is a really useful way to store a pointer over time. It doesn't make have any value as a return value used by a short-lived method. There isn't a good copy constructor, it's effectively the same as creating a new QWeakPointer reference that has to be cleaned up. Testing if something is null is still the same. A new QPointer can be made by the caller if it actually is needed. Input handling is a very hot path called many times a frame, so it's important to keep this light. focus() and at() are called a lot which added up to slightly over 1% of CPU time when moving the mouse about.
2020-09-07 08:11:07 +00:00
QVERIFY(!p->focus());
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QVERIFY(!cursor->image().isNull());
QCOMPARE(cursor->image(), fallbackCursor);
[autotest] Add test case for cursor image This test case verifies that the cursor image and hot spot changes correctly when focusing a window, changes when damaged and hides. Test shows that when focusing a window the cursor image is not removed, neither that unfocus sets back to fallback cursor properly.
2016-02-24 16:18:08 +00:00
}
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
class HelperEffect : public Effect
{
Q_OBJECT
public:
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
HelperEffect()
{
}
~HelperEffect() override
{
}
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
};
void PointerInputTest::testEffectOverrideCursorImage()
{
// this test verifies the effect cursor override handling
using namespace KWayland::Client;
// we need a pointer to get the enter event and set a cursor
auto pointer = m_seat->createPointer(m_seat);
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
auto cursor = Cursors::self()->mouse();
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy enteredSpy(pointer, &Pointer::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy leftSpy(pointer, &Pointer::left);
QVERIFY(leftSpy.isValid());
// move cursor somewhere the new window won't open
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
cursor->setPos(800, 800);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
// here we should have the fallback cursor
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
const QImage fallback = cursor->image();
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
QVERIFY(!fallback.isNull());
// now let's create a window
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface = Test::createSurface(m_compositor);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
QVERIFY(surface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface, surface);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window = workspace()->activeClient();
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
QVERIFY(window);
// and move cursor to the window
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
QVERIFY(!window->frameGeometry().contains(QPoint(800, 800)));
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
cursor->setPos(window->frameGeometry().center());
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
QVERIFY(enteredSpy.wait());
Do not unset cursor image when cursor enters a surface Summary: From Wayland documentation: "When a seat's focus enters a surface, the pointer image is undefined and a client should respond to this event by setting an appropriate pointer image with the set_cursor request." KWin's interpretation so far for the undefined pointer image was to remove the pointer image when entering a surface waiting for the client to set a cursor image. This can result in a short flicker as there might be a frame without a cursor image. This patch changes the behavior by keeping the previous image till the application set a new one. This brings some advantages: * if the application is not responding a cursor is still shown * if the same cursor is used as in the previous window we don't have a flicker CCBUG: 393639 Test Plan: I cannot see the flicker, so only tested with the adjusted tests Reviewers: #kwin, #plasma Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D12631
2018-05-01 13:33:33 +00:00
// cursor image should still be fallback
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QCOMPARE(cursor->image(), fallback);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
// now create an effect and set an override cursor
QScopedPointer<HelperEffect> effect(new HelperEffect);
[autotests] Use DMZ-White as cursor theme On build.kde.org we cannot use the breeze cursor theme. Instead we have DMZ-White (debian package dmz-cursor-theme). This change adjusts the PointerInput test to enforce DMZ-White and uses SizeAllCursor instead of OpenHandCursor as that one seems to be missing in that theme. Hopefully with these changes the test starts to pass on build.kde.org.
2016-04-05 06:36:53 +00:00
effects->startMouseInterception(effect.data(), Qt::SizeAllCursor);
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
const QImage sizeAll = cursor->image();
[autotests] Use DMZ-White as cursor theme On build.kde.org we cannot use the breeze cursor theme. Instead we have DMZ-White (debian package dmz-cursor-theme). This change adjusts the PointerInput test to enforce DMZ-White and uses SizeAllCursor instead of OpenHandCursor as that one seems to be missing in that theme. Hopefully with these changes the test starts to pass on build.kde.org.
2016-04-05 06:36:53 +00:00
QVERIFY(!sizeAll.isNull());
QVERIFY(sizeAll != fallback);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
QVERIFY(leftSpy.wait());
// let's change to arrow cursor, this should be our fallback
effects->defineCursor(Qt::ArrowCursor);
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QCOMPARE(cursor->image(), fallback);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
[autotests] Use DMZ-White as cursor theme On build.kde.org we cannot use the breeze cursor theme. Instead we have DMZ-White (debian package dmz-cursor-theme). This change adjusts the PointerInput test to enforce DMZ-White and uses SizeAllCursor instead of OpenHandCursor as that one seems to be missing in that theme. Hopefully with these changes the test starts to pass on build.kde.org.
2016-04-05 06:36:53 +00:00
// back to size all
effects->defineCursor(Qt::SizeAllCursor);
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QCOMPARE(cursor->image(), sizeAll);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
// move cursor outside the window area
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(800, 800);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
// and end the override, which should switch to fallback
effects->stopMouseInterception(effect.data());
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QCOMPARE(cursor->image(), fallback);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
// start mouse interception again
[autotests] Use DMZ-White as cursor theme On build.kde.org we cannot use the breeze cursor theme. Instead we have DMZ-White (debian package dmz-cursor-theme). This change adjusts the PointerInput test to enforce DMZ-White and uses SizeAllCursor instead of OpenHandCursor as that one seems to be missing in that theme. Hopefully with these changes the test starts to pass on build.kde.org.
2016-04-05 06:36:53 +00:00
effects->startMouseInterception(effect.data(), Qt::SizeAllCursor);
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QCOMPARE(cursor->image(), sizeAll);
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
// move cursor to area of window
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(window->frameGeometry().center());
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
// this should not result in an enter event
QVERIFY(!enteredSpy.wait(100));
// after ending the interception we should get an enter event
effects->stopMouseInterception(effect.data());
QVERIFY(enteredSpy.wait());
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QVERIFY(cursor->image().isNull());
[autotests] New test case to verify cursor changes correctly in effects The test case verifies that setting an override cursor during mouse interception works and that it's also possible to change it. When ending mouse interception the cursor image should be adjusted again. The test shows that when mouse interception starts KWin should send a pointer leave event to the current focused window and similar needs to handle the stop of mouse interception.
2016-02-25 08:04:29 +00:00
}
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
void PointerInputTest::testPopup()
{
// this test validates the basic popup behavior
// a button press outside the window should dismiss the popup
// first create a parent surface
using namespace KWayland::Client;
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy enteredSpy(pointer, &Pointer::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy leftSpy(pointer, &Pointer::left);
QVERIFY(leftSpy.isValid());
QSignalSpy buttonStateChangedSpy(pointer, &Pointer::buttonStateChanged);
QVERIFY(buttonStateChangedSpy.isValid());
QSignalSpy motionSpy(pointer, &Pointer::motion);
QVERIFY(motionSpy.isValid());
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(800, 800);
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface = Test::createSurface(m_compositor);
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
QVERIFY(surface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface, surface);
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window = workspace()->activeClient();
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
QVERIFY(window);
QCOMPARE(window->hasPopupGrab(), false);
// move pointer into window
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
QVERIFY(!window->frameGeometry().contains(QPoint(800, 800)));
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(window->frameGeometry().center());
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
QVERIFY(enteredSpy.wait());
// click inside window to create serial
quint32 timestamp = 0;
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonPressed(BTN_LEFT, timestamp++);
Test::pointerButtonReleased(BTN_LEFT, timestamp++);
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
QVERIFY(buttonStateChangedSpy.wait());
// now create the popup surface
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
QScopedPointer<Test::XdgPositioner> positioner(Test::createXdgPositioner());
positioner->set_size(100, 50);
positioner->set_anchor_rect(0, 0, 80, 20);
positioner->set_anchor(Test::XdgPositioner::anchor_bottom_right);
positioner->set_gravity(Test::XdgPositioner::gravity_bottom_right);
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *popupSurface = Test::createSurface(m_compositor);
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
QVERIFY(popupSurface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgPopup *popupShellSurface = Test::createXdgPopupSurface(popupSurface, shellSurface->xdgSurface(), positioner.data());
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
QVERIFY(popupShellSurface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
QSignalSpy doneReceivedSpy(popupShellSurface, &Test::XdgPopup::doneReceived);
QVERIFY(doneReceivedSpy.isValid());
popupShellSurface->grab(*Test::waylandSeat(), 0); // FIXME: Serial.
render(popupSurface, QSize(100, 50));
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
auto popupClient = clientAddedSpy.last().first().value<Window *>();
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
QVERIFY(popupClient);
QVERIFY(popupClient != window);
QCOMPARE(window, workspace()->activeClient());
QCOMPARE(popupClient->transientFor(), window);
QCOMPARE(popupClient->pos(), window->pos() + QPoint(80, 20));
QCOMPARE(popupClient->hasPopupGrab(), true);
// let's move the pointer into the center of the window
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(popupClient->frameGeometry().center());
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 2);
QCOMPARE(leftSpy.count(), 1);
QCOMPARE(pointer->enteredSurface(), popupSurface);
// let's move the pointer outside of the popup window
// this should not really change anything, it gets a leave event
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(popupClient->frameGeometry().bottomRight() + QPoint(2, 2));
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
QVERIFY(leftSpy.wait());
QCOMPARE(leftSpy.count(), 2);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
QVERIFY(doneReceivedSpy.isEmpty());
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
// now click, should trigger popupDone
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonPressed(BTN_LEFT, timestamp++);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
QVERIFY(doneReceivedSpy.wait());
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonReleased(BTN_LEFT, timestamp++);
Initial support for popup window handling Summary: So far KWin did not properly handle popup windows. That is when a popup surface got created and a click outside the surface happened KWin did not send out the popupDone Wayland event. This change makes KWin aware of whether a surface is a popup and tracks through a new PopupInputFilter whether there are popup windows. In case there are popups the new filter waits for mouse press events and cancels the popups if the press does not happen on any surface belonging to the same client. To quote the relevant section of the Wayland documentation: The popup grab continues until the window is destroyed or a mouse button is pressed in any other client's window. A click in any of the client's surfaces is reported as normal, however, clicks in other clients' surfaces will be discarded and trigger the callback. So far the support is still incomplete. Not yet implemented are: * support xdg_shell popup windows * verifying whether the popup is allowed to be a popup * cancel the popup on more global interactions like screen lock or kwin effect BUG: 366609 FIXED-IN: 5.10 Test Plan: Auto test and manual testing with QtWayland client Reviewers: #plasma, #kwin Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5177
2017-03-25 17:41:28 +00:00
}
Cancel popup if the user clicked window decoration of parent window Summary: So far the window decoration was not considered and e.g. right clicking the window decoration resulted in two open popups - one by KWin and one by the application. This change addresses the problem by ensuring the popup gets cancelled if the decoration is clicked. It's considered not being part of the window. Test Plan: Added test case which fails without the change Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5388
2017-04-10 16:19:45 +00:00
void PointerInputTest::testDecoCancelsPopup()
{
// this test verifies that clicking the window decoration of parent window
// cancels the popup
// first create a parent surface
using namespace KWayland::Client;
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy enteredSpy(pointer, &Pointer::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy leftSpy(pointer, &Pointer::left);
QVERIFY(leftSpy.isValid());
QSignalSpy buttonStateChangedSpy(pointer, &Pointer::buttonStateChanged);
QVERIFY(buttonStateChangedSpy.isValid());
QSignalSpy motionSpy(pointer, &Pointer::motion);
QVERIFY(motionSpy.isValid());
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(800, 800);
Cancel popup if the user clicked window decoration of parent window Summary: So far the window decoration was not considered and e.g. right clicking the window decoration resulted in two open popups - one by KWin and one by the application. This change addresses the problem by ensuring the popup gets cancelled if the decoration is clicked. It's considered not being part of the window. Test Plan: Added test case which fails without the change Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5388
2017-04-10 16:19:45 +00:00
autotests: Fix PointerInputTest::testDecoCancelsPopup() We need to ack configure event that wants to change deco mode.
2021-12-15 15:14:25 +00:00
// create a decorated window
QScopedPointer<KWayland::Client::Surface> surface(Test::createSurface());
QScopedPointer<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.data(), Test::CreationSetup::CreateOnly));
QScopedPointer<Test::XdgToplevelDecorationV1> decoration(Test::createXdgToplevelDecorationV1(shellSurface.data()));
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
decoration->set_mode(Test::XdgToplevelDecorationV1::mode_server_side);
surface->commit(KWayland::Client::Surface::CommitFlag::None);
QVERIFY(surfaceConfigureRequestedSpy.wait());
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
auto window = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
Cancel popup if the user clicked window decoration of parent window Summary: So far the window decoration was not considered and e.g. right clicking the window decoration resulted in two open popups - one by KWin and one by the application. This change addresses the problem by ensuring the popup gets cancelled if the decoration is clicked. It's considered not being part of the window. Test Plan: Added test case which fails without the change Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5388
2017-04-10 16:19:45 +00:00
QVERIFY(window);
QCOMPARE(window->hasPopupGrab(), false);
QVERIFY(window->isDecorated());
// move pointer into window
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
QVERIFY(!window->frameGeometry().contains(QPoint(800, 800)));
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(window->frameGeometry().center());
Cancel popup if the user clicked window decoration of parent window Summary: So far the window decoration was not considered and e.g. right clicking the window decoration resulted in two open popups - one by KWin and one by the application. This change addresses the problem by ensuring the popup gets cancelled if the decoration is clicked. It's considered not being part of the window. Test Plan: Added test case which fails without the change Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5388
2017-04-10 16:19:45 +00:00
QVERIFY(enteredSpy.wait());
// click inside window to create serial
quint32 timestamp = 0;
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonPressed(BTN_LEFT, timestamp++);
Test::pointerButtonReleased(BTN_LEFT, timestamp++);
Cancel popup if the user clicked window decoration of parent window Summary: So far the window decoration was not considered and e.g. right clicking the window decoration resulted in two open popups - one by KWin and one by the application. This change addresses the problem by ensuring the popup gets cancelled if the decoration is clicked. It's considered not being part of the window. Test Plan: Added test case which fails without the change Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5388
2017-04-10 16:19:45 +00:00
QVERIFY(buttonStateChangedSpy.wait());
// now create the popup surface
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
QScopedPointer<Test::XdgPositioner> positioner(Test::createXdgPositioner());
positioner->set_size(100, 50);
positioner->set_anchor_rect(0, 0, 80, 20);
positioner->set_anchor(Test::XdgPositioner::anchor_bottom_right);
positioner->set_gravity(Test::XdgPositioner::gravity_bottom_right);
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *popupSurface = Test::createSurface(m_compositor);
Cancel popup if the user clicked window decoration of parent window Summary: So far the window decoration was not considered and e.g. right clicking the window decoration resulted in two open popups - one by KWin and one by the application. This change addresses the problem by ensuring the popup gets cancelled if the decoration is clicked. It's considered not being part of the window. Test Plan: Added test case which fails without the change Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5388
2017-04-10 16:19:45 +00:00
QVERIFY(popupSurface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgPopup *popupShellSurface = Test::createXdgPopupSurface(popupSurface, shellSurface->xdgSurface(), positioner.data());
Cancel popup if the user clicked window decoration of parent window Summary: So far the window decoration was not considered and e.g. right clicking the window decoration resulted in two open popups - one by KWin and one by the application. This change addresses the problem by ensuring the popup gets cancelled if the decoration is clicked. It's considered not being part of the window. Test Plan: Added test case which fails without the change Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5388
2017-04-10 16:19:45 +00:00
QVERIFY(popupShellSurface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
QSignalSpy doneReceivedSpy(popupShellSurface, &Test::XdgPopup::doneReceived);
QVERIFY(doneReceivedSpy.isValid());
popupShellSurface->grab(*Test::waylandSeat(), 0); // FIXME: Serial.
autotests: Fix PointerInputTest::testDecoCancelsPopup() We need to ack configure event that wants to change deco mode.
2021-12-15 15:14:25 +00:00
auto popupClient = Test::renderAndWaitForShown(popupSurface, QSize(100, 50), Qt::red);
Cancel popup if the user clicked window decoration of parent window Summary: So far the window decoration was not considered and e.g. right clicking the window decoration resulted in two open popups - one by KWin and one by the application. This change addresses the problem by ensuring the popup gets cancelled if the decoration is clicked. It's considered not being part of the window. Test Plan: Added test case which fails without the change Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5388
2017-04-10 16:19:45 +00:00
QVERIFY(popupClient);
QVERIFY(popupClient != window);
QCOMPARE(window, workspace()->activeClient());
QCOMPARE(popupClient->transientFor(), window);
QCOMPARE(popupClient->pos(), window->pos() + window->clientPos() + QPoint(80, 20));
QCOMPARE(popupClient->hasPopupGrab(), true);
// let's move the pointer into the center of the deco
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(window->frameGeometry().center().x(), window->y() + (window->height() - window->clientSize().height()) / 2);
Cancel popup if the user clicked window decoration of parent window Summary: So far the window decoration was not considered and e.g. right clicking the window decoration resulted in two open popups - one by KWin and one by the application. This change addresses the problem by ensuring the popup gets cancelled if the decoration is clicked. It's considered not being part of the window. Test Plan: Added test case which fails without the change Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5388
2017-04-10 16:19:45 +00:00
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonPressed(BTN_RIGHT, timestamp++);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
QVERIFY(doneReceivedSpy.wait());
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonReleased(BTN_RIGHT, timestamp++);
Cancel popup if the user clicked window decoration of parent window Summary: So far the window decoration was not considered and e.g. right clicking the window decoration resulted in two open popups - one by KWin and one by the application. This change addresses the problem by ensuring the popup gets cancelled if the decoration is clicked. It's considered not being part of the window. Test Plan: Added test case which fails without the change Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5388
2017-04-10 16:19:45 +00:00
}
Don't update the focused pointer Surface if a button is pressed Summary: During pointer motion we already had the condition that an update of focused pointer surface can only happen when no button is pressed. But there are more conditions where we try to update the focused pointer even if a button is pressed. E.g. if the stacking order changes. This happens when trying to move one of Qt's dock widgets: 1. Press inside a dock widget 2. Qt opens another window, which is underneath the cursor 3. KWin sends pointer leave to parent window 4. dock widget movement breaks This change ensures that also this sequence works as expected and the pointer gets only updated when there are no buttons pressed, no matter from where we go into the update code path. BUG: 372876 Test Plan: Dock widgets in Dolphin can be moved now. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5461
2017-04-15 09:36:21 +00:00
void PointerInputTest::testWindowUnderCursorWhileButtonPressed()
{
// this test verifies that opening a window underneath the mouse cursor does not
// trigger a leave event if a button is pressed
// see BUG: 372876
// first create a parent surface
using namespace KWayland::Client;
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy enteredSpy(pointer, &Pointer::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy leftSpy(pointer, &Pointer::left);
QVERIFY(leftSpy.isValid());
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(800, 800);
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
Don't update the focused pointer Surface if a button is pressed Summary: During pointer motion we already had the condition that an update of focused pointer surface can only happen when no button is pressed. But there are more conditions where we try to update the focused pointer even if a button is pressed. E.g. if the stacking order changes. This happens when trying to move one of Qt's dock widgets: 1. Press inside a dock widget 2. Qt opens another window, which is underneath the cursor 3. KWin sends pointer leave to parent window 4. dock widget movement breaks This change ensures that also this sequence works as expected and the pointer gets only updated when there are no buttons pressed, no matter from where we go into the update code path. BUG: 372876 Test Plan: Dock widgets in Dolphin can be moved now. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5461
2017-04-15 09:36:21 +00:00
QVERIFY(clientAddedSpy.isValid());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface = Test::createSurface(m_compositor);
Don't update the focused pointer Surface if a button is pressed Summary: During pointer motion we already had the condition that an update of focused pointer surface can only happen when no button is pressed. But there are more conditions where we try to update the focused pointer even if a button is pressed. E.g. if the stacking order changes. This happens when trying to move one of Qt's dock widgets: 1. Press inside a dock widget 2. Qt opens another window, which is underneath the cursor 3. KWin sends pointer leave to parent window 4. dock widget movement breaks This change ensures that also this sequence works as expected and the pointer gets only updated when there are no buttons pressed, no matter from where we go into the update code path. BUG: 372876 Test Plan: Dock widgets in Dolphin can be moved now. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5461
2017-04-15 09:36:21 +00:00
QVERIFY(surface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface, surface);
Don't update the focused pointer Surface if a button is pressed Summary: During pointer motion we already had the condition that an update of focused pointer surface can only happen when no button is pressed. But there are more conditions where we try to update the focused pointer even if a button is pressed. E.g. if the stacking order changes. This happens when trying to move one of Qt's dock widgets: 1. Press inside a dock widget 2. Qt opens another window, which is underneath the cursor 3. KWin sends pointer leave to parent window 4. dock widget movement breaks This change ensures that also this sequence works as expected and the pointer gets only updated when there are no buttons pressed, no matter from where we go into the update code path. BUG: 372876 Test Plan: Dock widgets in Dolphin can be moved now. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5461
2017-04-15 09:36:21 +00:00
QVERIFY(shellSurface);
render(surface);
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *window = workspace()->activeClient();
Don't update the focused pointer Surface if a button is pressed Summary: During pointer motion we already had the condition that an update of focused pointer surface can only happen when no button is pressed. But there are more conditions where we try to update the focused pointer even if a button is pressed. E.g. if the stacking order changes. This happens when trying to move one of Qt's dock widgets: 1. Press inside a dock widget 2. Qt opens another window, which is underneath the cursor 3. KWin sends pointer leave to parent window 4. dock widget movement breaks This change ensures that also this sequence works as expected and the pointer gets only updated when there are no buttons pressed, no matter from where we go into the update code path. BUG: 372876 Test Plan: Dock widgets in Dolphin can be moved now. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5461
2017-04-15 09:36:21 +00:00
QVERIFY(window);
// move cursor over window
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
QVERIFY(!window->frameGeometry().contains(QPoint(800, 800)));
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(window->frameGeometry().center());
Don't update the focused pointer Surface if a button is pressed Summary: During pointer motion we already had the condition that an update of focused pointer surface can only happen when no button is pressed. But there are more conditions where we try to update the focused pointer even if a button is pressed. E.g. if the stacking order changes. This happens when trying to move one of Qt's dock widgets: 1. Press inside a dock widget 2. Qt opens another window, which is underneath the cursor 3. KWin sends pointer leave to parent window 4. dock widget movement breaks This change ensures that also this sequence works as expected and the pointer gets only updated when there are no buttons pressed, no matter from where we go into the update code path. BUG: 372876 Test Plan: Dock widgets in Dolphin can be moved now. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5461
2017-04-15 09:36:21 +00:00
QVERIFY(enteredSpy.wait());
// click inside window
quint32 timestamp = 0;
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonPressed(BTN_LEFT, timestamp++);
Don't update the focused pointer Surface if a button is pressed Summary: During pointer motion we already had the condition that an update of focused pointer surface can only happen when no button is pressed. But there are more conditions where we try to update the focused pointer even if a button is pressed. E.g. if the stacking order changes. This happens when trying to move one of Qt's dock widgets: 1. Press inside a dock widget 2. Qt opens another window, which is underneath the cursor 3. KWin sends pointer leave to parent window 4. dock widget movement breaks This change ensures that also this sequence works as expected and the pointer gets only updated when there are no buttons pressed, no matter from where we go into the update code path. BUG: 372876 Test Plan: Dock widgets in Dolphin can be moved now. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5461
2017-04-15 09:36:21 +00:00
// now create a second window as transient
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
QScopedPointer<Test::XdgPositioner> positioner(Test::createXdgPositioner());
positioner->set_size(99, 49);
positioner->set_anchor_rect(0, 0, 1, 1);
positioner->set_anchor(Test::XdgPositioner::anchor_bottom_right);
positioner->set_gravity(Test::XdgPositioner::gravity_bottom_right);
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *popupSurface = Test::createSurface(m_compositor);
Don't update the focused pointer Surface if a button is pressed Summary: During pointer motion we already had the condition that an update of focused pointer surface can only happen when no button is pressed. But there are more conditions where we try to update the focused pointer even if a button is pressed. E.g. if the stacking order changes. This happens when trying to move one of Qt's dock widgets: 1. Press inside a dock widget 2. Qt opens another window, which is underneath the cursor 3. KWin sends pointer leave to parent window 4. dock widget movement breaks This change ensures that also this sequence works as expected and the pointer gets only updated when there are no buttons pressed, no matter from where we go into the update code path. BUG: 372876 Test Plan: Dock widgets in Dolphin can be moved now. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5461
2017-04-15 09:36:21 +00:00
QVERIFY(popupSurface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgPopup *popupShellSurface = Test::createXdgPopupSurface(popupSurface, shellSurface->xdgSurface(), positioner.data());
Don't update the focused pointer Surface if a button is pressed Summary: During pointer motion we already had the condition that an update of focused pointer surface can only happen when no button is pressed. But there are more conditions where we try to update the focused pointer even if a button is pressed. E.g. if the stacking order changes. This happens when trying to move one of Qt's dock widgets: 1. Press inside a dock widget 2. Qt opens another window, which is underneath the cursor 3. KWin sends pointer leave to parent window 4. dock widget movement breaks This change ensures that also this sequence works as expected and the pointer gets only updated when there are no buttons pressed, no matter from where we go into the update code path. BUG: 372876 Test Plan: Dock widgets in Dolphin can be moved now. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5461
2017-04-15 09:36:21 +00:00
QVERIFY(popupShellSurface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
render(popupSurface, QSize(99, 49));
Don't update the focused pointer Surface if a button is pressed Summary: During pointer motion we already had the condition that an update of focused pointer surface can only happen when no button is pressed. But there are more conditions where we try to update the focused pointer even if a button is pressed. E.g. if the stacking order changes. This happens when trying to move one of Qt's dock widgets: 1. Press inside a dock widget 2. Qt opens another window, which is underneath the cursor 3. KWin sends pointer leave to parent window 4. dock widget movement breaks This change ensures that also this sequence works as expected and the pointer gets only updated when there are no buttons pressed, no matter from where we go into the update code path. BUG: 372876 Test Plan: Dock widgets in Dolphin can be moved now. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5461
2017-04-15 09:36:21 +00:00
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
auto popupClient = clientAddedSpy.last().first().value<Window *>();
Don't update the focused pointer Surface if a button is pressed Summary: During pointer motion we already had the condition that an update of focused pointer surface can only happen when no button is pressed. But there are more conditions where we try to update the focused pointer even if a button is pressed. E.g. if the stacking order changes. This happens when trying to move one of Qt's dock widgets: 1. Press inside a dock widget 2. Qt opens another window, which is underneath the cursor 3. KWin sends pointer leave to parent window 4. dock widget movement breaks This change ensures that also this sequence works as expected and the pointer gets only updated when there are no buttons pressed, no matter from where we go into the update code path. BUG: 372876 Test Plan: Dock widgets in Dolphin can be moved now. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5461
2017-04-15 09:36:21 +00:00
QVERIFY(popupClient);
QVERIFY(popupClient != window);
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QVERIFY(window->frameGeometry().contains(Cursors::self()->mouse()->pos()));
QVERIFY(popupClient->frameGeometry().contains(Cursors::self()->mouse()->pos()));
Don't update the focused pointer Surface if a button is pressed Summary: During pointer motion we already had the condition that an update of focused pointer surface can only happen when no button is pressed. But there are more conditions where we try to update the focused pointer even if a button is pressed. E.g. if the stacking order changes. This happens when trying to move one of Qt's dock widgets: 1. Press inside a dock widget 2. Qt opens another window, which is underneath the cursor 3. KWin sends pointer leave to parent window 4. dock widget movement breaks This change ensures that also this sequence works as expected and the pointer gets only updated when there are no buttons pressed, no matter from where we go into the update code path. BUG: 372876 Test Plan: Dock widgets in Dolphin can be moved now. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5461
2017-04-15 09:36:21 +00:00
QVERIFY(!leftSpy.wait());
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerButtonReleased(BTN_LEFT, timestamp++);
Don't update the focused pointer Surface if a button is pressed Summary: During pointer motion we already had the condition that an update of focused pointer surface can only happen when no button is pressed. But there are more conditions where we try to update the focused pointer even if a button is pressed. E.g. if the stacking order changes. This happens when trying to move one of Qt's dock widgets: 1. Press inside a dock widget 2. Qt opens another window, which is underneath the cursor 3. KWin sends pointer leave to parent window 4. dock widget movement breaks This change ensures that also this sequence works as expected and the pointer gets only updated when there are no buttons pressed, no matter from where we go into the update code path. BUG: 372876 Test Plan: Dock widgets in Dolphin can be moved now. Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D5461
2017-04-15 09:36:21 +00:00
// now that the button is no longer pressed we should get the leave event
QVERIFY(leftSpy.wait());
QCOMPARE(leftSpy.count(), 1);
QCOMPARE(enteredSpy.count(), 2);
}
[wayland] Confine pointer to screen geometry Summary: If the new pointer position is "off screen", PointerInputRedirection just ignores that new position. So, pointer remains on its previous position. In some particular cases, like reaching default panel, it degrades desktop experience because one have to slowly move pointer in order to reach what he/she wants. This change addresses that problem by confining the new pointer position to screen geometry. BUG: 374867 FIXED-IN: 5.13.4 Test Plan: Ran tests Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14036
2018-07-10 18:09:22 +00:00
void PointerInputTest::testConfineToScreenGeometry_data()
{
QTest::addColumn<QPoint>("startPos");
QTest::addColumn<QPoint>("targetPos");
QTest::addColumn<QPoint>("expectedPos");
// screen layout:
//
// +----------+----------+---------+
// | left | top | right |
// +----------+----------+---------+
// | bottom |
// +----------+
//
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QTest::newRow("move top-left - left screen") << QPoint(640, 512) << QPoint(-100, -100) << QPoint(0, 0);
QTest::newRow("move top - left screen") << QPoint(640, 512) << QPoint(640, -100) << QPoint(640, 0);
QTest::newRow("move top-right - left screen") << QPoint(640, 512) << QPoint(1380, -100) << QPoint(1380, 0);
QTest::newRow("move right - left screen") << QPoint(640, 512) << QPoint(1380, 512) << QPoint(1380, 512);
QTest::newRow("move bottom-right - left screen") << QPoint(640, 512) << QPoint(1380, 1124) << QPoint(1380, 1124);
QTest::newRow("move bottom - left screen") << QPoint(640, 512) << QPoint(640, 1124) << QPoint(640, 1023);
QTest::newRow("move bottom-left - left screen") << QPoint(640, 512) << QPoint(-100, 1124) << QPoint(0, 1023);
QTest::newRow("move left - left screen") << QPoint(640, 512) << QPoint(-100, 512) << QPoint(0, 512);
QTest::newRow("move top-left - top screen") << QPoint(1920, 512) << QPoint(1180, -100) << QPoint(1180, 0);
QTest::newRow("move top - top screen") << QPoint(1920, 512) << QPoint(1920, -100) << QPoint(1920, 0);
QTest::newRow("move top-right - top screen") << QPoint(1920, 512) << QPoint(2660, -100) << QPoint(2660, 0);
QTest::newRow("move right - top screen") << QPoint(1920, 512) << QPoint(2660, 512) << QPoint(2660, 512);
QTest::newRow("move bottom-right - top screen") << QPoint(1920, 512) << QPoint(2660, 1124) << QPoint(2559, 1023);
QTest::newRow("move bottom - top screen") << QPoint(1920, 512) << QPoint(1920, 1124) << QPoint(1920, 1124);
QTest::newRow("move bottom-left - top screen") << QPoint(1920, 512) << QPoint(1180, 1124) << QPoint(1280, 1023);
QTest::newRow("move left - top screen") << QPoint(1920, 512) << QPoint(1180, 512) << QPoint(1180, 512);
QTest::newRow("move top-left - right screen") << QPoint(3200, 512) << QPoint(2460, -100) << QPoint(2460, 0);
QTest::newRow("move top - right screen") << QPoint(3200, 512) << QPoint(3200, -100) << QPoint(3200, 0);
QTest::newRow("move top-right - right screen") << QPoint(3200, 512) << QPoint(3940, -100) << QPoint(3839, 0);
QTest::newRow("move right - right screen") << QPoint(3200, 512) << QPoint(3940, 512) << QPoint(3839, 512);
QTest::newRow("move bottom-right - right screen") << QPoint(3200, 512) << QPoint(3940, 1124) << QPoint(3839, 1023);
QTest::newRow("move bottom - right screen") << QPoint(3200, 512) << QPoint(3200, 1124) << QPoint(3200, 1023);
QTest::newRow("move bottom-left - right screen") << QPoint(3200, 512) << QPoint(2460, 1124) << QPoint(2460, 1124);
QTest::newRow("move left - right screen") << QPoint(3200, 512) << QPoint(2460, 512) << QPoint(2460, 512);
QTest::newRow("move top-left - bottom screen") << QPoint(1920, 1536) << QPoint(1180, 924) << QPoint(1180, 924);
QTest::newRow("move top - bottom screen") << QPoint(1920, 1536) << QPoint(1920, 924) << QPoint(1920, 924);
QTest::newRow("move top-right - bottom screen") << QPoint(1920, 1536) << QPoint(2660, 924) << QPoint(2660, 924);
QTest::newRow("move right - bottom screen") << QPoint(1920, 1536) << QPoint(2660, 1536) << QPoint(2559, 1536);
[wayland] Confine pointer to screen geometry Summary: If the new pointer position is "off screen", PointerInputRedirection just ignores that new position. So, pointer remains on its previous position. In some particular cases, like reaching default panel, it degrades desktop experience because one have to slowly move pointer in order to reach what he/she wants. This change addresses that problem by confining the new pointer position to screen geometry. BUG: 374867 FIXED-IN: 5.13.4 Test Plan: Ran tests Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14036
2018-07-10 18:09:22 +00:00
QTest::newRow("move bottom-right - bottom screen") << QPoint(1920, 1536) << QPoint(2660, 2148) << QPoint(2559, 2047);
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QTest::newRow("move bottom - bottom screen") << QPoint(1920, 1536) << QPoint(1920, 2148) << QPoint(1920, 2047);
QTest::newRow("move bottom-left - bottom screen") << QPoint(1920, 1536) << QPoint(1180, 2148) << QPoint(1280, 2047);
QTest::newRow("move left - bottom screen") << QPoint(1920, 1536) << QPoint(1180, 1536) << QPoint(1280, 1536);
[wayland] Confine pointer to screen geometry Summary: If the new pointer position is "off screen", PointerInputRedirection just ignores that new position. So, pointer remains on its previous position. In some particular cases, like reaching default panel, it degrades desktop experience because one have to slowly move pointer in order to reach what he/she wants. This change addresses that problem by confining the new pointer position to screen geometry. BUG: 374867 FIXED-IN: 5.13.4 Test Plan: Ran tests Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14036
2018-07-10 18:09:22 +00:00
}
void PointerInputTest::testConfineToScreenGeometry()
{
// this test verifies that pointer belongs to at least one screen
// after moving it to off-screen area
// unload the Present Windows effect because it pushes back
// pointer if it's at (0, 0)
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
static_cast<EffectsHandlerImpl *>(effects)->unloadEffect(QStringLiteral("presentwindows"));
[wayland] Confine pointer to screen geometry Summary: If the new pointer position is "off screen", PointerInputRedirection just ignores that new position. So, pointer remains on its previous position. In some particular cases, like reaching default panel, it degrades desktop experience because one have to slowly move pointer in order to reach what he/she wants. This change addresses that problem by confining the new pointer position to screen geometry. BUG: 374867 FIXED-IN: 5.13.4 Test Plan: Ran tests Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14036
2018-07-10 18:09:22 +00:00
// setup screen layout
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
const QVector<QRect> geometries{
[wayland] Confine pointer to screen geometry Summary: If the new pointer position is "off screen", PointerInputRedirection just ignores that new position. So, pointer remains on its previous position. In some particular cases, like reaching default panel, it degrades desktop experience because one have to slowly move pointer in order to reach what he/she wants. This change addresses that problem by confining the new pointer position to screen geometry. BUG: 374867 FIXED-IN: 5.13.4 Test Plan: Ran tests Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14036
2018-07-10 18:09:22 +00:00
QRect(0, 0, 1280, 1024),
QRect(1280, 0, 1280, 1024),
QRect(2560, 0, 1280, 1024),
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QRect(1280, 1024, 1280, 1024)};
[wayland] Confine pointer to screen geometry Summary: If the new pointer position is "off screen", PointerInputRedirection just ignores that new position. So, pointer remains on its previous position. In some particular cases, like reaching default panel, it degrades desktop experience because one have to slowly move pointer in order to reach what he/she wants. This change addresses that problem by confining the new pointer position to screen geometry. BUG: 374867 FIXED-IN: 5.13.4 Test Plan: Ran tests Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14036
2018-07-10 18:09:22 +00:00
QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs",
Qt::DirectConnection,
Q_ARG(int, geometries.count()),
Q_ARG(QVector<QRect>, geometries));
QCOMPARE(screens()->count(), geometries.count());
QCOMPARE(screens()->geometry(0), geometries.at(0));
QCOMPARE(screens()->geometry(1), geometries.at(1));
QCOMPARE(screens()->geometry(2), geometries.at(2));
QCOMPARE(screens()->geometry(3), geometries.at(3));
// move pointer to initial position
QFETCH(QPoint, startPos);
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(startPos);
QCOMPARE(Cursors::self()->mouse()->pos(), startPos);
[wayland] Confine pointer to screen geometry Summary: If the new pointer position is "off screen", PointerInputRedirection just ignores that new position. So, pointer remains on its previous position. In some particular cases, like reaching default panel, it degrades desktop experience because one have to slowly move pointer in order to reach what he/she wants. This change addresses that problem by confining the new pointer position to screen geometry. BUG: 374867 FIXED-IN: 5.13.4 Test Plan: Ran tests Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14036
2018-07-10 18:09:22 +00:00
// perform movement
QFETCH(QPoint, targetPos);
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerMotion(targetPos, 1);
[wayland] Confine pointer to screen geometry Summary: If the new pointer position is "off screen", PointerInputRedirection just ignores that new position. So, pointer remains on its previous position. In some particular cases, like reaching default panel, it degrades desktop experience because one have to slowly move pointer in order to reach what he/she wants. This change addresses that problem by confining the new pointer position to screen geometry. BUG: 374867 FIXED-IN: 5.13.4 Test Plan: Ran tests Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14036
2018-07-10 18:09:22 +00:00
QFETCH(QPoint, expectedPos);
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
QCOMPARE(Cursors::self()->mouse()->pos(), expectedPos);
[wayland] Confine pointer to screen geometry Summary: If the new pointer position is "off screen", PointerInputRedirection just ignores that new position. So, pointer remains on its previous position. In some particular cases, like reaching default panel, it degrades desktop experience because one have to slowly move pointer in order to reach what he/she wants. This change addresses that problem by confining the new pointer position to screen geometry. BUG: 374867 FIXED-IN: 5.13.4 Test Plan: Ran tests Reviewers: #kwin, graesslin Reviewed By: #kwin, graesslin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D14036
2018-07-10 18:09:22 +00:00
}
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
void PointerInputTest::testResizeCursor_data()
{
QTest::addColumn<Qt::Edges>("edges");
QTest::addColumn<KWin::CursorShape>("cursorShape");
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QTest::newRow("top-left") << Qt::Edges(Qt::TopEdge | Qt::LeftEdge) << CursorShape(ExtendedCursor::SizeNorthWest);
QTest::newRow("top") << Qt::Edges(Qt::TopEdge) << CursorShape(ExtendedCursor::SizeNorth);
QTest::newRow("top-right") << Qt::Edges(Qt::TopEdge | Qt::RightEdge) << CursorShape(ExtendedCursor::SizeNorthEast);
QTest::newRow("right") << Qt::Edges(Qt::RightEdge) << CursorShape(ExtendedCursor::SizeEast);
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
QTest::newRow("bottom-right") << Qt::Edges(Qt::BottomEdge | Qt::RightEdge) << CursorShape(ExtendedCursor::SizeSouthEast);
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
QTest::newRow("bottom") << Qt::Edges(Qt::BottomEdge) << CursorShape(ExtendedCursor::SizeSouth);
QTest::newRow("bottom-left") << Qt::Edges(Qt::BottomEdge | Qt::LeftEdge) << CursorShape(ExtendedCursor::SizeSouthWest);
QTest::newRow("left") << Qt::Edges(Qt::LeftEdge) << CursorShape(ExtendedCursor::SizeWest);
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
}
void PointerInputTest::testResizeCursor()
{
// this test verifies that the cursor has correct shape during resize operation
// first modify the config for this run
KConfigGroup group = kwinApp()->config()->group("MouseBindings");
Change CommandAllKey to Meta Summary: Alt + Left Click to move windows has a tendency to conflict with creative workflow apps. While Alt can be changed to Meta in KWin's settings, Alt + Left Click shortcuts often cannot be customized in apps. Rather than making every user who runs into this problem change their settings, we should change our default settings to improve KWin's default usability. The fact that Alt + Left Click to move windows is older does not matter. We are trying to use Meta for global/shell shortcuts anyway. BUG: 399375 Test Plan: The relevant parts of the relevant tests pass. kwin-testInternalWindow fails, but for unrelated reasons that have something to do with XWayland.
2020-05-06 09:17:44 +00:00
group.writeEntry("CommandAllKey", "Meta");
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
group.writeEntry("CommandAll3", "Resize");
group.sync();
workspace()->slotReconfigure();
Change CommandAllKey to Meta Summary: Alt + Left Click to move windows has a tendency to conflict with creative workflow apps. While Alt can be changed to Meta in KWin's settings, Alt + Left Click shortcuts often cannot be customized in apps. Rather than making every user who runs into this problem change their settings, we should change our default settings to improve KWin's default usability. The fact that Alt + Left Click to move windows is older does not matter. We are trying to use Meta for global/shell shortcuts anyway. BUG: 399375 Test Plan: The relevant parts of the relevant tests pass. kwin-testInternalWindow fails, but for unrelated reasons that have something to do with XWayland.
2020-05-06 09:17:44 +00:00
QCOMPARE(options->commandAllModifier(), Qt::MetaModifier);
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedResize);
autotests: Make PointerInputTest more robust According to the spec, when the pointer enters a surface, the contents of the cursor becomes undefined. The client should call set_cursor() to make sure that the cursor image is correct.
2021-02-22 13:41:31 +00:00
// load the fallback cursor (arrow cursor)
const PlatformCursorImage arrowCursor = loadReferenceThemeCursor(Qt::ArrowCursor);
QVERIFY(!arrowCursor.isNull());
QCOMPARE(kwinApp()->platform()->cursorImage().image(), arrowCursor.image());
QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), arrowCursor.hotSpot());
// we need a pointer to get the enter event
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy enteredSpy(pointer, &KWayland::Client::Pointer::entered);
QVERIFY(enteredSpy.isValid());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
// create a test client
using namespace KWayland::Client;
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
QScopedPointer<KWayland::Client::Surface> surface(Test::createSurface());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
QVERIFY(!surface.isNull());
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
QScopedPointer<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.data()));
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
QVERIFY(!shellSurface.isNull());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
QVERIFY(c);
// move the cursor to the test position
QPoint cursorPos;
QFETCH(Qt::Edges, edges);
if (edges & Qt::LeftEdge) {
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
cursorPos.setX(c->frameGeometry().left());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
} else if (edges & Qt::RightEdge) {
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
cursorPos.setX(c->frameGeometry().right());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
} else {
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
cursorPos.setX(c->frameGeometry().center().x());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
}
if (edges & Qt::TopEdge) {
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
cursorPos.setY(c->frameGeometry().top());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
} else if (edges & Qt::BottomEdge) {
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
cursorPos.setY(c->frameGeometry().bottom());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
} else {
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
cursorPos.setY(c->frameGeometry().center().y());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
}
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(cursorPos);
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
autotests: Make PointerInputTest more robust According to the spec, when the pointer enters a surface, the contents of the cursor becomes undefined. The client should call set_cursor() to make sure that the cursor image is correct.
2021-02-22 13:41:31 +00:00
// wait for the enter event and set the cursor
QVERIFY(enteredSpy.wait());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
QScopedPointer<KWayland::Client::Surface> cursorSurface(Test::createSurface(m_compositor));
autotests: Make PointerInputTest more robust According to the spec, when the pointer enters a surface, the contents of the cursor becomes undefined. The client should call set_cursor() to make sure that the cursor image is correct.
2021-02-22 13:41:31 +00:00
QVERIFY(cursorSurface);
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
QSignalSpy cursorRenderedSpy(cursorSurface.data(), &KWayland::Client::Surface::frameRendered);
autotests: Make PointerInputTest more robust According to the spec, when the pointer enters a surface, the contents of the cursor becomes undefined. The client should call set_cursor() to make sure that the cursor image is correct.
2021-02-22 13:41:31 +00:00
QVERIFY(cursorRenderedSpy.isValid());
cursorSurface->attachBuffer(Test::waylandShmPool()->createBuffer(arrowCursor.image()));
cursorSurface->damage(arrowCursor.image().rect());
cursorSurface->commit();
pointer->setCursor(cursorSurface.data(), arrowCursor.hotSpot());
QVERIFY(cursorRenderedSpy.wait());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
// start resizing the client
int timestamp = 1;
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
Test::pointerButtonPressed(BTN_RIGHT, timestamp++);
Prepend "Interactive" to interactive move resize methods This is to improve code readability and make it easier to differentiate between methods that are used during interactive move-resize and normal move-resize methods in the future.
2021-04-30 18:06:58 +00:00
QVERIFY(c->isInteractiveResize());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
QFETCH(KWin::CursorShape, cursorShape);
const PlatformCursorImage resizeCursor = loadReferenceThemeCursor(cursorShape);
[wayland] Rework Xcursor theme loading code Currently in order to load an Xcursor theme, kwin uses libwayland api, which looks really awkward because of the way how the compositor talks to itself via the internal connection. The main motivation behind this change is to limit the usage of kwayland client api in kwin.
2020-05-18 19:37:41 +00:00
QVERIFY(!resizeCursor.isNull());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
QCOMPARE(kwinApp()->platform()->cursorImage().image(), resizeCursor.image());
QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), resizeCursor.hotSpot());
// finish resizing the client
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
Test::pointerButtonReleased(BTN_RIGHT, timestamp++);
Prepend "Interactive" to interactive move resize methods This is to improve code readability and make it easier to differentiate between methods that are used during interactive move-resize and normal move-resize methods in the future.
2021-04-30 18:06:58 +00:00
QVERIFY(!c->isInteractiveResize());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
QCOMPARE(kwinApp()->platform()->cursorImage().image(), arrowCursor.image());
QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), arrowCursor.hotSpot());
}
void PointerInputTest::testMoveCursor()
{
// this test verifies that the cursor has correct shape during move operation
// first modify the config for this run
KConfigGroup group = kwinApp()->config()->group("MouseBindings");
Change CommandAllKey to Meta Summary: Alt + Left Click to move windows has a tendency to conflict with creative workflow apps. While Alt can be changed to Meta in KWin's settings, Alt + Left Click shortcuts often cannot be customized in apps. Rather than making every user who runs into this problem change their settings, we should change our default settings to improve KWin's default usability. The fact that Alt + Left Click to move windows is older does not matter. We are trying to use Meta for global/shell shortcuts anyway. BUG: 399375 Test Plan: The relevant parts of the relevant tests pass. kwin-testInternalWindow fails, but for unrelated reasons that have something to do with XWayland.
2020-05-06 09:17:44 +00:00
group.writeEntry("CommandAllKey", "Meta");
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
group.writeEntry("CommandAll1", "Move");
group.sync();
workspace()->slotReconfigure();
Change CommandAllKey to Meta Summary: Alt + Left Click to move windows has a tendency to conflict with creative workflow apps. While Alt can be changed to Meta in KWin's settings, Alt + Left Click shortcuts often cannot be customized in apps. Rather than making every user who runs into this problem change their settings, we should change our default settings to improve KWin's default usability. The fact that Alt + Left Click to move windows is older does not matter. We are trying to use Meta for global/shell shortcuts anyway. BUG: 399375 Test Plan: The relevant parts of the relevant tests pass. kwin-testInternalWindow fails, but for unrelated reasons that have something to do with XWayland.
2020-05-06 09:17:44 +00:00
QCOMPARE(options->commandAllModifier(), Qt::MetaModifier);
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
autotests: Make PointerInputTest more robust According to the spec, when the pointer enters a surface, the contents of the cursor becomes undefined. The client should call set_cursor() to make sure that the cursor image is correct.
2021-02-22 13:41:31 +00:00
// load the fallback cursor (arrow cursor)
const PlatformCursorImage arrowCursor = loadReferenceThemeCursor(Qt::ArrowCursor);
QVERIFY(!arrowCursor.isNull());
QCOMPARE(kwinApp()->platform()->cursorImage().image(), arrowCursor.image());
QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), arrowCursor.hotSpot());
// we need a pointer to get the enter event
auto pointer = m_seat->createPointer(m_seat);
QVERIFY(pointer);
QVERIFY(pointer->isValid());
QSignalSpy enteredSpy(pointer, &KWayland::Client::Pointer::entered);
QVERIFY(enteredSpy.isValid());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
// create a test client
using namespace KWayland::Client;
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
QScopedPointer<KWayland::Client::Surface> surface(Test::createSurface());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
QVERIFY(!surface.isNull());
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
QScopedPointer<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.data()));
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
QVERIFY(!shellSurface.isNull());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
QVERIFY(c);
// move cursor to the test position
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(c->frameGeometry().center());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
autotests: Make PointerInputTest more robust According to the spec, when the pointer enters a surface, the contents of the cursor becomes undefined. The client should call set_cursor() to make sure that the cursor image is correct.
2021-02-22 13:41:31 +00:00
// wait for the enter event and set the cursor
QVERIFY(enteredSpy.wait());
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
QScopedPointer<KWayland::Client::Surface> cursorSurface(Test::createSurface(m_compositor));
autotests: Make PointerInputTest more robust According to the spec, when the pointer enters a surface, the contents of the cursor becomes undefined. The client should call set_cursor() to make sure that the cursor image is correct.
2021-02-22 13:41:31 +00:00
QVERIFY(cursorSurface);
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
QSignalSpy cursorRenderedSpy(cursorSurface.data(), &KWayland::Client::Surface::frameRendered);
autotests: Make PointerInputTest more robust According to the spec, when the pointer enters a surface, the contents of the cursor becomes undefined. The client should call set_cursor() to make sure that the cursor image is correct.
2021-02-22 13:41:31 +00:00
QVERIFY(cursorRenderedSpy.isValid());
cursorSurface->attachBuffer(Test::waylandShmPool()->createBuffer(arrowCursor.image()));
cursorSurface->damage(arrowCursor.image().rect());
cursorSurface->commit();
pointer->setCursor(cursorSurface.data(), arrowCursor.hotSpot());
QVERIFY(cursorRenderedSpy.wait());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
// start moving the client
int timestamp = 1;
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
Test::pointerButtonPressed(BTN_LEFT, timestamp++);
Prepend "Interactive" to interactive move resize methods This is to improve code readability and make it easier to differentiate between methods that are used during interactive move-resize and normal move-resize methods in the future.
2021-04-30 18:06:58 +00:00
QVERIFY(c->isInteractiveMove());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
const PlatformCursorImage sizeAllCursor = loadReferenceThemeCursor(Qt::SizeAllCursor);
[wayland] Rework Xcursor theme loading code Currently in order to load an Xcursor theme, kwin uses libwayland api, which looks really awkward because of the way how the compositor talks to itself via the internal connection. The main motivation behind this change is to limit the usage of kwayland client api in kwin.
2020-05-18 19:37:41 +00:00
QVERIFY(!sizeAllCursor.isNull());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
QCOMPARE(kwinApp()->platform()->cursorImage().image(), sizeAllCursor.image());
QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), sizeAllCursor.hotSpot());
// finish moving the client
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
Test::pointerButtonReleased(BTN_LEFT, timestamp++);
Prepend "Interactive" to interactive move resize methods This is to improve code readability and make it easier to differentiate between methods that are used during interactive move-resize and normal move-resize methods in the future.
2021-04-30 18:06:58 +00:00
QVERIFY(!c->isInteractiveMove());
[wayland] Don't use hardcoded move-resize cursor Summary: Currently, when resizing a window the cursor doesn't match the resize direction. The reason for that is the move-resize cursor is hardcoded. To fix that, CursorImage::updateMoveResize has to use AbstractClient::cursor. Also, because the move-resize cursor is updated after calling startMoveResize, we have to connect to AbstractClient::moveResizeCursorChanged. BUG: 370339 FIXED-IN: 5.15 Reviewers: #kwin, davidedmundson, broulik, romangg, graesslin Reviewed By: #kwin, graesslin Subscribers: davidedmundson, romangg, graesslin, kwin Tags: #kwin Maniphest Tasks: T5714 Differential Revision: https://phabricator.kde.org/D3202
2018-12-25 15:30:38 +00:00
QCOMPARE(kwinApp()->platform()->cursorImage().image(), arrowCursor.image());
QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), arrowCursor.hotSpot());
}
[autotests] Don't test wl-shell clients Summary: This change removes all traces of wl-shell in the test suite. That's a prerequisite for dropping wl-shell support in KWin. Given that wl-shell and xdg-shell are not interchangeable, some tests were removed and initialization sequence in some tests was adjusted. The most notable change is ensuring that each plasmashell window sets its role and initial position before committing the surface. Setting those properties before the first surface commit is important because our window placement code needs to know window type in order to avoid maximizing panels, popups, etc. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23561
2019-08-27 15:01:14 +00:00
void PointerInputTest::testHideShowCursor()
{
make software cursors work per output
2021-12-25 17:12:12 +00:00
QCOMPARE(Cursors::self()->isCursorHidden(), false);
Cursors::self()->hideCursor();
QCOMPARE(Cursors::self()->isCursorHidden(), true);
Cursors::self()->showCursor();
QCOMPARE(Cursors::self()->isCursorHidden(), false);
Cursors::self()->hideCursor();
QCOMPARE(Cursors::self()->isCursorHidden(), true);
Cursors::self()->hideCursor();
Cursors::self()->hideCursor();
Cursors::self()->hideCursor();
QCOMPARE(Cursors::self()->isCursorHidden(), true);
Cursors::self()->showCursor();
QCOMPARE(Cursors::self()->isCursorHidden(), true);
Cursors::self()->showCursor();
QCOMPARE(Cursors::self()->isCursorHidden(), true);
Cursors::self()->showCursor();
QCOMPARE(Cursors::self()->isCursorHidden(), true);
Cursors::self()->showCursor();
QCOMPARE(Cursors::self()->isCursorHidden(), false);
[autotests] Don't test wl-shell clients Summary: This change removes all traces of wl-shell in the test suite. That's a prerequisite for dropping wl-shell support in KWin. Given that wl-shell and xdg-shell are not interchangeable, some tests were removed and initialization sequence in some tests was adjusted. The most notable change is ensuring that each plasmashell window sets its role and initial position before committing the surface. Setting those properties before the first surface commit is important because our window placement code needs to know window type in order to avoid maximizing panels, popups, etc. Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D23561
2019-08-27 15:01:14 +00:00
}
Adapt to input region changes in kwayland-server SurfaceInterface::inputIsInfinite() has been dropped. If the surface has no any input region specified, SurfaceInterface::input() will return a region that corresponds to the rect of the surface (0, 0, width, height). While the new design is more robust, for example it's no longer possible to forget to check SurfaceInterface::inputIsInfinite(), it has shown some issues in the input stack of kwin. Currently, acceptsInput() will return false if you attempt to click the server-side decoration for a surface whose input region is not empty. Therefore, it's possible for an application to set an input region with a width and a height of 1. If user doesn't know about KSysGuard or the possibility of closing apps via the task manager, they won't be able to close such an application. Another issue is that if an application has specified an empty input region on purpose, user will be still able click it. With the new behavior of SurfaceInterface::input(), this is no longer an issue and it is handled properly by kwin.
2020-10-17 12:47:25 +00:00
void PointerInputTest::testDefaultInputRegion()
{
// This test verifies that a surface that hasn't specified the input region can be focused.
// Create a test client.
using namespace KWayland::Client;
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
QScopedPointer<KWayland::Client::Surface> surface(Test::createSurface());
Adapt to input region changes in kwayland-server SurfaceInterface::inputIsInfinite() has been dropped. If the surface has no any input region specified, SurfaceInterface::input() will return a region that corresponds to the rect of the surface (0, 0, width, height). While the new design is more robust, for example it's no longer possible to forget to check SurfaceInterface::inputIsInfinite(), it has shown some issues in the input stack of kwin. Currently, acceptsInput() will return false if you attempt to click the server-side decoration for a surface whose input region is not empty. Therefore, it's possible for an application to set an input region with a width and a height of 1. If user doesn't know about KSysGuard or the possibility of closing apps via the task manager, they won't be able to close such an application. Another issue is that if an application has specified an empty input region on purpose, user will be still able click it. With the new behavior of SurfaceInterface::input(), this is no longer an issue and it is handled properly by kwin.
2020-10-17 12:47:25 +00:00
QVERIFY(!surface.isNull());
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
QScopedPointer<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.data()));
Adapt to input region changes in kwayland-server SurfaceInterface::inputIsInfinite() has been dropped. If the surface has no any input region specified, SurfaceInterface::input() will return a region that corresponds to the rect of the surface (0, 0, width, height). While the new design is more robust, for example it's no longer possible to forget to check SurfaceInterface::inputIsInfinite(), it has shown some issues in the input stack of kwin. Currently, acceptsInput() will return false if you attempt to click the server-side decoration for a surface whose input region is not empty. Therefore, it's possible for an application to set an input region with a width and a height of 1. If user doesn't know about KSysGuard or the possibility of closing apps via the task manager, they won't be able to close such an application. Another issue is that if an application has specified an empty input region on purpose, user will be still able click it. With the new behavior of SurfaceInterface::input(), this is no longer an issue and it is handled properly by kwin.
2020-10-17 12:47:25 +00:00
QVERIFY(!shellSurface.isNull());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
Adapt to input region changes in kwayland-server SurfaceInterface::inputIsInfinite() has been dropped. If the surface has no any input region specified, SurfaceInterface::input() will return a region that corresponds to the rect of the surface (0, 0, width, height). While the new design is more robust, for example it's no longer possible to forget to check SurfaceInterface::inputIsInfinite(), it has shown some issues in the input stack of kwin. Currently, acceptsInput() will return false if you attempt to click the server-side decoration for a surface whose input region is not empty. Therefore, it's possible for an application to set an input region with a width and a height of 1. If user doesn't know about KSysGuard or the possibility of closing apps via the task manager, they won't be able to close such an application. Another issue is that if an application has specified an empty input region on purpose, user will be still able click it. With the new behavior of SurfaceInterface::input(), this is no longer an issue and it is handled properly by kwin.
2020-10-17 12:47:25 +00:00
QVERIFY(client);
// Move the point to the center of the surface.
Cursors::self()->mouse()->setPos(client->frameGeometry().center());
QCOMPARE(waylandServer()->seat()->focusedPointerSurface(), client->surface());
// Destroy the test client.
shellSurface.reset();
QVERIFY(Test::waitForWindowDestroyed(client));
}
void PointerInputTest::testEmptyInputRegion()
{
// This test verifies that a surface that has specified an empty input region can't be focused.
// Create a test client.
using namespace KWayland::Client;
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
QScopedPointer<KWayland::Client::Surface> surface(Test::createSurface());
Adapt to input region changes in kwayland-server SurfaceInterface::inputIsInfinite() has been dropped. If the surface has no any input region specified, SurfaceInterface::input() will return a region that corresponds to the rect of the surface (0, 0, width, height). While the new design is more robust, for example it's no longer possible to forget to check SurfaceInterface::inputIsInfinite(), it has shown some issues in the input stack of kwin. Currently, acceptsInput() will return false if you attempt to click the server-side decoration for a surface whose input region is not empty. Therefore, it's possible for an application to set an input region with a width and a height of 1. If user doesn't know about KSysGuard or the possibility of closing apps via the task manager, they won't be able to close such an application. Another issue is that if an application has specified an empty input region on purpose, user will be still able click it. With the new behavior of SurfaceInterface::input(), this is no longer an issue and it is handled properly by kwin.
2020-10-17 12:47:25 +00:00
QVERIFY(!surface.isNull());
std::unique_ptr<KWayland::Client::Region> inputRegion(m_compositor->createRegion(QRegion()));
surface->setInputRegion(inputRegion.get());
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
QScopedPointer<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.data()));
Adapt to input region changes in kwayland-server SurfaceInterface::inputIsInfinite() has been dropped. If the surface has no any input region specified, SurfaceInterface::input() will return a region that corresponds to the rect of the surface (0, 0, width, height). While the new design is more robust, for example it's no longer possible to forget to check SurfaceInterface::inputIsInfinite(), it has shown some issues in the input stack of kwin. Currently, acceptsInput() will return false if you attempt to click the server-side decoration for a surface whose input region is not empty. Therefore, it's possible for an application to set an input region with a width and a height of 1. If user doesn't know about KSysGuard or the possibility of closing apps via the task manager, they won't be able to close such an application. Another issue is that if an application has specified an empty input region on purpose, user will be still able click it. With the new behavior of SurfaceInterface::input(), this is no longer an issue and it is handled properly by kwin.
2020-10-17 12:47:25 +00:00
QVERIFY(!shellSurface.isNull());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
Adapt to input region changes in kwayland-server SurfaceInterface::inputIsInfinite() has been dropped. If the surface has no any input region specified, SurfaceInterface::input() will return a region that corresponds to the rect of the surface (0, 0, width, height). While the new design is more robust, for example it's no longer possible to forget to check SurfaceInterface::inputIsInfinite(), it has shown some issues in the input stack of kwin. Currently, acceptsInput() will return false if you attempt to click the server-side decoration for a surface whose input region is not empty. Therefore, it's possible for an application to set an input region with a width and a height of 1. If user doesn't know about KSysGuard or the possibility of closing apps via the task manager, they won't be able to close such an application. Another issue is that if an application has specified an empty input region on purpose, user will be still able click it. With the new behavior of SurfaceInterface::input(), this is no longer an issue and it is handled properly by kwin.
2020-10-17 12:47:25 +00:00
QVERIFY(client);
// Move the point to the center of the surface.
Cursors::self()->mouse()->setPos(client->frameGeometry().center());
QVERIFY(!waylandServer()->seat()->focusedPointerSurface());
// Destroy the test client.
shellSurface.reset();
QVERIFY(Test::waitForWindowDestroyed(client));
}
[autotest] Add test for internal pointer warping When warping a pointer through Cursor::setPos it should be processed just like any other pointer event. It should generate enter/leave event, create motion events, etc. This is currently not the case as the test shows.
2016-02-11 11:48:42 +00:00
}
WAYLANDTEST_MAIN(KWin::PointerInputTest)
#include "pointer_input.moc"
Reference in a new issue Copy permalink