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

810 lines
34 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 case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +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 case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
Prettify license headers
2020-08-02 22:22:19 +00:00
SPDX-License-Identifier: GPL-2.0-or-later
*/
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +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
[autotests] Add test case for fullscreen window with groups When an X11 window is raised to fullscreen it gets set to active layer. When another window gets activated then it goes back to normal layer. But when a window of the same group gets activated the fullscreen window stays in the active layer. Due to that it is not possible to raise other windows above the fullscreen window. This just adds a test case exposing the problematic area. CCBUG: 388310
2018-01-06 09:45:44 +00:00
#include "atoms.h"
composite.h -> compositor.h
2023-08-31 12:23:42 +00:00
#include "compositor.h"
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
#include "cursor.h"
libkwineffects/ -> effect/
2023-11-17 08:59:08 +00:00
#include "effect/effectloader.h"
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
#include "wayland_server.h"
#include "workspace.h"
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
#include "x11window.h"
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
#include <KWayland/Client/surface.h>
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
#include <netwm.h>
#include <xcb/xcb_icccm.h>
using namespace KWin;
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
static const QString s_socketName = QStringLiteral("wayland_test_x11_window-0");
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
class X11WindowTest : public QObject
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
{
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
Q_OBJECT
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
private Q_SLOTS:
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
void initTestCase_data();
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
void initTestCase();
void init();
void cleanup();
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
void testMinimumSize();
void testMaximumSize();
Fix captions with non-BMP characters KWin replaces any non-printable character with a space. This check does not handle surrogate pairs correctly. Additionally, translators sometimes insert non-printable soft-hyphens into titles, which also cause KWin to display a space instead. This code adds the missing surrogate handling, and (to fix both issues), also removes non-printable characters instead of replacing them with a space. Also moved the changed test after these changes, so that changes in non- printable characters do not cause unneeded redraws. Unit tests adapted by Vlad Zagorodniy. Test Plan: kwrite /tmp/Test😣.txt shows correct title. I also tested actual non-printable characters, such as 0x1A, and these are correctly omitted. BUG: 376813 FIXED-IN: 5.15.5 Reviewers: #kwin, zzag Reviewed By: #kwin, zzag Subscribers: zzag, grasslin, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D19052
2019-04-26 08:52:57 +00:00
void testTrimCaption_data();
void testTrimCaption();
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
void testFullscreenLayerWithActiveWaylandWindow();
Reset last_active_client when a ShellClient is removed Summary: The last_active_client is set when an AbstractClient gets activated. For the X11 case the last_active_client was getting reset to nullptr when the last_active_client gets destroyed. But for the ShellClient that did not yet happen. This could result in a crash. This change addresses the problem and adds a test case which triggered the crash. The condition of the crash are difficult to generate though - it took me about an hour to write the test for the crash. 1. Wayland client must be active 2. Explicit focus to null (no active client) 3. destroy Wayland window 4. X11 client which sets focus on itself without interaction with window manager Test Plan: test case no longer crashes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D6852
2017-07-23 14:18:09 +00:00
void testFocusInWithWaylandLastActiveWindow();
[autotests] Add test case for updating X11 client captions CCBUG: 383444
2017-08-13 14:52:14 +00:00
void testCaptionChanges();
Use xcb-icccm to read the name property Summary: The KWindowSystem call which we used doesn't work on Wayland as it's only implemented in the xcb variant and cannot be made available for Wayland in an easy way as it is still XLib based. This change turns the optional XCB-ICCCM dependency in a required one and thus can use the functionality provided by said library to implement what KWindowSystem provided. BUG: 382789 Test Plan: New test case which failed with old code Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7046
2017-08-01 19:28:36 +00:00
void testCaptionWmName();
[autotests] Add test case for fullscreen window with groups When an X11 window is raised to fullscreen it gets set to active layer. When another window gets activated then it goes back to normal layer. But when a window of the same group gets activated the fullscreen window stays in the active layer. Due to that it is not possible to raise other windows above the fullscreen window. This just adds a test case exposing the problematic area. CCBUG: 388310
2018-01-06 09:45:44 +00:00
void testFullscreenWindowGroups();
[x11] Force FocusIn events for already focused windows Depending on the current focus stealing prevention level, it's possible for kwin to call XSetInputFocus() on a window that already has the input focus. In which case, we won't receive the corresponding FocusIn event and the client will remain inactive from kwin's perspective even though it isn't. In order to work around this issue, we can move the input focus to the null window. By doing so, it's guaranteed that we're going to receive the matching FocusIn event for the client. This commit indirectly fixes a bug where fullscreen games are displayed below panels.
2020-06-16 08:03:25 +00:00
void testActivateFocusedWindow();
Rework async geometry updates Window management features were written with synchronous geometry updates in mind. Currently, this poses a big problem on Wayland because geometry updates are done in asynchronous fashion there. At the moment, geometry is updated in a so called pseudo-asynchronous fashion, meaning that the frame geometry will be reset to the old value once geometry updates are unblocked. The main drawback of this approach is that it is too error prone, the data flow is hard to comprehend, etc. It is worth noting that there is already a machinery to perform async geometry which is used during interactive move/resize operations. This change extends the move/resize geometry usage beyond interactive move/resize to make asynchronous geometry updates less error prone and easier to comprehend. With the proposed solution, all geometry updates must be done on the move/resize geometry first. After that, the new geometry is passed on to the Client-specific implementation of moveResizeInternal(). To be more specific, the frameGeometry() returns the current frame geometry, it is primarily useful only to the scene. If you want to move or resize a window, you need to use moveResizeGeometry() because it corresponds to the last requested frame geometry. It is worth noting that the moveResizeGeometry() returns the desired bounding geometry. The client may commit the xdg_toplevel surface with a slightly smaller window geometry, for example to enforce a specific aspect ratio. The client is not allowed to resize beyond the size as indicated in moveResizeGeometry(). The data flow is very simple: moveResize() updates the move/resize geometry and calls the client-specific implementation of the moveResizeInternal() method. Based on whether a configure event is needed, moveResizeInternal() will update the frameGeometry() either immediately or after the client commits a new buffer. Unfortunately, both the compositor and xdg-shell clients try to update the window geometry. It means that it's possible to have conflicts between the two. With this change, the compositor's move resize geometry will be synced only if there are no pending configure events, meaning that the user doesn't try to resize the window.
2021-04-30 18:26:09 +00:00
void testReentrantMoveResize();
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
};
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
void X11WindowTest::initTestCase_data()
{
QTest::addColumn<qreal>("scale");
QTest::newRow("normal") << 1.0;
QTest::newRow("scaled2x") << 2.0;
}
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
void X11WindowTest::initTestCase()
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
{
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
qRegisterMetaType<KWin::Window *>();
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);
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));
autotests: directly call setVirtualOutputs
2023-05-08 10:16:00 +00:00
Test::setOutputConfig({QRect(0, 0, 1280, 1024)});
Reset last_active_client when a ShellClient is removed Summary: The last_active_client is set when an AbstractClient gets activated. For the X11 case the last_active_client was getting reset to nullptr when the last_active_client gets destroyed. But for the ShellClient that did not yet happen. This could result in a crash. This change addresses the problem and adds a test case which triggered the crash. The condition of the crash are difficult to generate though - it took me about an hour to write the test for the crash. 1. Wayland client must be active 2. Explicit focus to null (no active client) 3. destroy Wayland window 4. X11 client which sets focus on itself without interaction with window manager Test Plan: test case no longer crashes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D6852
2017-07-23 14:18:09 +00:00
kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +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());
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
QVERIFY(KWin::Compositor::self());
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
}
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
void X11WindowTest::init()
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
{
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
QVERIFY(Test::setupWaylandConnection());
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
}
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
void X11WindowTest::cleanup()
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
{
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
Test::destroyWaylandConnection();
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
}
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
void X11WindowTest::testMinimumSize()
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
{
// This test verifies that the minimum size constraint is correctly applied.
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QFETCH_GLOBAL(qreal, scale);
kwinApp()->setXwaylandScale(scale);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
// Create an xcb window.
Autotests: Use a helper method to create X11 connection
2023-02-03 13:29:21 +00:00
Test::XcbConnectionPtr c = Test::createX11Connection();
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
QVERIFY(!xcb_connection_has_error(c.get()));
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
const QRect windowGeometry(0, 0, 100, 200);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_window_t windowId = xcb_generate_id(c.get());
xcb_create_window(c.get(), XCB_COPY_FROM_PARENT, windowId, rootWindow(),
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
windowGeometry.x(),
windowGeometry.y(),
windowGeometry.width(),
windowGeometry.height(),
0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
xcb_size_hints_t hints;
memset(&hints, 0, sizeof(hints));
xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
xcb_icccm_size_hints_set_min_size(&hints, windowGeometry.width(), windowGeometry.height());
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_icccm_set_wm_normal_hints(c.get(), windowId, &hints);
xcb_map_window(c.get(), windowId);
xcb_flush(c.get());
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QSignalSpy windowCreatedSpy(workspace(), &Workspace::windowAdded);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
QVERIFY(windowCreatedSpy.wait());
autotests: client -> window
2022-04-23 19:51:16 +00:00
X11Window *window = windowCreatedSpy.last().first().value<X11Window *>();
QVERIFY(window);
QVERIFY(window->isDecorated());
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QSignalSpy interactiveMoveResizeStartedSpy(window, &Window::interactiveMoveResizeStarted);
QSignalSpy interactiveMoveResizeSteppedSpy(window, &Window::interactiveMoveResizeStepped);
QSignalSpy interactiveMoveResizeFinishedSpy(window, &Window::interactiveMoveResizeFinished);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QSignalSpy frameGeometryChangedSpy(window, &Window::frameGeometryChanged);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
// Begin resize.
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QCOMPARE(workspace()->moveResizeWindow(), nullptr);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(!window->isInteractiveResize());
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
workspace()->slotWindowResize();
autotests: client -> window
2022-04-23 19:51:16 +00:00
QCOMPARE(workspace()->moveResizeWindow(), window);
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeStartedSpy.count(), 1);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window->isInteractiveResize());
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
cursor: make position, hotspot and size floating point This allows all pixel positions to be used on high dpi screens, and corrects damage tracking with Xwayland cursors CCBUG: 466094
2023-02-19 23:35:44 +00:00
const QPointF cursorPos = KWin::Cursors::self()->mouse()->pos();
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->keyPressEvent(Qt::Key_Left);
window->updateInteractiveMoveResize(KWin::Cursors::self()->mouse()->pos());
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(KWin::Cursors::self()->mouse()->pos(), cursorPos + QPoint(-8, 0));
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeSteppedSpy.count(), 0);
autotests: Make testX11Window quicker Before Executed in 17.39 secs fish external usr time 422.91 millis 1.92 millis 420.99 millis sys time 586.41 millis 0.22 millis 586.19 millis After Executed in 1.23 secs fish external usr time 395.63 millis 0.00 millis 395.63 millis sys time 228.55 millis 2.13 millis 226.42 millis
2023-01-11 21:05:45 +00:00
QVERIFY(!frameGeometryChangedSpy.wait(10));
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QCOMPARE(window->clientSize().width(), 100 / scale);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->keyPressEvent(Qt::Key_Right);
window->updateInteractiveMoveResize(KWin::Cursors::self()->mouse()->pos());
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(KWin::Cursors::self()->mouse()->pos(), cursorPos);
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeSteppedSpy.count(), 0);
autotests: Make testX11Window quicker Before Executed in 17.39 secs fish external usr time 422.91 millis 1.92 millis 420.99 millis sys time 586.41 millis 0.22 millis 586.19 millis After Executed in 1.23 secs fish external usr time 395.63 millis 0.00 millis 395.63 millis sys time 228.55 millis 2.13 millis 226.42 millis
2023-01-11 21:05:45 +00:00
QVERIFY(!frameGeometryChangedSpy.wait(10));
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QCOMPARE(window->clientSize().width(), 100 / scale);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->keyPressEvent(Qt::Key_Right);
window->updateInteractiveMoveResize(KWin::Cursors::self()->mouse()->pos());
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(KWin::Cursors::self()->mouse()->pos(), cursorPos + QPoint(8, 0));
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeSteppedSpy.count(), 1);
Lock clientStepUserMovedResized to move resize geometry changes On Wayland, the move resize geometry and the frame geometry are completely out of sync. This change synchronizes emitting of the clientStepUserMovedResized signal to the move resize geometry changes. It simplifies code of InternalClient and XdgSurfaceClient, and makes adding support for other shell surface protocols easier as there's less boilerplate stuff that you would need to take care of.
2021-12-24 09:20:00 +00:00
QVERIFY(frameGeometryChangedSpy.wait());
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
// whilst X11 window size goes through scale, the increment is a logical value kwin side
QCOMPARE(window->clientSize().width(), 100 / scale + 8);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->keyPressEvent(Qt::Key_Up);
window->updateInteractiveMoveResize(KWin::Cursors::self()->mouse()->pos());
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(KWin::Cursors::self()->mouse()->pos(), cursorPos + QPoint(8, -8));
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeSteppedSpy.count(), 1);
autotests: Make testX11Window quicker Before Executed in 17.39 secs fish external usr time 422.91 millis 1.92 millis 420.99 millis sys time 586.41 millis 0.22 millis 586.19 millis After Executed in 1.23 secs fish external usr time 395.63 millis 0.00 millis 395.63 millis sys time 228.55 millis 2.13 millis 226.42 millis
2023-01-11 21:05:45 +00:00
QVERIFY(!frameGeometryChangedSpy.wait(10));
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QCOMPARE(window->clientSize().height(), 200 / scale);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->keyPressEvent(Qt::Key_Down);
window->updateInteractiveMoveResize(KWin::Cursors::self()->mouse()->pos());
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(KWin::Cursors::self()->mouse()->pos(), cursorPos + QPoint(8, 0));
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeSteppedSpy.count(), 1);
autotests: Make testX11Window quicker Before Executed in 17.39 secs fish external usr time 422.91 millis 1.92 millis 420.99 millis sys time 586.41 millis 0.22 millis 586.19 millis After Executed in 1.23 secs fish external usr time 395.63 millis 0.00 millis 395.63 millis sys time 228.55 millis 2.13 millis 226.42 millis
2023-01-11 21:05:45 +00:00
QVERIFY(!frameGeometryChangedSpy.wait(10));
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QCOMPARE(window->clientSize().height(), 200 / scale);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->keyPressEvent(Qt::Key_Down);
window->updateInteractiveMoveResize(KWin::Cursors::self()->mouse()->pos());
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(KWin::Cursors::self()->mouse()->pos(), cursorPos + QPoint(8, 8));
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeSteppedSpy.count(), 2);
Lock clientStepUserMovedResized to move resize geometry changes On Wayland, the move resize geometry and the frame geometry are completely out of sync. This change synchronizes emitting of the clientStepUserMovedResized signal to the move resize geometry changes. It simplifies code of InternalClient and XdgSurfaceClient, and makes adding support for other shell surface protocols easier as there's less boilerplate stuff that you would need to take care of.
2021-12-24 09:20:00 +00:00
QVERIFY(frameGeometryChangedSpy.wait());
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QCOMPARE(window->clientSize().height(), 200 / scale + 8);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
// Finish the resize operation.
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeFinishedSpy.count(), 0);
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->keyPressEvent(Qt::Key_Enter);
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeFinishedSpy.count(), 1);
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QCOMPARE(workspace()->moveResizeWindow(), nullptr);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(!window->isInteractiveResize());
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
// Destroy the window.
Tidy Window::windowClosed() signal "window" is redundant, so remove it. Also remove the original window argument to improve the API consistency.
2023-03-13 19:21:11 +00:00
QSignalSpy windowClosedSpy(window, &X11Window::closed);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_unmap_window(c.get(), windowId);
xcb_destroy_window(c.get(), windowId);
xcb_flush(c.get());
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
QVERIFY(windowClosedSpy.wait());
c.reset();
}
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
void X11WindowTest::testMaximumSize()
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
{
// This test verifies that the maximum size constraint is correctly applied.
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QFETCH_GLOBAL(qreal, scale);
kwinApp()->setXwaylandScale(scale);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
// Create an xcb window.
Autotests: Use a helper method to create X11 connection
2023-02-03 13:29:21 +00:00
Test::XcbConnectionPtr c = Test::createX11Connection();
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
QVERIFY(!xcb_connection_has_error(c.get()));
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
const QRect windowGeometry(0, 0, 100, 200);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_window_t windowId = xcb_generate_id(c.get());
xcb_create_window(c.get(), XCB_COPY_FROM_PARENT, windowId, rootWindow(),
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
windowGeometry.x(),
windowGeometry.y(),
windowGeometry.width(),
windowGeometry.height(),
0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
xcb_size_hints_t hints;
memset(&hints, 0, sizeof(hints));
xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
xcb_icccm_size_hints_set_max_size(&hints, windowGeometry.width(), windowGeometry.height());
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_icccm_set_wm_normal_hints(c.get(), windowId, &hints);
xcb_map_window(c.get(), windowId);
xcb_flush(c.get());
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QSignalSpy windowCreatedSpy(workspace(), &Workspace::windowAdded);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
QVERIFY(windowCreatedSpy.wait());
autotests: client -> window
2022-04-23 19:51:16 +00:00
X11Window *window = windowCreatedSpy.last().first().value<X11Window *>();
QVERIFY(window);
QVERIFY(window->isDecorated());
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QSignalSpy interactiveMoveResizeStartedSpy(window, &Window::interactiveMoveResizeStarted);
QSignalSpy interactiveMoveResizeSteppedSpy(window, &Window::interactiveMoveResizeStepped);
QSignalSpy interactiveMoveResizeFinishedSpy(window, &Window::interactiveMoveResizeFinished);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QSignalSpy frameGeometryChangedSpy(window, &Window::frameGeometryChanged);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
// Begin resize.
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QCOMPARE(workspace()->moveResizeWindow(), nullptr);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(!window->isInteractiveResize());
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
workspace()->slotWindowResize();
autotests: client -> window
2022-04-23 19:51:16 +00:00
QCOMPARE(workspace()->moveResizeWindow(), window);
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeStartedSpy.count(), 1);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window->isInteractiveResize());
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
cursor: make position, hotspot and size floating point This allows all pixel positions to be used on high dpi screens, and corrects damage tracking with Xwayland cursors CCBUG: 466094
2023-02-19 23:35:44 +00:00
const QPointF cursorPos = KWin::Cursors::self()->mouse()->pos();
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->keyPressEvent(Qt::Key_Right);
window->updateInteractiveMoveResize(KWin::Cursors::self()->mouse()->pos());
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(KWin::Cursors::self()->mouse()->pos(), cursorPos + QPoint(8, 0));
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeSteppedSpy.count(), 0);
autotests: Make testX11Window quicker Before Executed in 17.39 secs fish external usr time 422.91 millis 1.92 millis 420.99 millis sys time 586.41 millis 0.22 millis 586.19 millis After Executed in 1.23 secs fish external usr time 395.63 millis 0.00 millis 395.63 millis sys time 228.55 millis 2.13 millis 226.42 millis
2023-01-11 21:05:45 +00:00
QVERIFY(!frameGeometryChangedSpy.wait(10));
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QCOMPARE(window->clientSize().width(), 100 / scale);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->keyPressEvent(Qt::Key_Left);
window->updateInteractiveMoveResize(KWin::Cursors::self()->mouse()->pos());
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(KWin::Cursors::self()->mouse()->pos(), cursorPos);
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QVERIFY(!interactiveMoveResizeSteppedSpy.wait(10));
QCOMPARE(interactiveMoveResizeSteppedSpy.count(), 0);
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QCOMPARE(window->clientSize().width(), 100 / scale);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->keyPressEvent(Qt::Key_Left);
window->updateInteractiveMoveResize(KWin::Cursors::self()->mouse()->pos());
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(KWin::Cursors::self()->mouse()->pos(), cursorPos + QPoint(-8, 0));
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeSteppedSpy.count(), 1);
Lock clientStepUserMovedResized to move resize geometry changes On Wayland, the move resize geometry and the frame geometry are completely out of sync. This change synchronizes emitting of the clientStepUserMovedResized signal to the move resize geometry changes. It simplifies code of InternalClient and XdgSurfaceClient, and makes adding support for other shell surface protocols easier as there's less boilerplate stuff that you would need to take care of.
2021-12-24 09:20:00 +00:00
QVERIFY(frameGeometryChangedSpy.wait());
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QCOMPARE(window->clientSize().width(), 100 / scale - 8);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->keyPressEvent(Qt::Key_Down);
window->updateInteractiveMoveResize(KWin::Cursors::self()->mouse()->pos());
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(KWin::Cursors::self()->mouse()->pos(), cursorPos + QPoint(-8, 8));
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeSteppedSpy.count(), 1);
autotests: Make testX11Window quicker Before Executed in 17.39 secs fish external usr time 422.91 millis 1.92 millis 420.99 millis sys time 586.41 millis 0.22 millis 586.19 millis After Executed in 1.23 secs fish external usr time 395.63 millis 0.00 millis 395.63 millis sys time 228.55 millis 2.13 millis 226.42 millis
2023-01-11 21:05:45 +00:00
QVERIFY(!frameGeometryChangedSpy.wait(10));
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QCOMPARE(window->clientSize().height(), 200 / scale);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->keyPressEvent(Qt::Key_Up);
window->updateInteractiveMoveResize(KWin::Cursors::self()->mouse()->pos());
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(KWin::Cursors::self()->mouse()->pos(), cursorPos + QPoint(-8, 0));
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeSteppedSpy.count(), 1);
autotests: Make testX11Window quicker Before Executed in 17.39 secs fish external usr time 422.91 millis 1.92 millis 420.99 millis sys time 586.41 millis 0.22 millis 586.19 millis After Executed in 1.23 secs fish external usr time 395.63 millis 0.00 millis 395.63 millis sys time 228.55 millis 2.13 millis 226.42 millis
2023-01-11 21:05:45 +00:00
QVERIFY(!frameGeometryChangedSpy.wait(10));
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QCOMPARE(window->clientSize().height(), 200 / scale);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->keyPressEvent(Qt::Key_Up);
window->updateInteractiveMoveResize(KWin::Cursors::self()->mouse()->pos());
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(KWin::Cursors::self()->mouse()->pos(), cursorPos + QPoint(-8, -8));
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeSteppedSpy.count(), 2);
Lock clientStepUserMovedResized to move resize geometry changes On Wayland, the move resize geometry and the frame geometry are completely out of sync. This change synchronizes emitting of the clientStepUserMovedResized signal to the move resize geometry changes. It simplifies code of InternalClient and XdgSurfaceClient, and makes adding support for other shell surface protocols easier as there's less boilerplate stuff that you would need to take care of.
2021-12-24 09:20:00 +00:00
QVERIFY(frameGeometryChangedSpy.wait());
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QCOMPARE(window->clientSize().height(), 200 / scale - 8);
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
// Finish the resize operation.
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeFinishedSpy.count(), 0);
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->keyPressEvent(Qt::Key_Enter);
Rename interactive move resize lifecycle signals Add the "interactive" word to be consistent and put "started", "stepped", and "finished" at the end of signal names where they are more expected.
2023-02-18 11:38:08 +00:00
QCOMPARE(interactiveMoveResizeFinishedSpy.count(), 1);
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QCOMPARE(workspace()->moveResizeWindow(), nullptr);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(!window->isInteractiveResize());
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
// Destroy the window.
Tidy Window::windowClosed() signal "window" is redundant, so remove it. Also remove the original window argument to improve the API consistency.
2023-03-13 19:21:11 +00:00
QSignalSpy windowClosedSpy(window, &X11Window::closed);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_unmap_window(c.get(), windowId);
xcb_destroy_window(c.get(), windowId);
xcb_flush(c.get());
[autotests] Add tests for PMinSize, PMaxSize, and PResizeInc geometry hints Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D27400
2020-02-14 11:59:58 +00:00
QVERIFY(windowClosedSpy.wait());
c.reset();
}
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
void X11WindowTest::testTrimCaption_data()
Fix captions with non-BMP characters KWin replaces any non-printable character with a space. This check does not handle surrogate pairs correctly. Additionally, translators sometimes insert non-printable soft-hyphens into titles, which also cause KWin to display a space instead. This code adds the missing surrogate handling, and (to fix both issues), also removes non-printable characters instead of replacing them with a space. Also moved the changed test after these changes, so that changes in non- printable characters do not cause unneeded redraws. Unit tests adapted by Vlad Zagorodniy. Test Plan: kwrite /tmp/Test😣.txt shows correct title. I also tested actual non-printable characters, such as 0x1A, and these are correctly omitted. BUG: 376813 FIXED-IN: 5.15.5 Reviewers: #kwin, zzag Reviewed By: #kwin, zzag Subscribers: zzag, grasslin, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D19052
2019-04-26 08:52:57 +00:00
{
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QFETCH_GLOBAL(qreal, scale);
kwinApp()->setXwaylandScale(scale);
Fix captions with non-BMP characters KWin replaces any non-printable character with a space. This check does not handle surrogate pairs correctly. Additionally, translators sometimes insert non-printable soft-hyphens into titles, which also cause KWin to display a space instead. This code adds the missing surrogate handling, and (to fix both issues), also removes non-printable characters instead of replacing them with a space. Also moved the changed test after these changes, so that changes in non- printable characters do not cause unneeded redraws. Unit tests adapted by Vlad Zagorodniy. Test Plan: kwrite /tmp/Test😣.txt shows correct title. I also tested actual non-printable characters, such as 0x1A, and these are correctly omitted. BUG: 376813 FIXED-IN: 5.15.5 Reviewers: #kwin, zzag Reviewed By: #kwin, zzag Subscribers: zzag, grasslin, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D19052
2019-04-26 08:52:57 +00:00
QTest::addColumn<QByteArray>("originalTitle");
QTest::addColumn<QByteArray>("expectedTitle");
QTest::newRow("simplified")
<< QByteArrayLiteral("Was tun, wenn Schüler Autismus haben?\342\200\250\342\200\250\342\200\250 – Marlies Hübner - Mozilla Firefox")
<< QByteArrayLiteral("Was tun, wenn Schüler Autismus haben? – Marlies Hübner - Mozilla Firefox");
QTest::newRow("with emojis")
<< QByteArrayLiteral("\bTesting non\302\255printable:\177, emoij:\360\237\230\203, non-characters:\357\277\276")
<< QByteArrayLiteral("Testing nonprintable:, emoij:\360\237\230\203, non-characters:");
}
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
void X11WindowTest::testTrimCaption()
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
{
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QFETCH_GLOBAL(qreal, scale);
kwinApp()->setXwaylandScale(scale);
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
// this test verifies that caption is properly trimmed
// create an xcb window
Autotests: Use a helper method to create X11 connection
2023-02-03 13:29:21 +00:00
Test::XcbConnectionPtr c = Test::createX11Connection();
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
QVERIFY(!xcb_connection_has_error(c.get()));
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
const QRect windowGeometry(0, 0, 100, 200);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_window_t windowId = xcb_generate_id(c.get());
xcb_create_window(c.get(), XCB_COPY_FROM_PARENT, windowId, rootWindow(),
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
windowGeometry.x(),
windowGeometry.y(),
windowGeometry.width(),
windowGeometry.height(),
0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
xcb_size_hints_t hints;
memset(&hints, 0, sizeof(hints));
xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_icccm_set_wm_normal_hints(c.get(), windowId, &hints);
NETWinInfo winInfo(c.get(), windowId, rootWindow(), NET::Properties(), NET::Properties2());
Fix captions with non-BMP characters KWin replaces any non-printable character with a space. This check does not handle surrogate pairs correctly. Additionally, translators sometimes insert non-printable soft-hyphens into titles, which also cause KWin to display a space instead. This code adds the missing surrogate handling, and (to fix both issues), also removes non-printable characters instead of replacing them with a space. Also moved the changed test after these changes, so that changes in non- printable characters do not cause unneeded redraws. Unit tests adapted by Vlad Zagorodniy. Test Plan: kwrite /tmp/Test😣.txt shows correct title. I also tested actual non-printable characters, such as 0x1A, and these are correctly omitted. BUG: 376813 FIXED-IN: 5.15.5 Reviewers: #kwin, zzag Reviewed By: #kwin, zzag Subscribers: zzag, grasslin, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D19052
2019-04-26 08:52:57 +00:00
QFETCH(QByteArray, originalTitle);
winInfo.setName(originalTitle);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_map_window(c.get(), windowId);
xcb_flush(c.get());
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
// we should get a window for it
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QSignalSpy windowCreatedSpy(workspace(), &Workspace::windowAdded);
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
QVERIFY(windowCreatedSpy.wait());
autotests: client -> window
2022-04-23 19:51:16 +00:00
X11Window *window = windowCreatedSpy.first().first().value<X11Window *>();
QVERIFY(window);
QCOMPARE(window->window(), windowId);
Fix captions with non-BMP characters KWin replaces any non-printable character with a space. This check does not handle surrogate pairs correctly. Additionally, translators sometimes insert non-printable soft-hyphens into titles, which also cause KWin to display a space instead. This code adds the missing surrogate handling, and (to fix both issues), also removes non-printable characters instead of replacing them with a space. Also moved the changed test after these changes, so that changes in non- printable characters do not cause unneeded redraws. Unit tests adapted by Vlad Zagorodniy. Test Plan: kwrite /tmp/Test😣.txt shows correct title. I also tested actual non-printable characters, such as 0x1A, and these are correctly omitted. BUG: 376813 FIXED-IN: 5.15.5 Reviewers: #kwin, zzag Reviewed By: #kwin, zzag Subscribers: zzag, grasslin, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D19052
2019-04-26 08:52:57 +00:00
QFETCH(QByteArray, expectedTitle);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QCOMPARE(window->caption(), QString::fromUtf8(expectedTitle));
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
// and destroy the window again
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_unmap_window(c.get(), windowId);
xcb_flush(c.get());
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
Tidy Window::windowClosed() signal "window" is redundant, so remove it. Also remove the original window argument to improve the API consistency.
2023-03-13 19:21:11 +00:00
QSignalSpy windowClosedSpy(window, &X11Window::closed);
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
QVERIFY(windowClosedSpy.wait());
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_destroy_window(c.get(), windowId);
[autotest] Add test case for window caption need to be simplified The test illustrates that special characters like a line break are not removed from the window caption, which results in a line break added in the window decoration. Test case uses a title from a web page triggering it in Firefox. CCBUG: 323798
2016-10-31 14:50:14 +00:00
c.reset();
}
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
void X11WindowTest::testFullscreenLayerWithActiveWaylandWindow()
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
{
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QFETCH_GLOBAL(qreal, scale);
kwinApp()->setXwaylandScale(scale);
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
// this test verifies that an X11 fullscreen window does not stay in the active layer
// when a Wayland window is active, see BUG: 375759
Make Workspace track managed outputs This change adjusts the window management abstractions in kwin for the drm backend providing more than just "desktop" outputs. Besides that, it has other potential benefits - for example, the Workspace could start managing allocation of the placeholder output by itself, thus leading to some simplifications in the drm backend. Another is that it lets us move wayland code from the drm backend.
2022-07-11 10:41:15 +00:00
QCOMPARE(workspace()->outputs().count(), 1);
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
// first create an X11 window
Autotests: Use a helper method to create X11 connection
2023-02-03 13:29:21 +00:00
Test::XcbConnectionPtr c = Test::createX11Connection();
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
QVERIFY(!xcb_connection_has_error(c.get()));
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
const QRect windowGeometry(0, 0, 100, 200);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_window_t windowId = xcb_generate_id(c.get());
xcb_create_window(c.get(), XCB_COPY_FROM_PARENT, windowId, rootWindow(),
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
windowGeometry.x(),
windowGeometry.y(),
windowGeometry.width(),
windowGeometry.height(),
0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
xcb_size_hints_t hints;
memset(&hints, 0, sizeof(hints));
xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_icccm_set_wm_normal_hints(c.get(), windowId, &hints);
xcb_map_window(c.get(), windowId);
xcb_flush(c.get());
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
// we should get a window for it
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QSignalSpy windowCreatedSpy(workspace(), &Workspace::windowAdded);
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
QVERIFY(windowCreatedSpy.wait());
autotests: client -> window
2022-04-23 19:51:16 +00:00
X11Window *window = windowCreatedSpy.first().first().value<X11Window *>();
QVERIFY(window);
QCOMPARE(window->window(), windowId);
QVERIFY(!window->isFullScreen());
QVERIFY(window->isActive());
QCOMPARE(window->layer(), NormalLayer);
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
workspace()->slotWindowFullScreen();
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window->isFullScreen());
QCOMPARE(window->layer(), ActiveLayer);
QCOMPARE(workspace()->stackingOrder().last(), window);
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
// now let's open a Wayland window
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
auto waylandWindow = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(waylandWindow);
QVERIFY(waylandWindow->isActive());
QCOMPARE(waylandWindow->layer(), NormalLayer);
QCOMPARE(workspace()->stackingOrder().last(), waylandWindow);
QCOMPARE(workspace()->stackingOrder().last(), waylandWindow);
QCOMPARE(window->layer(), NormalLayer);
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
// now activate fullscreen again
autotests: client -> window
2022-04-23 19:51:16 +00:00
workspace()->activateWindow(window);
QTRY_VERIFY(window->isActive());
QCOMPARE(window->layer(), ActiveLayer);
QCOMPARE(workspace()->stackingOrder().last(), window);
QCOMPARE(workspace()->stackingOrder().last(), window);
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
// activate wayland window again
autotests: client -> window
2022-04-23 19:51:16 +00:00
workspace()->activateWindow(waylandWindow);
QTRY_VERIFY(waylandWindow->isActive());
QCOMPARE(workspace()->stackingOrder().last(), waylandWindow);
QCOMPARE(workspace()->stackingOrder().last(), waylandWindow);
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
[autotests] Extend X11ClientTest::testFullscreenLayerWithActiveWaylandWindow Unfortunately still doesn't trigger the actual bug.
2017-07-23 18:02:57 +00:00
// back to x window
autotests: client -> window
2022-04-23 19:51:16 +00:00
workspace()->activateWindow(window);
QTRY_VERIFY(window->isActive());
[autotests] Extend X11ClientTest::testFullscreenLayerWithActiveWaylandWindow Unfortunately still doesn't trigger the actual bug.
2017-07-23 18:02:57 +00:00
// remove fullscreen
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window->isFullScreen());
[autotests] Extend X11ClientTest::testFullscreenLayerWithActiveWaylandWindow Unfortunately still doesn't trigger the actual bug.
2017-07-23 18:02:57 +00:00
workspace()->slotWindowFullScreen();
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(!window->isFullScreen());
[autotests] Extend X11ClientTest::testFullscreenLayerWithActiveWaylandWindow Unfortunately still doesn't trigger the actual bug.
2017-07-23 18:02:57 +00:00
// and fullscreen again
workspace()->slotWindowFullScreen();
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window->isFullScreen());
QCOMPARE(workspace()->stackingOrder().last(), window);
QCOMPARE(workspace()->stackingOrder().last(), window);
[autotests] Extend X11ClientTest::testFullscreenLayerWithActiveWaylandWindow Unfortunately still doesn't trigger the actual bug.
2017-07-23 18:02:57 +00:00
// activate wayland window again
autotests: client -> window
2022-04-23 19:51:16 +00:00
workspace()->activateWindow(waylandWindow);
QTRY_VERIFY(waylandWindow->isActive());
QCOMPARE(workspace()->stackingOrder().last(), waylandWindow);
QCOMPARE(workspace()->stackingOrder().last(), waylandWindow);
[autotests] Extend X11ClientTest::testFullscreenLayerWithActiveWaylandWindow Unfortunately still doesn't trigger the actual bug.
2017-07-23 18:02:57 +00:00
// back to X11 window
autotests: client -> window
2022-04-23 19:51:16 +00:00
workspace()->activateWindow(window);
QTRY_VERIFY(window->isActive());
[autotests] Extend X11ClientTest::testFullscreenLayerWithActiveWaylandWindow Unfortunately still doesn't trigger the actual bug.
2017-07-23 18:02:57 +00:00
// remove fullscreen
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window->isFullScreen());
[autotests] Extend X11ClientTest::testFullscreenLayerWithActiveWaylandWindow Unfortunately still doesn't trigger the actual bug.
2017-07-23 18:02:57 +00:00
workspace()->slotWindowFullScreen();
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(!window->isFullScreen());
[autotests] Extend X11ClientTest::testFullscreenLayerWithActiveWaylandWindow Unfortunately still doesn't trigger the actual bug.
2017-07-23 18:02:57 +00:00
// and fullscreen through X API
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
NETWinInfo info(c.get(), windowId, kwinApp()->x11RootWindow(), NET::Properties(), NET::Properties2());
[autotests] Extend X11ClientTest::testFullscreenLayerWithActiveWaylandWindow Unfortunately still doesn't trigger the actual bug.
2017-07-23 18:02:57 +00:00
info.setState(NET::FullScreen, NET::FullScreen);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
NETRootInfo rootInfo(c.get(), NET::Properties());
autotests: client -> window
2022-04-23 19:51:16 +00:00
rootInfo.setActiveWindow(windowId, NET::FromApplication, XCB_CURRENT_TIME, XCB_WINDOW_NONE);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_flush(c.get());
autotests: client -> window
2022-04-23 19:51:16 +00:00
QTRY_VERIFY(window->isFullScreen());
QCOMPARE(workspace()->stackingOrder().last(), window);
QCOMPARE(workspace()->stackingOrder().last(), window);
[autotests] Extend X11ClientTest::testFullscreenLayerWithActiveWaylandWindow Unfortunately still doesn't trigger the actual bug.
2017-07-23 18:02:57 +00:00
// activate wayland window again
autotests: client -> window
2022-04-23 19:51:16 +00:00
workspace()->activateWindow(waylandWindow);
QTRY_VERIFY(waylandWindow->isActive());
QCOMPARE(workspace()->stackingOrder().last(), waylandWindow);
QCOMPARE(workspace()->stackingOrder().last(), waylandWindow);
QCOMPARE(window->layer(), NormalLayer);
[autotests] Extend X11ClientTest::testFullscreenLayerWithActiveWaylandWindow Unfortunately still doesn't trigger the actual bug.
2017-07-23 18:02:57 +00:00
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
// close the window
shellSurface.reset();
surface.reset();
autotests: Fix Test::waitForWindowDestroyed Before Deleted merge, it used to be equivalent to waiting until the window is closed. This fixes tests waiting until the window closing animation completes and the Window object is destroyed.
2023-04-21 20:28:48 +00:00
QVERIFY(Test::waitForWindowClosed(waylandWindow));
autotests: client -> window
2022-04-23 19:51:16 +00:00
QTRY_VERIFY(window->isActive());
QCOMPARE(window->layer(), ActiveLayer);
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
// and destroy the window again
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_unmap_window(c.get(), windowId);
xcb_flush(c.get());
[autotest] Add a test case for X11 fullscreen windows when an Wayland window is there KWin cannot handle the layering correctly when a Wayland window is active and there is a fullscreen X11 window. This test tries to simulate the situation, but it does not show it. Nevertheless it's a good test, so let's add it. CCBUG: 375759
2017-07-23 09:50:58 +00:00
}
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
void X11WindowTest::testFocusInWithWaylandLastActiveWindow()
Reset last_active_client when a ShellClient is removed Summary: The last_active_client is set when an AbstractClient gets activated. For the X11 case the last_active_client was getting reset to nullptr when the last_active_client gets destroyed. But for the ShellClient that did not yet happen. This could result in a crash. This change addresses the problem and adds a test case which triggered the crash. The condition of the crash are difficult to generate though - it took me about an hour to write the test for the crash. 1. Wayland client must be active 2. Explicit focus to null (no active client) 3. destroy Wayland window 4. X11 client which sets focus on itself without interaction with window manager Test Plan: test case no longer crashes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D6852
2017-07-23 14:18:09 +00:00
{
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
// this test verifies that Workspace::allowWindowActivation does not crash if last client was a Wayland client
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QFETCH_GLOBAL(qreal, scale);
kwinApp()->setXwaylandScale(scale);
Reset last_active_client when a ShellClient is removed Summary: The last_active_client is set when an AbstractClient gets activated. For the X11 case the last_active_client was getting reset to nullptr when the last_active_client gets destroyed. But for the ShellClient that did not yet happen. This could result in a crash. This change addresses the problem and adds a test case which triggered the crash. The condition of the crash are difficult to generate though - it took me about an hour to write the test for the crash. 1. Wayland client must be active 2. Explicit focus to null (no active client) 3. destroy Wayland window 4. X11 client which sets focus on itself without interaction with window manager Test Plan: test case no longer crashes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D6852
2017-07-23 14:18:09 +00:00
// create an X11 window
Autotests: Use a helper method to create X11 connection
2023-02-03 13:29:21 +00:00
Test::XcbConnectionPtr c = Test::createX11Connection();
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
QVERIFY(!xcb_connection_has_error(c.get()));
Reset last_active_client when a ShellClient is removed Summary: The last_active_client is set when an AbstractClient gets activated. For the X11 case the last_active_client was getting reset to nullptr when the last_active_client gets destroyed. But for the ShellClient that did not yet happen. This could result in a crash. This change addresses the problem and adds a test case which triggered the crash. The condition of the crash are difficult to generate though - it took me about an hour to write the test for the crash. 1. Wayland client must be active 2. Explicit focus to null (no active client) 3. destroy Wayland window 4. X11 client which sets focus on itself without interaction with window manager Test Plan: test case no longer crashes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D6852
2017-07-23 14:18:09 +00:00
const QRect windowGeometry(0, 0, 100, 200);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_window_t windowId = xcb_generate_id(c.get());
xcb_create_window(c.get(), XCB_COPY_FROM_PARENT, windowId, rootWindow(),
Reset last_active_client when a ShellClient is removed Summary: The last_active_client is set when an AbstractClient gets activated. For the X11 case the last_active_client was getting reset to nullptr when the last_active_client gets destroyed. But for the ShellClient that did not yet happen. This could result in a crash. This change addresses the problem and adds a test case which triggered the crash. The condition of the crash are difficult to generate though - it took me about an hour to write the test for the crash. 1. Wayland client must be active 2. Explicit focus to null (no active client) 3. destroy Wayland window 4. X11 client which sets focus on itself without interaction with window manager Test Plan: test case no longer crashes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D6852
2017-07-23 14:18:09 +00:00
windowGeometry.x(),
windowGeometry.y(),
windowGeometry.width(),
windowGeometry.height(),
0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
xcb_size_hints_t hints;
memset(&hints, 0, sizeof(hints));
xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_icccm_set_wm_normal_hints(c.get(), windowId, &hints);
xcb_map_window(c.get(), windowId);
xcb_flush(c.get());
Reset last_active_client when a ShellClient is removed Summary: The last_active_client is set when an AbstractClient gets activated. For the X11 case the last_active_client was getting reset to nullptr when the last_active_client gets destroyed. But for the ShellClient that did not yet happen. This could result in a crash. This change addresses the problem and adds a test case which triggered the crash. The condition of the crash are difficult to generate though - it took me about an hour to write the test for the crash. 1. Wayland client must be active 2. Explicit focus to null (no active client) 3. destroy Wayland window 4. X11 client which sets focus on itself without interaction with window manager Test Plan: test case no longer crashes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D6852
2017-07-23 14:18:09 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
// we should get a window for it
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QSignalSpy windowCreatedSpy(workspace(), &Workspace::windowAdded);
Reset last_active_client when a ShellClient is removed Summary: The last_active_client is set when an AbstractClient gets activated. For the X11 case the last_active_client was getting reset to nullptr when the last_active_client gets destroyed. But for the ShellClient that did not yet happen. This could result in a crash. This change addresses the problem and adds a test case which triggered the crash. The condition of the crash are difficult to generate though - it took me about an hour to write the test for the crash. 1. Wayland client must be active 2. Explicit focus to null (no active client) 3. destroy Wayland window 4. X11 client which sets focus on itself without interaction with window manager Test Plan: test case no longer crashes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D6852
2017-07-23 14:18:09 +00:00
QVERIFY(windowCreatedSpy.wait());
autotests: client -> window
2022-04-23 19:51:16 +00:00
X11Window *window = windowCreatedSpy.first().first().value<X11Window *>();
QVERIFY(window);
QCOMPARE(window->window(), windowId);
QVERIFY(window->isActive());
Reset last_active_client when a ShellClient is removed Summary: The last_active_client is set when an AbstractClient gets activated. For the X11 case the last_active_client was getting reset to nullptr when the last_active_client gets destroyed. But for the ShellClient that did not yet happen. This could result in a crash. This change addresses the problem and adds a test case which triggered the crash. The condition of the crash are difficult to generate though - it took me about an hour to write the test for the crash. 1. Wayland client must be active 2. Explicit focus to null (no active client) 3. destroy Wayland window 4. X11 client which sets focus on itself without interaction with window manager Test Plan: test case no longer crashes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D6852
2017-07-23 14:18:09 +00:00
// create Wayland window
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
auto waylandWindow = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(waylandWindow);
QVERIFY(waylandWindow->isActive());
Reset last_active_client when a ShellClient is removed Summary: The last_active_client is set when an AbstractClient gets activated. For the X11 case the last_active_client was getting reset to nullptr when the last_active_client gets destroyed. But for the ShellClient that did not yet happen. This could result in a crash. This change addresses the problem and adds a test case which triggered the crash. The condition of the crash are difficult to generate though - it took me about an hour to write the test for the crash. 1. Wayland client must be active 2. Explicit focus to null (no active client) 3. destroy Wayland window 4. X11 client which sets focus on itself without interaction with window manager Test Plan: test case no longer crashes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D6852
2017-07-23 14:18:09 +00:00
// activate no window
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
workspace()->setActiveWindow(nullptr);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(!waylandWindow->isActive());
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QVERIFY(!workspace()->activeWindow());
Reset last_active_client when a ShellClient is removed Summary: The last_active_client is set when an AbstractClient gets activated. For the X11 case the last_active_client was getting reset to nullptr when the last_active_client gets destroyed. But for the ShellClient that did not yet happen. This could result in a crash. This change addresses the problem and adds a test case which triggered the crash. The condition of the crash are difficult to generate though - it took me about an hour to write the test for the crash. 1. Wayland client must be active 2. Explicit focus to null (no active client) 3. destroy Wayland window 4. X11 client which sets focus on itself without interaction with window manager Test Plan: test case no longer crashes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D6852
2017-07-23 14:18:09 +00:00
// and close Wayland window again
shellSurface.reset();
surface.reset();
autotests: Fix Test::waitForWindowDestroyed Before Deleted merge, it used to be equivalent to waiting until the window is closed. This fixes tests waiting until the window closing animation completes and the Window object is destroyed.
2023-04-21 20:28:48 +00:00
QVERIFY(Test::waitForWindowClosed(waylandWindow));
Reset last_active_client when a ShellClient is removed Summary: The last_active_client is set when an AbstractClient gets activated. For the X11 case the last_active_client was getting reset to nullptr when the last_active_client gets destroyed. But for the ShellClient that did not yet happen. This could result in a crash. This change addresses the problem and adds a test case which triggered the crash. The condition of the crash are difficult to generate though - it took me about an hour to write the test for the crash. 1. Wayland client must be active 2. Explicit focus to null (no active client) 3. destroy Wayland window 4. X11 client which sets focus on itself without interaction with window manager Test Plan: test case no longer crashes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D6852
2017-07-23 14:18:09 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
// and try to activate the x11 window through X11 api
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
const auto cookie = xcb_set_input_focus_checked(c.get(), XCB_INPUT_FOCUS_NONE, windowId, XCB_CURRENT_TIME);
auto error = xcb_request_check(c.get(), cookie);
Reset last_active_client when a ShellClient is removed Summary: The last_active_client is set when an AbstractClient gets activated. For the X11 case the last_active_client was getting reset to nullptr when the last_active_client gets destroyed. But for the ShellClient that did not yet happen. This could result in a crash. This change addresses the problem and adds a test case which triggered the crash. The condition of the crash are difficult to generate though - it took me about an hour to write the test for the crash. 1. Wayland client must be active 2. Explicit focus to null (no active client) 3. destroy Wayland window 4. X11 client which sets focus on itself without interaction with window manager Test Plan: test case no longer crashes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D6852
2017-07-23 14:18:09 +00:00
QVERIFY(!error);
autotests: client -> window
2022-04-23 19:51:16 +00:00
// this accesses m_lastActiveWindow on trying to activate
QTRY_VERIFY(window->isActive());
Reset last_active_client when a ShellClient is removed Summary: The last_active_client is set when an AbstractClient gets activated. For the X11 case the last_active_client was getting reset to nullptr when the last_active_client gets destroyed. But for the ShellClient that did not yet happen. This could result in a crash. This change addresses the problem and adds a test case which triggered the crash. The condition of the crash are difficult to generate though - it took me about an hour to write the test for the crash. 1. Wayland client must be active 2. Explicit focus to null (no active client) 3. destroy Wayland window 4. X11 client which sets focus on itself without interaction with window manager Test Plan: test case no longer crashes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D6852
2017-07-23 14:18:09 +00:00
// and destroy the window again
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_unmap_window(c.get(), windowId);
xcb_flush(c.get());
Reset last_active_client when a ShellClient is removed Summary: The last_active_client is set when an AbstractClient gets activated. For the X11 case the last_active_client was getting reset to nullptr when the last_active_client gets destroyed. But for the ShellClient that did not yet happen. This could result in a crash. This change addresses the problem and adds a test case which triggered the crash. The condition of the crash are difficult to generate though - it took me about an hour to write the test for the crash. 1. Wayland client must be active 2. Explicit focus to null (no active client) 3. destroy Wayland window 4. X11 client which sets focus on itself without interaction with window manager Test Plan: test case no longer crashes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D6852
2017-07-23 14:18:09 +00:00
}
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
void X11WindowTest::testCaptionChanges()
[autotests] Add test case for updating X11 client captions CCBUG: 383444
2017-08-13 14:52:14 +00:00
{
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QFETCH_GLOBAL(qreal, scale);
kwinApp()->setXwaylandScale(scale);
[autotests] Add test case for updating X11 client captions CCBUG: 383444
2017-08-13 14:52:14 +00:00
// verifies that caption is updated correctly when the X11 window updates it
// BUG: 383444
Autotests: Use a helper method to create X11 connection
2023-02-03 13:29:21 +00:00
Test::XcbConnectionPtr c = Test::createX11Connection();
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
QVERIFY(!xcb_connection_has_error(c.get()));
[autotests] Add test case for updating X11 client captions CCBUG: 383444
2017-08-13 14:52:14 +00:00
const QRect windowGeometry(0, 0, 100, 200);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_window_t windowId = xcb_generate_id(c.get());
xcb_create_window(c.get(), XCB_COPY_FROM_PARENT, windowId, rootWindow(),
[autotests] Add test case for updating X11 client captions CCBUG: 383444
2017-08-13 14:52:14 +00:00
windowGeometry.x(),
windowGeometry.y(),
windowGeometry.width(),
windowGeometry.height(),
0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
xcb_size_hints_t hints;
memset(&hints, 0, sizeof(hints));
xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_icccm_set_wm_normal_hints(c.get(), windowId, &hints);
NETWinInfo info(c.get(), windowId, kwinApp()->x11RootWindow(), NET::Properties(), NET::Properties2());
[autotests] Add test case for updating X11 client captions CCBUG: 383444
2017-08-13 14:52:14 +00:00
info.setName("foo");
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_map_window(c.get(), windowId);
xcb_flush(c.get());
[autotests] Add test case for updating X11 client captions CCBUG: 383444
2017-08-13 14:52:14 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
// we should get a window for it
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QSignalSpy windowCreatedSpy(workspace(), &Workspace::windowAdded);
[autotests] Add test case for updating X11 client captions CCBUG: 383444
2017-08-13 14:52:14 +00:00
QVERIFY(windowCreatedSpy.wait());
autotests: client -> window
2022-04-23 19:51:16 +00:00
X11Window *window = windowCreatedSpy.first().first().value<X11Window *>();
QVERIFY(window);
QCOMPARE(window->window(), windowId);
QCOMPARE(window->caption(), QStringLiteral("foo"));
[autotests] Add test case for updating X11 client captions CCBUG: 383444
2017-08-13 14:52:14 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
QSignalSpy captionChangedSpy(window, &X11Window::captionChanged);
[autotests] Add test case for updating X11 client captions CCBUG: 383444
2017-08-13 14:52:14 +00:00
info.setName("bar");
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_flush(c.get());
[autotests] Add test case for updating X11 client captions CCBUG: 383444
2017-08-13 14:52:14 +00:00
QVERIFY(captionChangedSpy.wait());
autotests: client -> window
2022-04-23 19:51:16 +00:00
QCOMPARE(window->caption(), QStringLiteral("bar"));
[autotests] Add test case for updating X11 client captions CCBUG: 383444
2017-08-13 14:52:14 +00:00
// and destroy the window again
Tidy Window::windowClosed() signal "window" is redundant, so remove it. Also remove the original window argument to improve the API consistency.
2023-03-13 19:21:11 +00:00
QSignalSpy windowClosedSpy(window, &X11Window::closed);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_unmap_window(c.get(), windowId);
xcb_flush(c.get());
[autotests] Add test case for updating X11 client captions CCBUG: 383444
2017-08-13 14:52:14 +00:00
QVERIFY(windowClosedSpy.wait());
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_destroy_window(c.get(), windowId);
[autotests] Add test case for updating X11 client captions CCBUG: 383444
2017-08-13 14:52:14 +00:00
c.reset();
}
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
void X11WindowTest::testCaptionWmName()
Use xcb-icccm to read the name property Summary: The KWindowSystem call which we used doesn't work on Wayland as it's only implemented in the xcb variant and cannot be made available for Wayland in an easy way as it is still XLib based. This change turns the optional XCB-ICCCM dependency in a required one and thus can use the functionality provided by said library to implement what KWindowSystem provided. BUG: 382789 Test Plan: New test case which failed with old code Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7046
2017-08-01 19:28:36 +00:00
{
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QFETCH_GLOBAL(qreal, scale);
kwinApp()->setXwaylandScale(scale);
Use xcb-icccm to read the name property Summary: The KWindowSystem call which we used doesn't work on Wayland as it's only implemented in the xcb variant and cannot be made available for Wayland in an easy way as it is still XLib based. This change turns the optional XCB-ICCCM dependency in a required one and thus can use the functionality provided by said library to implement what KWindowSystem provided. BUG: 382789 Test Plan: New test case which failed with old code Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7046
2017-08-01 19:28:36 +00:00
// this test verifies that a caption set through WM_NAME is read correctly
// open glxgears as that one only uses WM_NAME
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QSignalSpy windowAddedSpy(workspace(), &Workspace::windowAdded);
Use xcb-icccm to read the name property Summary: The KWindowSystem call which we used doesn't work on Wayland as it's only implemented in the xcb variant and cannot be made available for Wayland in an easy way as it is still XLib based. This change turns the optional XCB-ICCCM dependency in a required one and thus can use the functionality provided by said library to implement what KWindowSystem provided. BUG: 382789 Test Plan: New test case which failed with old code Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7046
2017-08-01 19:28:36 +00:00
QProcess glxgears;
Port some tests away from a deprecated QProcess::start() overload
2020-09-10 07:15:31 +00:00
glxgears.setProgram(QStringLiteral("glxgears"));
glxgears.start();
Use xcb-icccm to read the name property Summary: The KWindowSystem call which we used doesn't work on Wayland as it's only implemented in the xcb variant and cannot be made available for Wayland in an easy way as it is still XLib based. This change turns the optional XCB-ICCCM dependency in a required one and thus can use the functionality provided by said library to implement what KWindowSystem provided. BUG: 382789 Test Plan: New test case which failed with old code Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7046
2017-08-01 19:28:36 +00:00
QVERIFY(glxgears.waitForStarted());
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QVERIFY(windowAddedSpy.wait());
QCOMPARE(windowAddedSpy.count(), 1);
Drop Workspace::clientList()
2023-03-21 17:47:58 +00:00
QCOMPARE(workspace()->windows().count(), 1);
Window *glxgearsWindow = workspace()->windows().first();
autotests: client -> window
2022-04-23 19:51:16 +00:00
QCOMPARE(glxgearsWindow->caption(), QStringLiteral("glxgears"));
Use xcb-icccm to read the name property Summary: The KWindowSystem call which we used doesn't work on Wayland as it's only implemented in the xcb variant and cannot be made available for Wayland in an easy way as it is still XLib based. This change turns the optional XCB-ICCCM dependency in a required one and thus can use the functionality provided by said library to implement what KWindowSystem provided. BUG: 382789 Test Plan: New test case which failed with old code Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D7046
2017-08-01 19:28:36 +00:00
glxgears.terminate();
QVERIFY(glxgears.waitForFinished());
}
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
void X11WindowTest::testFullscreenWindowGroups()
[autotests] Add test case for fullscreen window with groups When an X11 window is raised to fullscreen it gets set to active layer. When another window gets activated then it goes back to normal layer. But when a window of the same group gets activated the fullscreen window stays in the active layer. Due to that it is not possible to raise other windows above the fullscreen window. This just adds a test case exposing the problematic area. CCBUG: 388310
2018-01-06 09:45:44 +00:00
{
// this test creates an X11 window and puts it to full screen
// then a second window is created which is in the same window group
// BUG: 388310
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QFETCH_GLOBAL(qreal, scale);
kwinApp()->setXwaylandScale(scale);
Autotests: Use a helper method to create X11 connection
2023-02-03 13:29:21 +00:00
Test::XcbConnectionPtr c = Test::createX11Connection();
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
QVERIFY(!xcb_connection_has_error(c.get()));
[autotests] Add test case for fullscreen window with groups When an X11 window is raised to fullscreen it gets set to active layer. When another window gets activated then it goes back to normal layer. But when a window of the same group gets activated the fullscreen window stays in the active layer. Due to that it is not possible to raise other windows above the fullscreen window. This just adds a test case exposing the problematic area. CCBUG: 388310
2018-01-06 09:45:44 +00:00
const QRect windowGeometry(0, 0, 100, 200);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_window_t windowId = xcb_generate_id(c.get());
xcb_create_window(c.get(), XCB_COPY_FROM_PARENT, windowId, rootWindow(),
[autotests] Add test case for fullscreen window with groups When an X11 window is raised to fullscreen it gets set to active layer. When another window gets activated then it goes back to normal layer. But when a window of the same group gets activated the fullscreen window stays in the active layer. Due to that it is not possible to raise other windows above the fullscreen window. This just adds a test case exposing the problematic area. CCBUG: 388310
2018-01-06 09:45:44 +00:00
windowGeometry.x(),
windowGeometry.y(),
windowGeometry.width(),
windowGeometry.height(),
0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
xcb_size_hints_t hints;
memset(&hints, 0, sizeof(hints));
xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_icccm_set_wm_normal_hints(c.get(), windowId, &hints);
xcb_change_property(c.get(), XCB_PROP_MODE_REPLACE, windowId, atoms->wm_client_leader, XCB_ATOM_WINDOW, 32, 1, &windowId);
xcb_map_window(c.get(), windowId);
xcb_flush(c.get());
[autotests] Add test case for fullscreen window with groups When an X11 window is raised to fullscreen it gets set to active layer. When another window gets activated then it goes back to normal layer. But when a window of the same group gets activated the fullscreen window stays in the active layer. Due to that it is not possible to raise other windows above the fullscreen window. This just adds a test case exposing the problematic area. CCBUG: 388310
2018-01-06 09:45:44 +00:00
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QSignalSpy windowCreatedSpy(workspace(), &Workspace::windowAdded);
[autotests] Add test case for fullscreen window with groups When an X11 window is raised to fullscreen it gets set to active layer. When another window gets activated then it goes back to normal layer. But when a window of the same group gets activated the fullscreen window stays in the active layer. Due to that it is not possible to raise other windows above the fullscreen window. This just adds a test case exposing the problematic area. CCBUG: 388310
2018-01-06 09:45:44 +00:00
QVERIFY(windowCreatedSpy.wait());
autotests: client -> window
2022-04-23 19:51:16 +00:00
X11Window *window = windowCreatedSpy.first().first().value<X11Window *>();
QVERIFY(window);
QCOMPARE(window->window(), windowId);
QCOMPARE(window->isActive(), true);
[autotests] Add test case for fullscreen window with groups When an X11 window is raised to fullscreen it gets set to active layer. When another window gets activated then it goes back to normal layer. But when a window of the same group gets activated the fullscreen window stays in the active layer. Due to that it is not possible to raise other windows above the fullscreen window. This just adds a test case exposing the problematic area. CCBUG: 388310
2018-01-06 09:45:44 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
QCOMPARE(window->isFullScreen(), false);
QCOMPARE(window->layer(), NormalLayer);
[autotests] Add test case for fullscreen window with groups When an X11 window is raised to fullscreen it gets set to active layer. When another window gets activated then it goes back to normal layer. But when a window of the same group gets activated the fullscreen window stays in the active layer. Due to that it is not possible to raise other windows above the fullscreen window. This just adds a test case exposing the problematic area. CCBUG: 388310
2018-01-06 09:45:44 +00:00
workspace()->slotWindowFullScreen();
autotests: client -> window
2022-04-23 19:51:16 +00:00
QCOMPARE(window->isFullScreen(), true);
QCOMPARE(window->layer(), ActiveLayer);
[autotests] Add test case for fullscreen window with groups When an X11 window is raised to fullscreen it gets set to active layer. When another window gets activated then it goes back to normal layer. But when a window of the same group gets activated the fullscreen window stays in the active layer. Due to that it is not possible to raise other windows above the fullscreen window. This just adds a test case exposing the problematic area. CCBUG: 388310
2018-01-06 09:45:44 +00:00
// now let's create a second window
windowCreatedSpy.clear();
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_window_t w2 = xcb_generate_id(c.get());
xcb_create_window(c.get(), XCB_COPY_FROM_PARENT, w2, rootWindow(),
[autotests] Add test case for fullscreen window with groups When an X11 window is raised to fullscreen it gets set to active layer. When another window gets activated then it goes back to normal layer. But when a window of the same group gets activated the fullscreen window stays in the active layer. Due to that it is not possible to raise other windows above the fullscreen window. This just adds a test case exposing the problematic area. CCBUG: 388310
2018-01-06 09:45:44 +00:00
windowGeometry.x(),
windowGeometry.y(),
windowGeometry.width(),
windowGeometry.height(),
0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
xcb_size_hints_t hints2;
memset(&hints2, 0, sizeof(hints2));
xcb_icccm_size_hints_set_position(&hints2, 1, windowGeometry.x(), windowGeometry.y());
xcb_icccm_size_hints_set_size(&hints2, 1, windowGeometry.width(), windowGeometry.height());
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_icccm_set_wm_normal_hints(c.get(), w2, &hints2);
xcb_change_property(c.get(), XCB_PROP_MODE_REPLACE, w2, atoms->wm_client_leader, XCB_ATOM_WINDOW, 32, 1, &windowId);
xcb_map_window(c.get(), w2);
xcb_flush(c.get());
[autotests] Add test case for fullscreen window with groups When an X11 window is raised to fullscreen it gets set to active layer. When another window gets activated then it goes back to normal layer. But when a window of the same group gets activated the fullscreen window stays in the active layer. Due to that it is not possible to raise other windows above the fullscreen window. This just adds a test case exposing the problematic area. CCBUG: 388310
2018-01-06 09:45:44 +00:00
QVERIFY(windowCreatedSpy.wait());
autotests: client -> window
2022-04-23 19:51:16 +00:00
X11Window *window2 = windowCreatedSpy.first().first().value<X11Window *>();
QVERIFY(window2);
QVERIFY(window != window2);
QCOMPARE(window2->window(), w2);
QCOMPARE(window2->isActive(), true);
QCOMPARE(window2->group(), window->group());
// first window should be moved back to normal layer
QCOMPARE(window->isActive(), false);
QCOMPARE(window->isFullScreen(), true);
QCOMPARE(window->layer(), NormalLayer);
Keep fullscreen windows in active layer based on transients not the group Summary: So far a not-active fullscreen X11 window was kept in the active layer if the newly activated window is in the same group (that is same client leader). For example a fullscreen X11 kwrite window is in the active layer if another kwrite window is active. The two kwrite windows obviously don't have anything to do with each other, but are in the same group. This creates problems as it's not possible to raise other windows above the active not-fullscreen kwrite window. E.g. the panel is stacked below. The idea behind the check makes sense: if a fullscreen window opens another window (e.g. a configuration dialog) it should not be put back to normal layer. Thus the check is adjusted whether the new active window is a transient to the fullscreen window. Thus the intention is still the same, but does not cause the problems. As the code now does not need to differentiate between X11 and Wayland windows (group only on X11) the Client specific implementation is removed and the method unvirtual'ed. BUG: 388310 FIXED-IN: 5.12.0 Test Plan: Test passes Reviewers: #kwin, #plasma Subscribers: plasma-devel, kwin Tags: #plasma Differential Revision: https://phabricator.kde.org/D9699
2018-01-06 10:24:31 +00:00
// activating the fullscreen window again, should move it to active layer
autotests: client -> window
2022-04-23 19:51:16 +00:00
workspace()->activateWindow(window);
QTRY_COMPARE(window->layer(), ActiveLayer);
[autotests] Add test case for fullscreen window with groups When an X11 window is raised to fullscreen it gets set to active layer. When another window gets activated then it goes back to normal layer. But when a window of the same group gets activated the fullscreen window stays in the active layer. Due to that it is not possible to raise other windows above the fullscreen window. This just adds a test case exposing the problematic area. CCBUG: 388310
2018-01-06 09:45:44 +00:00
}
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
void X11WindowTest::testActivateFocusedWindow()
[x11] Force FocusIn events for already focused windows Depending on the current focus stealing prevention level, it's possible for kwin to call XSetInputFocus() on a window that already has the input focus. In which case, we won't receive the corresponding FocusIn event and the client will remain inactive from kwin's perspective even though it isn't. In order to work around this issue, we can move the input focus to the null window. By doing so, it's guaranteed that we're going to receive the matching FocusIn event for the client. This commit indirectly fixes a bug where fullscreen games are displayed below panels.
2020-06-16 08:03:25 +00:00
{
// The window manager may call XSetInputFocus() on a window that already has focus, in which
// case no FocusIn event will be generated and the window won't be marked as active. This test
// verifies that we handle that subtle case properly.
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QFETCH_GLOBAL(qreal, scale);
kwinApp()->setXwaylandScale(scale);
Autotests: Use a helper method to create X11 connection
2023-02-03 13:29:21 +00:00
Test::XcbConnectionPtr connection = Test::createX11Connection();
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
QVERIFY(!xcb_connection_has_error(connection.get()));
[x11] Force FocusIn events for already focused windows Depending on the current focus stealing prevention level, it's possible for kwin to call XSetInputFocus() on a window that already has the input focus. In which case, we won't receive the corresponding FocusIn event and the client will remain inactive from kwin's perspective even though it isn't. In order to work around this issue, we can move the input focus to the null window. By doing so, it's guaranteed that we're going to receive the matching FocusIn event for the client. This commit indirectly fixes a bug where fullscreen games are displayed below panels.
2020-06-16 08:03:25 +00:00
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QSignalSpy windowCreatedSpy(workspace(), &Workspace::windowAdded);
[x11] Force FocusIn events for already focused windows Depending on the current focus stealing prevention level, it's possible for kwin to call XSetInputFocus() on a window that already has the input focus. In which case, we won't receive the corresponding FocusIn event and the client will remain inactive from kwin's perspective even though it isn't. In order to work around this issue, we can move the input focus to the null window. By doing so, it's guaranteed that we're going to receive the matching FocusIn event for the client. This commit indirectly fixes a bug where fullscreen games are displayed below panels.
2020-06-16 08:03:25 +00:00
const QRect windowGeometry(0, 0, 100, 200);
xcb_size_hints_t hints;
memset(&hints, 0, sizeof(hints));
xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
// Create the first test window.
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
const xcb_window_t windowId1 = xcb_generate_id(connection.get());
xcb_create_window(connection.get(), XCB_COPY_FROM_PARENT, windowId1, rootWindow(),
[x11] Force FocusIn events for already focused windows Depending on the current focus stealing prevention level, it's possible for kwin to call XSetInputFocus() on a window that already has the input focus. In which case, we won't receive the corresponding FocusIn event and the client will remain inactive from kwin's perspective even though it isn't. In order to work around this issue, we can move the input focus to the null window. By doing so, it's guaranteed that we're going to receive the matching FocusIn event for the client. This commit indirectly fixes a bug where fullscreen games are displayed below panels.
2020-06-16 08:03:25 +00:00
windowGeometry.x(), windowGeometry.y(),
windowGeometry.width(), windowGeometry.height(),
0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_icccm_set_wm_normal_hints(connection.get(), windowId1, &hints);
xcb_change_property(connection.get(), XCB_PROP_MODE_REPLACE, windowId1,
autotests: client -> window
2022-04-23 19:51:16 +00:00
atoms->wm_client_leader, XCB_ATOM_WINDOW, 32, 1, &windowId1);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_map_window(connection.get(), windowId1);
xcb_flush(connection.get());
[x11] Force FocusIn events for already focused windows Depending on the current focus stealing prevention level, it's possible for kwin to call XSetInputFocus() on a window that already has the input focus. In which case, we won't receive the corresponding FocusIn event and the client will remain inactive from kwin's perspective even though it isn't. In order to work around this issue, we can move the input focus to the null window. By doing so, it's guaranteed that we're going to receive the matching FocusIn event for the client. This commit indirectly fixes a bug where fullscreen games are displayed below panels.
2020-06-16 08:03:25 +00:00
QVERIFY(windowCreatedSpy.wait());
autotests: client -> window
2022-04-23 19:51:16 +00:00
X11Window *window1 = windowCreatedSpy.first().first().value<X11Window *>();
QVERIFY(window1);
QCOMPARE(window1->window(), windowId1);
QCOMPARE(window1->isActive(), true);
[x11] Force FocusIn events for already focused windows Depending on the current focus stealing prevention level, it's possible for kwin to call XSetInputFocus() on a window that already has the input focus. In which case, we won't receive the corresponding FocusIn event and the client will remain inactive from kwin's perspective even though it isn't. In order to work around this issue, we can move the input focus to the null window. By doing so, it's guaranteed that we're going to receive the matching FocusIn event for the client. This commit indirectly fixes a bug where fullscreen games are displayed below panels.
2020-06-16 08:03:25 +00:00
// Create the second test window.
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
const xcb_window_t windowId2 = xcb_generate_id(connection.get());
xcb_create_window(connection.get(), XCB_COPY_FROM_PARENT, windowId2, rootWindow(),
[x11] Force FocusIn events for already focused windows Depending on the current focus stealing prevention level, it's possible for kwin to call XSetInputFocus() on a window that already has the input focus. In which case, we won't receive the corresponding FocusIn event and the client will remain inactive from kwin's perspective even though it isn't. In order to work around this issue, we can move the input focus to the null window. By doing so, it's guaranteed that we're going to receive the matching FocusIn event for the client. This commit indirectly fixes a bug where fullscreen games are displayed below panels.
2020-06-16 08:03:25 +00:00
windowGeometry.x(), windowGeometry.y(),
windowGeometry.width(), windowGeometry.height(),
0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_icccm_set_wm_normal_hints(connection.get(), windowId2, &hints);
xcb_change_property(connection.get(), XCB_PROP_MODE_REPLACE, windowId2,
autotests: client -> window
2022-04-23 19:51:16 +00:00
atoms->wm_client_leader, XCB_ATOM_WINDOW, 32, 1, &windowId2);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_map_window(connection.get(), windowId2);
xcb_flush(connection.get());
[x11] Force FocusIn events for already focused windows Depending on the current focus stealing prevention level, it's possible for kwin to call XSetInputFocus() on a window that already has the input focus. In which case, we won't receive the corresponding FocusIn event and the client will remain inactive from kwin's perspective even though it isn't. In order to work around this issue, we can move the input focus to the null window. By doing so, it's guaranteed that we're going to receive the matching FocusIn event for the client. This commit indirectly fixes a bug where fullscreen games are displayed below panels.
2020-06-16 08:03:25 +00:00
QVERIFY(windowCreatedSpy.wait());
autotests: client -> window
2022-04-23 19:51:16 +00:00
X11Window *window2 = windowCreatedSpy.last().first().value<X11Window *>();
QVERIFY(window2);
QCOMPARE(window2->window(), windowId2);
QCOMPARE(window2->isActive(), true);
[x11] Force FocusIn events for already focused windows Depending on the current focus stealing prevention level, it's possible for kwin to call XSetInputFocus() on a window that already has the input focus. In which case, we won't receive the corresponding FocusIn event and the client will remain inactive from kwin's perspective even though it isn't. In order to work around this issue, we can move the input focus to the null window. By doing so, it's guaranteed that we're going to receive the matching FocusIn event for the client. This commit indirectly fixes a bug where fullscreen games are displayed below panels.
2020-06-16 08:03:25 +00:00
// When the second test window is destroyed, the window manager will attempt to activate the
autotests: client -> window
2022-04-23 19:51:16 +00:00
// next window in the focus chain, which is the first window.
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_set_input_focus(connection.get(), XCB_INPUT_FOCUS_POINTER_ROOT, windowId1, XCB_CURRENT_TIME);
xcb_destroy_window(connection.get(), windowId2);
xcb_flush(connection.get());
autotests: Fix Test::waitForWindowDestroyed Before Deleted merge, it used to be equivalent to waiting until the window is closed. This fixes tests waiting until the window closing animation completes and the Window object is destroyed.
2023-04-21 20:28:48 +00:00
QVERIFY(Test::waitForWindowClosed(window2));
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window1->isActive());
[x11] Force FocusIn events for already focused windows Depending on the current focus stealing prevention level, it's possible for kwin to call XSetInputFocus() on a window that already has the input focus. In which case, we won't receive the corresponding FocusIn event and the client will remain inactive from kwin's perspective even though it isn't. In order to work around this issue, we can move the input focus to the null window. By doing so, it's guaranteed that we're going to receive the matching FocusIn event for the client. This commit indirectly fixes a bug where fullscreen games are displayed below panels.
2020-06-16 08:03:25 +00:00
// Destroy the first test window.
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_destroy_window(connection.get(), windowId1);
xcb_flush(connection.get());
autotests: Fix Test::waitForWindowDestroyed Before Deleted merge, it used to be equivalent to waiting until the window is closed. This fixes tests waiting until the window closing animation completes and the Window object is destroyed.
2023-04-21 20:28:48 +00:00
QVERIFY(Test::waitForWindowClosed(window1));
[x11] Force FocusIn events for already focused windows Depending on the current focus stealing prevention level, it's possible for kwin to call XSetInputFocus() on a window that already has the input focus. In which case, we won't receive the corresponding FocusIn event and the client will remain inactive from kwin's perspective even though it isn't. In order to work around this issue, we can move the input focus to the null window. By doing so, it's guaranteed that we're going to receive the matching FocusIn event for the client. This commit indirectly fixes a bug where fullscreen games are displayed below panels.
2020-06-16 08:03:25 +00:00
}
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
void X11WindowTest::testReentrantMoveResize()
Make setFrameGeometry() re-entrant for X and internal clients If AbstractClient::setFrameGeometry() is called from a slot connected directly to the frameGeometryChanged() signal, then is there a good chance that kwin will fall into an infinite recursion. However, that's the case with only X11 and internal clients. The root cause of the infinite recursion is that both X11Client and InternalClient compare the new geometry against the geometry before update blocking. In order to fix the bug, we simply need to ensure that updateGeometryBeforeUpdateBlocking() has been called before we start emitting the frameGeometryChanged() signal. Furthermore, a couple of tests were added to ensure that we won't hit this subtle bug again.
2020-07-20 19:33:19 +00:00
{
Rework async geometry updates Window management features were written with synchronous geometry updates in mind. Currently, this poses a big problem on Wayland because geometry updates are done in asynchronous fashion there. At the moment, geometry is updated in a so called pseudo-asynchronous fashion, meaning that the frame geometry will be reset to the old value once geometry updates are unblocked. The main drawback of this approach is that it is too error prone, the data flow is hard to comprehend, etc. It is worth noting that there is already a machinery to perform async geometry which is used during interactive move/resize operations. This change extends the move/resize geometry usage beyond interactive move/resize to make asynchronous geometry updates less error prone and easier to comprehend. With the proposed solution, all geometry updates must be done on the move/resize geometry first. After that, the new geometry is passed on to the Client-specific implementation of moveResizeInternal(). To be more specific, the frameGeometry() returns the current frame geometry, it is primarily useful only to the scene. If you want to move or resize a window, you need to use moveResizeGeometry() because it corresponds to the last requested frame geometry. It is worth noting that the moveResizeGeometry() returns the desired bounding geometry. The client may commit the xdg_toplevel surface with a slightly smaller window geometry, for example to enforce a specific aspect ratio. The client is not allowed to resize beyond the size as indicated in moveResizeGeometry(). The data flow is very simple: moveResize() updates the move/resize geometry and calls the client-specific implementation of the moveResizeInternal() method. Based on whether a configure event is needed, moveResizeInternal() will update the frameGeometry() either immediately or after the client commits a new buffer. Unfortunately, both the compositor and xdg-shell clients try to update the window geometry. It means that it's possible to have conflicts between the two. With this change, the compositor's move resize geometry will be synced only if there are no pending configure events, meaning that the user doesn't try to resize the window.
2021-04-30 18:26:09 +00:00
// This test verifies that calling moveResize() from a slot connected directly
Make setFrameGeometry() re-entrant for X and internal clients If AbstractClient::setFrameGeometry() is called from a slot connected directly to the frameGeometryChanged() signal, then is there a good chance that kwin will fall into an infinite recursion. However, that's the case with only X11 and internal clients. The root cause of the infinite recursion is that both X11Client and InternalClient compare the new geometry against the geometry before update blocking. In order to fix the bug, we simply need to ensure that updateGeometryBeforeUpdateBlocking() has been called before we start emitting the frameGeometryChanged() signal. Furthermore, a couple of tests were added to ensure that we won't hit this subtle bug again.
2020-07-20 19:33:19 +00:00
// to the frameGeometryChanged() signal won't cause an infinite recursion.
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
QFETCH_GLOBAL(qreal, scale);
kwinApp()->setXwaylandScale(scale);
Make setFrameGeometry() re-entrant for X and internal clients If AbstractClient::setFrameGeometry() is called from a slot connected directly to the frameGeometryChanged() signal, then is there a good chance that kwin will fall into an infinite recursion. However, that's the case with only X11 and internal clients. The root cause of the infinite recursion is that both X11Client and InternalClient compare the new geometry against the geometry before update blocking. In order to fix the bug, we simply need to ensure that updateGeometryBeforeUpdateBlocking() has been called before we start emitting the frameGeometryChanged() signal. Furthermore, a couple of tests were added to ensure that we won't hit this subtle bug again.
2020-07-20 19:33:19 +00:00
// Create a test window.
Autotests: Use a helper method to create X11 connection
2023-02-03 13:29:21 +00:00
Test::XcbConnectionPtr c = Test::createX11Connection();
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
QVERIFY(!xcb_connection_has_error(c.get()));
Make setFrameGeometry() re-entrant for X and internal clients If AbstractClient::setFrameGeometry() is called from a slot connected directly to the frameGeometryChanged() signal, then is there a good chance that kwin will fall into an infinite recursion. However, that's the case with only X11 and internal clients. The root cause of the infinite recursion is that both X11Client and InternalClient compare the new geometry against the geometry before update blocking. In order to fix the bug, we simply need to ensure that updateGeometryBeforeUpdateBlocking() has been called before we start emitting the frameGeometryChanged() signal. Furthermore, a couple of tests were added to ensure that we won't hit this subtle bug again.
2020-07-20 19:33:19 +00:00
const QRect windowGeometry(0, 0, 100, 200);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_window_t windowId = xcb_generate_id(c.get());
xcb_create_window(c.get(), XCB_COPY_FROM_PARENT, windowId, rootWindow(),
Make setFrameGeometry() re-entrant for X and internal clients If AbstractClient::setFrameGeometry() is called from a slot connected directly to the frameGeometryChanged() signal, then is there a good chance that kwin will fall into an infinite recursion. However, that's the case with only X11 and internal clients. The root cause of the infinite recursion is that both X11Client and InternalClient compare the new geometry against the geometry before update blocking. In order to fix the bug, we simply need to ensure that updateGeometryBeforeUpdateBlocking() has been called before we start emitting the frameGeometryChanged() signal. Furthermore, a couple of tests were added to ensure that we won't hit this subtle bug again.
2020-07-20 19:33:19 +00:00
windowGeometry.x(),
windowGeometry.y(),
windowGeometry.width(),
windowGeometry.height(),
0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
xcb_size_hints_t hints;
memset(&hints, 0, sizeof(hints));
xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_icccm_set_wm_normal_hints(c.get(), windowId, &hints);
xcb_change_property(c.get(), XCB_PROP_MODE_REPLACE, windowId, atoms->wm_client_leader, XCB_ATOM_WINDOW, 32, 1, &windowId);
xcb_map_window(c.get(), windowId);
xcb_flush(c.get());
Make setFrameGeometry() re-entrant for X and internal clients If AbstractClient::setFrameGeometry() is called from a slot connected directly to the frameGeometryChanged() signal, then is there a good chance that kwin will fall into an infinite recursion. However, that's the case with only X11 and internal clients. The root cause of the infinite recursion is that both X11Client and InternalClient compare the new geometry against the geometry before update blocking. In order to fix the bug, we simply need to ensure that updateGeometryBeforeUpdateBlocking() has been called before we start emitting the frameGeometryChanged() signal. Furthermore, a couple of tests were added to ensure that we won't hit this subtle bug again.
2020-07-20 19:33:19 +00:00
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QSignalSpy windowCreatedSpy(workspace(), &Workspace::windowAdded);
Make setFrameGeometry() re-entrant for X and internal clients If AbstractClient::setFrameGeometry() is called from a slot connected directly to the frameGeometryChanged() signal, then is there a good chance that kwin will fall into an infinite recursion. However, that's the case with only X11 and internal clients. The root cause of the infinite recursion is that both X11Client and InternalClient compare the new geometry against the geometry before update blocking. In order to fix the bug, we simply need to ensure that updateGeometryBeforeUpdateBlocking() has been called before we start emitting the frameGeometryChanged() signal. Furthermore, a couple of tests were added to ensure that we won't hit this subtle bug again.
2020-07-20 19:33:19 +00:00
QVERIFY(windowCreatedSpy.wait());
autotests: client -> window
2022-04-23 19:51:16 +00:00
X11Window *window = windowCreatedSpy.first().first().value<X11Window *>();
QVERIFY(window);
QCOMPARE(window->pos(), QPoint(0, 0));
Make setFrameGeometry() re-entrant for X and internal clients If AbstractClient::setFrameGeometry() is called from a slot connected directly to the frameGeometryChanged() signal, then is there a good chance that kwin will fall into an infinite recursion. However, that's the case with only X11 and internal clients. The root cause of the infinite recursion is that both X11Client and InternalClient compare the new geometry against the geometry before update blocking. In order to fix the bug, we simply need to ensure that updateGeometryBeforeUpdateBlocking() has been called before we start emitting the frameGeometryChanged() signal. Furthermore, a couple of tests were added to ensure that we won't hit this subtle bug again.
2020-07-20 19:33:19 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
// Let's pretend that there is a script that really wants the window to be at (100, 100).
connect(window, &Window::frameGeometryChanged, this, [window]() {
Use floating geometry throughout With fractional scaling integer based logical geometry may not match device pixels. Once we have a floating point base we can fix that. This also is important for our X11 scale override, with a scale of 2 we could get logical sizes with halves. We already have all input being floating point, this doubles down on it for all remaining geometry. - Outputs remain integer to ensure that any screen on the right remains aligned. - Placement also remains integer based for now. - Repainting is untouched as we always expand outwards (QRectF::toAdjustedRect(). - Decoration is untouched for now - Rules are integer in the config, but floating in the adjusting/API This should also be fine. At some point we'll add a method to snap to the device pixel grid. Effectively `round(value * dpr) / dpr` though right now things mostly work. This also gets rid of a lot of hacks for QRect right and bottom which are very confusing. Parts to watch out in the port are: QRectF::contains now includes edges QRectF::right and bottom are now sane so previous hacks have to be removed QRectF(QPoint, QPoint) behaves differently for the same reason QRectF::center too In test results some adjusted values which are the result of QRect.center because using QRectF's center should behave the same to the user.
2022-05-16 20:13:39 +00:00
window->moveResize(QRectF(QPointF(100, 100), window->size()));
Make setFrameGeometry() re-entrant for X and internal clients If AbstractClient::setFrameGeometry() is called from a slot connected directly to the frameGeometryChanged() signal, then is there a good chance that kwin will fall into an infinite recursion. However, that's the case with only X11 and internal clients. The root cause of the infinite recursion is that both X11Client and InternalClient compare the new geometry against the geometry before update blocking. In order to fix the bug, we simply need to ensure that updateGeometryBeforeUpdateBlocking() has been called before we start emitting the frameGeometryChanged() signal. Furthermore, a couple of tests were added to ensure that we won't hit this subtle bug again.
2020-07-20 19:33:19 +00:00
});
// Trigger the lambda above.
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->move(QPoint(40, 50));
Make setFrameGeometry() re-entrant for X and internal clients If AbstractClient::setFrameGeometry() is called from a slot connected directly to the frameGeometryChanged() signal, then is there a good chance that kwin will fall into an infinite recursion. However, that's the case with only X11 and internal clients. The root cause of the infinite recursion is that both X11Client and InternalClient compare the new geometry against the geometry before update blocking. In order to fix the bug, we simply need to ensure that updateGeometryBeforeUpdateBlocking() has been called before we start emitting the frameGeometryChanged() signal. Furthermore, a couple of tests were added to ensure that we won't hit this subtle bug again.
2020-07-20 19:33:19 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
// Eventually, the window will end up at (100, 100).
QCOMPARE(window->pos(), QPoint(100, 100));
Make setFrameGeometry() re-entrant for X and internal clients If AbstractClient::setFrameGeometry() is called from a slot connected directly to the frameGeometryChanged() signal, then is there a good chance that kwin will fall into an infinite recursion. However, that's the case with only X11 and internal clients. The root cause of the infinite recursion is that both X11Client and InternalClient compare the new geometry against the geometry before update blocking. In order to fix the bug, we simply need to ensure that updateGeometryBeforeUpdateBlocking() has been called before we start emitting the frameGeometryChanged() signal. Furthermore, a couple of tests were added to ensure that we won't hit this subtle bug again.
2020-07-20 19:33:19 +00:00
// Destroy the test window.
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
xcb_destroy_window(c.get(), windowId);
xcb_flush(c.get());
autotests: Fix Test::waitForWindowDestroyed Before Deleted merge, it used to be equivalent to waiting until the window is closed. This fixes tests waiting until the window closing animation completes and the Window object is destroyed.
2023-04-21 20:28:48 +00:00
QVERIFY(Test::waitForWindowClosed(window));
Make setFrameGeometry() re-entrant for X and internal clients If AbstractClient::setFrameGeometry() is called from a slot connected directly to the frameGeometryChanged() signal, then is there a good chance that kwin will fall into an infinite recursion. However, that's the case with only X11 and internal clients. The root cause of the infinite recursion is that both X11Client and InternalClient compare the new geometry against the geometry before update blocking. In order to fix the bug, we simply need to ensure that updateGeometryBeforeUpdateBlocking() has been called before we start emitting the frameGeometryChanged() signal. Furthermore, a couple of tests were added to ensure that we won't hit this subtle bug again.
2020-07-20 19:33:19 +00:00
}
Rename X11Client to X11Window The word "client" means different things in wayland and kwin. Use a better word to refer to windows.
2022-04-22 17:54:31 +00:00
WAYLANDTEST_MAIN(X11WindowTest)
#include "x11_window_test.moc"
Reference in a new issue Copy permalink