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

807 lines
33 KiB
C++
Raw Normal View History

Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
/*
KWin - the KDE window manager
This file is part of the KDE project.
SPDX-FileCopyrightText: 2020 Marco Martin <mart@kde.org>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#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
Move multi-purpose code in its own directory Things such as Output, InputDevice and so on are made to be multi-purpose. In order to make this separation more clear, this change moves that code in the core directory. Some things still link to the abstraction level above (kwin), they can be tackled in future refactors. Ideally code in core/ should depend either on other code in core/ or system libs.
2022-08-29 07:55:49 +00:00
#include "core/output.h"
virtualkeyboard: rename class to InputMethod VirtualKeyboard class does not implement the relevant VirtualKeyboard protocol but rather implements the InputMethod protcol and can in theory be used by other input method like e.g. ibus. Make class name consistent with what it does to avoid confusion in future. For now only rename of main class is done and dbus service is kept as-is to provide retro-compatibility, when input method protocol is implemented fully, we can think of what to do wrt the dbus interface later when we fully implement zwp_input_method_unstable_v1 protocol.
2020-09-29 14:46:32 +00:00
#include "inputmethod.h"
inputmethod: Ensure InputPanelV1Window is always within the screen Currently when input panel is using overlay mode and the cursor rectangle is below or above the screen area, the input panel may be placed off the screen. The change ensure it is always placed within the screen area using similar math like xdg_popup's slide_y constrain.
2024-01-11 06:37:51 +00:00
#include "inputpanelv1window.h"
Add a fallback path for input when there is no text-input An application that does not support text-input has no way of communicating with the input method, so even if you show the input method the application receives nothing. As a fallback, instead send fake key events so the application still gets something at least. The key events are synthesised based on the text string that the input method sends, which may result in things that do not actually correspond to real keys. Unfortunately I do not see a way around that. CCBUG: 439911
2022-05-17 11:53:13 +00:00
#include "keyboard_input.h"
Port away from Cursor::setPos() Use input device specific apis to change the position of the cursor. The main reason to do so is to break the assumption that Cursor position is the same as pointer position, which I would like to rely on later to merge tablet and pointer cursors.
2023-02-09 13:07:56 +00:00
#include "pointer_input.h"
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
#include "qwayland-input-method-unstable-v1.h"
virtualkeyboard: add text-input-v3 support
2020-09-25 06:51:04 +00:00
#include "qwayland-text-input-unstable-v3.h"
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
#include "virtualkeyboard_dbus.h"
Integrate kwaylandserver This makes KWin switch to in-tree copy of KWaylandServer codebase. KWaylandServer namespace has been left as is. It will be addressed later by renaming classes in order to fit in the KWin namespace.
2022-04-22 09:27:33 +00:00
#include "wayland/clientconnection.h"
#include "wayland/display.h"
wayland: Drop "_interface" from filenames The cpp files in the wayland directory are named after protocol names. "_interface" does not contribute anything new.
2023-09-13 05:52:59 +00:00
#include "wayland/seat.h"
#include "wayland/surface.h"
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
#include "wayland_server.h"
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
#include "window.h"
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
#include "workspace.h"
Add a fallback path for input when there is no text-input An application that does not support text-input has no way of communicating with the input method, so even if you show the input method the application receives nothing. As a fallback, instead send fake key events so the application still gets something at least. The key events are synthesised based on the text string that the input method sends, which may result in things that do not actually correspond to real keys. Unfortunately I do not see a way around that. CCBUG: 439911
2022-05-17 11:53:13 +00:00
#include "xkb.h"
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +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
#include <QDBusConnection>
#include <QDBusMessage>
#include <QDBusPendingReply>
#include <QSignalSpy>
#include <QTest>
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
#include <KWayland/Client/compositor.h>
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
#include <KWayland/Client/keyboard.h>
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
#include <KWayland/Client/output.h>
inputmethod: Reduce consecutive activation+deactivation+activation sequences So far calling setActive(true) would issue a deactivation then another activation. This sometimes makes maliit crash and we can achieve the same result just by just issuing a reset.
2021-07-20 23:41:38 +00:00
#include <KWayland/Client/region.h>
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
#include <KWayland/Client/seat.h>
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
#include <KWayland/Client/surface.h>
#include <KWayland/Client/textinput.h>
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
#include <linux/input-event-codes.h>
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
using namespace KWin;
using KWin::VirtualKeyboardDBus;
autotests: rename to testInputMethod Relevant class got renamed, also update the test name Related: plasma/kwin!302
2020-09-30 10:28:42 +00:00
static const QString s_socketName = QStringLiteral("wayland_test_kwin_inputmethod-0");
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
autotests: rename to testInputMethod Relevant class got renamed, also update the test name Related: plasma/kwin!302
2020-09-30 10:28:42 +00:00
class InputMethodTest : public QObject
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
{
Q_OBJECT
private Q_SLOTS:
void initTestCase();
void init();
void cleanup();
void testOpenClose();
virtualkeyboard: add text-input-v3 support
2020-09-25 06:51:04 +00:00
void testEnableDisableV3();
inputmethod: Reduce consecutive activation+deactivation+activation sequences So far calling setActive(true) would issue a deactivation then another activation. This sometimes makes maliit crash and we can achieve the same result just by just issuing a reset.
2021-07-20 23:41:38 +00:00
void testEnableActive();
inputmethod: Also expose the visibility on dbus Since we adapted inputmethod to support methods like ibus, the input method can be active but not have a visible panel. This includes an extra property that will indicate us if the panel is visible at any time. This will allow us to properly render the virtual keyboard hide button in Plasma Mobile (or wherever we need it).
2021-07-21 00:04:33 +00:00
void testHidePanel();
Try to refresh textInput active focus status
2023-08-15 10:56:11 +00:00
void testReactivateFocus();
inputmethod: Add a test that simulates client switching
2021-07-30 18:29:01 +00:00
void testSwitchFocusedSurfaces();
Fix potential race condition when text input state change and focus change happened at the same time In some cases, stateCommitted may fire after a new surface being focused and in correctly set input method to be inactive. This can be reproduced by switch client between an active text input v3 client and text input v2 client.
2022-10-16 05:03:32 +00:00
void testV2V3SameClient();
Try our best to convert preedit styling to text-input-v3 cursor range. text-input-v3 does not have preedit styling, instead, it can only specify the range of cursor. Try to keep track of any highlight/selection style range and combine them together. If it matches the cursor position, use it as the cursor range.
2021-12-23 08:42:00 +00:00
void testV3Styling();
Do not call setActive(true) when request input panel to show Observed in kdevelop, that isEnabled() could be false when switching between different tabs with Ctrl+Tab. But Qt may still call show() if you click on the texteditor widget. This leads to isEnabled == false but setActive(true) is called. This causes kdevelop in a usable state because keyboard grab will be created and no key event will reach application because isEnabled == false. Under normal circumstances, key will reach widget first and triggers another text_input_v2 enable to make input method work properly.
2021-12-23 22:33:30 +00:00
void testDisableShowInputPanel();
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
void testModifierForwarding();
Add a fallback path for input when there is no text-input An application that does not support text-input has no way of communicating with the input method, so even if you show the input method the application receives nothing. As a fallback, instead send fake key events so the application still gets something at least. The key events are synthesised based on the text string that the input method sends, which may result in things that do not actually correspond to real keys. Unfortunately I do not see a way around that. CCBUG: 439911
2022-05-17 11:53:13 +00:00
void testFakeEventFallback();
inputmethod: Ensure InputPanelV1Window is always within the screen Currently when input panel is using overlay mode and the cursor rectangle is below or above the screen area, the input panel may be placed off the screen. The change ensure it is always placed within the screen area using similar math like xdg_popup's slide_y constrain.
2024-01-11 06:37:51 +00:00
void testOverlayPositioning_data();
void testOverlayPositioning();
Fix inputmethodtest We needed to simulate a touch event so that it doesn't decide to ignore the next events.
2021-10-18 13:41:05 +00:00
private:
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
void touchNow()
{
Fix inputmethodtest We needed to simulate a touch event so that it doesn't decide to ignore the next events.
2021-10-18 13:41:05 +00:00
static int time = 0;
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::touchDown(0, {100, 100}, ++time);
Test::touchUp(0, ++time);
Fix inputmethodtest We needed to simulate a touch event so that it doesn't decide to ignore the next events.
2021-10-18 13:41:05 +00:00
}
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
};
autotests: rename to testInputMethod Relevant class got renamed, also update the test name Related: plasma/kwin!302
2020-09-30 10:28:42 +00:00
void InputMethodTest::initTestCase()
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
{
autotests: Register virtual keyboard service Otherwise the input method test seems to fail with the following error "The name org.kde.kwin.testvirtualkeyboard was not provided by any .service files"
2021-02-22 16:03:16 +00:00
QDBusConnection::sessionBus().registerService(QStringLiteral("org.kde.kwin.testvirtualkeyboard"));
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
qRegisterMetaType<KWin::Window *>();
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
qRegisterMetaType<KWayland::Client::Output *>();
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),
QRect(1280, 0, 1280, 1024),
});
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
inputmethod: Remove workaround
2021-07-21 11:10:06 +00:00
static_cast<WaylandTestApplication *>(kwinApp())->setInputMethodServerToStart("internal");
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
kwinApp()->start();
QVERIFY(applicationStartedSpy.wait());
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
const auto outputs = workspace()->outputs();
autotests: Port common screen check preamble to AbstractOutput
2021-08-31 07:03:05 +00:00
QCOMPARE(outputs.count(), 2);
QCOMPARE(outputs[0]->geometry(), QRect(0, 0, 1280, 1024));
QCOMPARE(outputs[1]->geometry(), QRect(1280, 0, 1280, 1024));
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
}
autotests: rename to testInputMethod Relevant class got renamed, also update the test name Related: plasma/kwin!302
2020-09-30 10:28:42 +00:00
void InputMethodTest::init()
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
{
Port away from Cursor::setPos() Use input device specific apis to change the position of the cursor. The main reason to do so is to break the assumption that Cursor position is the same as pointer position, which I would like to rely on later to merge tablet and pointer cursors.
2023-02-09 13:07:56 +00:00
workspace()->setActiveOutput(QPoint(640, 512));
KWin::input()->pointer()->warp(QPoint(640, 512));
Fix inputmethodtest We needed to simulate a touch event so that it doesn't decide to ignore the next events.
2021-10-18 13:41:05 +00:00
touchNow();
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
Port away from Cursor::setPos() Use input device specific apis to change the position of the cursor. The main reason to do so is to break the assumption that Cursor position is the same as pointer position, which I would like to rely on later to merge tablet and pointer cursors.
2023-02-09 13:07:56 +00:00
QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat | Test::AdditionalWaylandInterface::TextInputManagerV2 | Test::AdditionalWaylandInterface::InputMethodV1 | Test::AdditionalWaylandInterface::TextInputManagerV3));
Trim trailing whitespace
2020-11-27 19:57:24 +00:00
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
kwinApp()->inputMethod()->setEnabled(true);
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
}
autotests: rename to testInputMethod Relevant class got renamed, also update the test name Related: plasma/kwin!302
2020-09-30 10:28:42 +00:00
void InputMethodTest::cleanup()
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
{
Test::destroyWaylandConnection();
}
autotests: rename to testInputMethod Relevant class got renamed, also update the test name Related: plasma/kwin!302
2020-09-30 10:28:42 +00:00
void InputMethodTest::testOpenClose()
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
{
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QSignalSpy windowAddedSpy(workspace(), &Workspace::windowAdded);
QSignalSpy windowRemovedSpy(workspace(), &Workspace::windowRemoved);
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
// Create an xdg_toplevel surface and wait for the compositor to catch up.
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()));
Window *window = Test::renderAndWaitForShown(surface.get(), QSize(1280, 1024), Qt::red);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window);
QVERIFY(window->isActive());
QCOMPARE(window->frameGeometry().size(), QSize(1280, 1024));
QSignalSpy frameGeometryChangedSpy(window, &Window::frameGeometryChanged);
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
QSignalSpy toplevelConfigureRequestedSpy(shellSurface.get(), &Test::XdgToplevel::configureRequested);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
autotests/integration: make inputmethodtest more realstic When text input gets enabled, the sequence should be 1. enable 2. request to show the panel 3. panel gets added and shown And showing the panel again after hiding is an important case to cover as well.
2022-10-21 19:44:57 +00:00
QVERIFY(surfaceConfigureRequestedSpy.wait());
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
std::unique_ptr<KWayland::Client::TextInput> textInput(Test::waylandTextInputManager()->createTextInput(Test::waylandSeat()));
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
QVERIFY(textInput != nullptr);
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
// Show the keyboard
Fix inputmethodtest We needed to simulate a touch event so that it doesn't decide to ignore the next events.
2021-10-18 13:41:05 +00:00
touchNow();
autotests/integration: make inputmethodtest more realstic When text input gets enabled, the sequence should be 1. enable 2. request to show the panel 3. panel gets added and shown And showing the panel again after hiding is an important case to cover as well.
2022-10-21 19:44:57 +00:00
textInput->enable(surface.get());
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
textInput->showInputPanel();
autotests/integration: make inputmethodtest more realstic When text input gets enabled, the sequence should be 1. enable 2. request to show the panel 3. panel gets added and shown And showing the panel again after hiding is an important case to cover as well.
2022-10-21 19:44:57 +00:00
QSignalSpy paneladded(kwinApp()->inputMethod(), &KWin::InputMethod::panelChanged);
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QVERIFY(windowAddedSpy.wait());
autotests/integration: make inputmethodtest more realstic When text input gets enabled, the sequence should be 1. enable 2. request to show the panel 3. panel gets added and shown And showing the panel again after hiding is an important case to cover as well.
2022-10-21 19:44:57 +00:00
QCOMPARE(paneladded.count(), 1);
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
Window *keyboardClient = windowAddedSpy.last().first().value<Window *>();
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
QVERIFY(keyboardClient);
QVERIFY(keyboardClient->isInputMethod());
// Do the actual resize
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
QVERIFY(surfaceConfigureRequestedSpy.wait());
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
Test::render(surface.get(), toplevelConfigureRequestedSpy.last().first().value<QSize>(), Qt::red);
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
QVERIFY(frameGeometryChangedSpy.wait());
Drop Window::inputGeometry It's been mostly superseded by Window::hitTest().
2023-03-31 17:18:55 +00:00
QCOMPARE(window->frameGeometry().height(), 1024 - keyboardClient->frameGeometry().height());
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
// Hide the keyboard
textInput->hideInputPanel();
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
QVERIFY(surfaceConfigureRequestedSpy.wait());
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
Test::render(surface.get(), toplevelConfigureRequestedSpy.last().first().value<QSize>(), Qt::red);
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
QVERIFY(frameGeometryChangedSpy.wait());
autotests: client -> window
2022-04-23 19:51:16 +00:00
QCOMPARE(window->frameGeometry().height(), 1024);
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
autotests/integration: make inputmethodtest more realstic When text input gets enabled, the sequence should be 1. enable 2. request to show the panel 3. panel gets added and shown And showing the panel again after hiding is an important case to cover as well.
2022-10-21 19:44:57 +00:00
// show the keyboard again
touchNow();
textInput->enable(surface.get());
textInput->showInputPanel();
QVERIFY(surfaceConfigureRequestedSpy.wait());
QVERIFY(keyboardClient->isShown());
autotests: client -> window
2022-04-23 19:51:16 +00:00
// Destroy the test window.
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
shellSurface.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(window));
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
}
autotests: rename to testInputMethod Relevant class got renamed, also update the test name Related: plasma/kwin!302
2020-09-30 10:28:42 +00:00
void InputMethodTest::testEnableDisableV3()
virtualkeyboard: add text-input-v3 support
2020-09-25 06:51:04 +00:00
{
// Create an xdg_toplevel surface and wait for the compositor to catch up.
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()));
Window *window = Test::renderAndWaitForShown(surface.get(), QSize(1280, 1024), Qt::red);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window);
QVERIFY(window->isActive());
QCOMPARE(window->frameGeometry().size(), QSize(1280, 1024));
virtualkeyboard: add text-input-v3 support
2020-09-25 06:51:04 +00:00
Fix potential race condition when text input state change and focus change happened at the same time In some cases, stateCommitted may fire after a new surface being focused and in correctly set input method to be inactive. This can be reproduced by switch client between an active text input v3 client and text input v2 client.
2022-10-16 05:03:32 +00:00
auto textInputV3 = std::make_unique<Test::TextInputV3>();
virtualkeyboard: add text-input-v3 support
2020-09-25 06:51:04 +00:00
textInputV3->init(Test::waylandTextInputManagerV3()->get_text_input(*(Test::waylandSeat())));
Implement a enableRequested signal for text-input-v3 The signal will be emitted if text-input-v3 applies a new enable state if it's already enabled. In Gtk's implementation, sending text_input_v3.enable for the second time has the similar semantics of text-input-v2.showInputPanel. Try to connect them together and add corresponding test. See also: https://github.com/GNOME/gtk/blob/a95cfb1c457cbd3ff365f7f1244c42dda8540b66/gtk/gtkimcontextwayland.c#L555
2022-10-24 23:38:40 +00:00
// Show the keyboard
touchNow();
virtualkeyboard: add text-input-v3 support
2020-09-25 06:51:04 +00:00
textInputV3->enable();
Implement a enableRequested signal for text-input-v3 The signal will be emitted if text-input-v3 applies a new enable state if it's already enabled. In Gtk's implementation, sending text_input_v3.enable for the second time has the similar semantics of text-input-v2.showInputPanel. Try to connect them together and add corresponding test. See also: https://github.com/GNOME/gtk/blob/a95cfb1c457cbd3ff365f7f1244c42dda8540b66/gtk/gtkimcontextwayland.c#L555
2022-10-24 23:38:40 +00:00
QSignalSpy windowAddedSpy(workspace(), &Workspace::windowAdded);
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QSignalSpy inputMethodActiveSpy(kwinApp()->inputMethod(), &InputMethod::activeChanged);
InputMethodTest: Use InputMethod::isActive as a way to check if it's activated Instead of looking for a client, which is a bit more of a hit and miss, since the client doesn't need to be registered when the test expects it to.
2021-05-10 16:01:41 +00:00
// just enabling the text-input should not show it but rather on commit
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(!kwinApp()->inputMethod()->isActive());
virtualkeyboard: add text-input-v3 support
2020-09-25 06:51:04 +00:00
textInputV3->commit();
InputMethodTest: Use InputMethod::isActive as a way to check if it's activated Instead of looking for a client, which is a bit more of a hit and miss, since the client doesn't need to be registered when the test expects it to.
2021-05-10 16:01:41 +00:00
QVERIFY(inputMethodActiveSpy.count() || inputMethodActiveSpy.wait());
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(kwinApp()->inputMethod()->isActive());
virtualkeyboard: add text-input-v3 support
2020-09-25 06:51:04 +00:00
Implement a enableRequested signal for text-input-v3 The signal will be emitted if text-input-v3 applies a new enable state if it's already enabled. In Gtk's implementation, sending text_input_v3.enable for the second time has the similar semantics of text-input-v2.showInputPanel. Try to connect them together and add corresponding test. See also: https://github.com/GNOME/gtk/blob/a95cfb1c457cbd3ff365f7f1244c42dda8540b66/gtk/gtkimcontextwayland.c#L555
2022-10-24 23:38:40 +00:00
QVERIFY(windowAddedSpy.wait());
Window *keyboardClient = windowAddedSpy.last().first().value<Window *>();
QVERIFY(keyboardClient);
QVERIFY(keyboardClient->isInputMethod());
QVERIFY(keyboardClient->isShown());
// Text input v3 doesn't have hideInputPanel, just simiulate the hide from dbus call
kwinApp()->inputMethod()->hide();
QVERIFY(!keyboardClient->isShown());
Port away the remaining users of windowShown/windowHidden to hiddenChanged
2024-01-29 22:04:57 +00:00
QSignalSpy hiddenChangedSpy(keyboardClient, &Window::hiddenChanged);
Implement a enableRequested signal for text-input-v3 The signal will be emitted if text-input-v3 applies a new enable state if it's already enabled. In Gtk's implementation, sending text_input_v3.enable for the second time has the similar semantics of text-input-v2.showInputPanel. Try to connect them together and add corresponding test. See also: https://github.com/GNOME/gtk/blob/a95cfb1c457cbd3ff365f7f1244c42dda8540b66/gtk/gtkimcontextwayland.c#L555
2022-10-24 23:38:40 +00:00
// Force enable the text input object. This is what's done by Gtk.
textInputV3->enable();
textInputV3->commit();
Port away the remaining users of windowShown/windowHidden to hiddenChanged
2024-01-29 22:04:57 +00:00
hiddenChangedSpy.wait();
Implement a enableRequested signal for text-input-v3 The signal will be emitted if text-input-v3 applies a new enable state if it's already enabled. In Gtk's implementation, sending text_input_v3.enable for the second time has the similar semantics of text-input-v2.showInputPanel. Try to connect them together and add corresponding test. See also: https://github.com/GNOME/gtk/blob/a95cfb1c457cbd3ff365f7f1244c42dda8540b66/gtk/gtkimcontextwayland.c#L555
2022-10-24 23:38:40 +00:00
QVERIFY(keyboardClient->isShown());
virtualkeyboard: add text-input-v3 support
2020-09-25 06:51:04 +00:00
// disable text input and ensure that it is not hiding input panel without commit
InputMethodTest: Use InputMethod::isActive as a way to check if it's activated Instead of looking for a client, which is a bit more of a hit and miss, since the client doesn't need to be registered when the test expects it to.
2021-05-10 16:01:41 +00:00
inputMethodActiveSpy.clear();
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(kwinApp()->inputMethod()->isActive());
virtualkeyboard: add text-input-v3 support
2020-09-25 06:51:04 +00:00
textInputV3->disable();
textInputV3->commit();
InputMethodTest: Use InputMethod::isActive as a way to check if it's activated Instead of looking for a client, which is a bit more of a hit and miss, since the client doesn't need to be registered when the test expects it to.
2021-05-10 16:01:41 +00:00
QVERIFY(inputMethodActiveSpy.count() || inputMethodActiveSpy.wait());
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(!kwinApp()->inputMethod()->isActive());
virtualkeyboard: add text-input-v3 support
2020-09-25 06:51:04 +00:00
}
inputmethod: Reduce consecutive activation+deactivation+activation sequences So far calling setActive(true) would issue a deactivation then another activation. This sometimes makes maliit crash and we can achieve the same result just by just issuing a reset.
2021-07-20 23:41:38 +00:00
void InputMethodTest::testEnableActive()
{
autotests: Hopefully stabilize testInputMethod
2022-09-08 07:04:14 +00:00
// This test verifies that enabling text-input twice won't change the active input method status.
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(!kwinApp()->inputMethod()->isActive());
inputmethod: Reduce consecutive activation+deactivation+activation sequences So far calling setActive(true) would issue a deactivation then another activation. This sometimes makes maliit crash and we can achieve the same result just by just issuing a reset.
2021-07-20 23:41:38 +00:00
// Create an xdg_toplevel surface and wait for the compositor to catch up.
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()));
Window *window = Test::renderAndWaitForShown(surface.get(), QSize(1280, 1024), Qt::red);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window);
QVERIFY(window->isActive());
inputmethod: Reduce consecutive activation+deactivation+activation sequences So far calling setActive(true) would issue a deactivation then another activation. This sometimes makes maliit crash and we can achieve the same result just by just issuing a reset.
2021-07-20 23:41:38 +00:00
// Show the keyboard
InputMethodTest: Only create the windowAddedSpy when actually needed We don't really care about the window showing up until we're calling showInputPanel, but since Workspace::windowAdded is triggered for any window that gets added, the test sometimes fails because count() is 2 instead of 1. To avoid that, only create the spy when it's actually relevant instead of all the way at the start before any other setup is done.
2022-07-13 15:24:19 +00:00
QSignalSpy windowAddedSpy(workspace(), &Workspace::windowAdded);
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
std::unique_ptr<KWayland::Client::TextInput> textInput(Test::waylandTextInputManager()->createTextInput(Test::waylandSeat()));
autotests: Hopefully stabilize testInputMethod
2022-09-08 07:04:14 +00:00
textInput->enable(surface.get());
autotests: fix InputMethodTest
2022-09-22 19:49:53 +00:00
QSignalSpy paneladded(kwinApp()->inputMethod(), &KWin::InputMethod::panelChanged);
QVERIFY(paneladded.wait());
inputmethod: Reduce consecutive activation+deactivation+activation sequences So far calling setActive(true) would issue a deactivation then another activation. This sometimes makes maliit crash and we can achieve the same result just by just issuing a reset.
2021-07-20 23:41:38 +00:00
textInput->showInputPanel();
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QVERIFY(windowAddedSpy.wait());
autotests: Hopefully stabilize testInputMethod
2022-09-08 07:04:14 +00:00
QVERIFY(kwinApp()->inputMethod()->isActive());
inputmethod: Reduce consecutive activation+deactivation+activation sequences So far calling setActive(true) would issue a deactivation then another activation. This sometimes makes maliit crash and we can achieve the same result just by just issuing a reset.
2021-07-20 23:41:38 +00:00
autotests: Hopefully stabilize testInputMethod
2022-09-08 07:04:14 +00:00
// Ask the keyboard to be shown again.
QSignalSpy activateSpy(kwinApp()->inputMethod(), &InputMethod::activeChanged);
inputmethod: Reduce consecutive activation+deactivation+activation sequences So far calling setActive(true) would issue a deactivation then another activation. This sometimes makes maliit crash and we can achieve the same result just by just issuing a reset.
2021-07-20 23:41:38 +00:00
textInput->enable(surface.get());
textInput->showInputPanel();
activateSpy.wait(200);
QVERIFY(activateSpy.isEmpty());
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(kwinApp()->inputMethod()->isActive());
inputmethod: Reduce consecutive activation+deactivation+activation sequences So far calling setActive(true) would issue a deactivation then another activation. This sometimes makes maliit crash and we can achieve the same result just by just issuing a reset.
2021-07-20 23:41:38 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
// Destroy the test window.
inputmethod: Reduce consecutive activation+deactivation+activation sequences So far calling setActive(true) would issue a deactivation then another activation. This sometimes makes maliit crash and we can achieve the same result just by just issuing a reset.
2021-07-20 23:41:38 +00:00
shellSurface.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(window));
inputmethod: Reduce consecutive activation+deactivation+activation sequences So far calling setActive(true) would issue a deactivation then another activation. This sometimes makes maliit crash and we can achieve the same result just by just issuing a reset.
2021-07-20 23:41:38 +00:00
}
inputmethod: Also expose the visibility on dbus Since we adapted inputmethod to support methods like ibus, the input method can be active but not have a visible panel. This includes an extra property that will indicate us if the panel is visible at any time. This will allow us to properly render the virtual keyboard hide button in Plasma Mobile (or wherever we need it).
2021-07-21 00:04:33 +00:00
void InputMethodTest::testHidePanel()
{
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(!kwinApp()->inputMethod()->isActive());
inputmethod: Also expose the visibility on dbus Since we adapted inputmethod to support methods like ibus, the input method can be active but not have a visible panel. This includes an extra property that will indicate us if the panel is visible at any time. This will allow us to properly render the virtual keyboard hide button in Plasma Mobile (or wherever we need it).
2021-07-21 00:04:33 +00:00
autotests: Fix InputMethodTest We now will only be getting the input method panel when there's an enabled surface.
2022-01-19 01:52:44 +00:00
touchNow();
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QSignalSpy windowAddedSpy(workspace(), &Workspace::windowAdded);
QSignalSpy windowRemovedSpy(workspace(), &Workspace::windowRemoved);
inputmethod: Also expose the visibility on dbus Since we adapted inputmethod to support methods like ibus, the input method can be active but not have a visible panel. This includes an extra property that will indicate us if the panel is visible at any time. This will allow us to properly render the virtual keyboard hide button in Plasma Mobile (or wherever we need it).
2021-07-21 00:04:33 +00:00
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QSignalSpy activateSpy(kwinApp()->inputMethod(), &InputMethod::activeChanged);
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
std::unique_ptr<KWayland::Client::TextInput> textInput(Test::waylandTextInputManager()->createTextInput(Test::waylandSeat()));
inputmethod: Also expose the visibility on dbus Since we adapted inputmethod to support methods like ibus, the input method can be active but not have a visible panel. This includes an extra property that will indicate us if the panel is visible at any time. This will allow us to properly render the virtual keyboard hide button in Plasma Mobile (or wherever we need it).
2021-07-21 00:04:33 +00:00
// Create an xdg_toplevel surface and wait for the compositor to catch up.
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()));
Window *window = Test::renderAndWaitForShown(surface.get(), QSize(1280, 1024), Qt::red);
autotests: client -> window
2022-04-23 19:51:16 +00:00
waylandServer()->seat()->setFocusedTextInputSurface(window->surface());
inputmethod: Also expose the visibility on dbus Since we adapted inputmethod to support methods like ibus, the input method can be active but not have a visible panel. This includes an extra property that will indicate us if the panel is visible at any time. This will allow us to properly render the virtual keyboard hide button in Plasma Mobile (or wherever we need it).
2021-07-21 00:04:33 +00:00
autotests: Fix InputMethodTest We now will only be getting the input method panel when there's an enabled surface.
2022-01-19 01:52:44 +00:00
textInput->enable(surface.get());
autotests: fix InputMethodTest
2022-09-22 19:49:53 +00:00
QSignalSpy paneladded(kwinApp()->inputMethod(), &KWin::InputMethod::panelChanged);
QVERIFY(paneladded.wait());
autotests: Fix InputMethodTest We now will only be getting the input method panel when there's an enabled surface.
2022-01-19 01:52:44 +00:00
textInput->showInputPanel();
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QVERIFY(windowAddedSpy.wait());
autotests: Fix InputMethodTest We now will only be getting the input method panel when there's an enabled surface.
2022-01-19 01:52:44 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
QCOMPARE(workspace()->activeWindow(), window);
inputmethod: Also expose the visibility on dbus Since we adapted inputmethod to support methods like ibus, the input method can be active but not have a visible panel. This includes an extra property that will indicate us if the panel is visible at any time. This will allow us to properly render the virtual keyboard hide button in Plasma Mobile (or wherever we need it).
2021-07-21 00:04:33 +00:00
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QCOMPARE(windowAddedSpy.count(), 2);
inputmethod: Also expose the visibility on dbus Since we adapted inputmethod to support methods like ibus, the input method can be active but not have a visible panel. This includes an extra property that will indicate us if the panel is visible at any time. This will allow us to properly render the virtual keyboard hide button in Plasma Mobile (or wherever we need it).
2021-07-21 00:04:33 +00:00
QVERIFY(activateSpy.count() || activateSpy.wait());
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(kwinApp()->inputMethod()->isActive());
inputmethod: Also expose the visibility on dbus Since we adapted inputmethod to support methods like ibus, the input method can be active but not have a visible panel. This includes an extra property that will indicate us if the panel is visible at any time. This will allow us to properly render the virtual keyboard hide button in Plasma Mobile (or wherever we need it).
2021-07-21 00:04:33 +00:00
autotests: fix InputMethodTest
2022-09-22 19:49:53 +00:00
auto keyboardWindow = kwinApp()->inputMethod()->panel();
inputmethod: Also expose the visibility on dbus Since we adapted inputmethod to support methods like ibus, the input method can be active but not have a visible panel. This includes an extra property that will indicate us if the panel is visible at any time. This will allow us to properly render the virtual keyboard hide button in Plasma Mobile (or wherever we need it).
2021-07-21 00:04:33 +00:00
auto ipsurface = Test::inputPanelSurface();
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(keyboardWindow);
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
windowRemovedSpy.clear();
inputmethod: Also expose the visibility on dbus Since we adapted inputmethod to support methods like ibus, the input method can be active but not have a visible panel. This includes an extra property that will indicate us if the panel is visible at any time. This will allow us to properly render the virtual keyboard hide button in Plasma Mobile (or wherever we need it).
2021-07-21 00:04:33 +00:00
delete ipsurface;
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(kwinApp()->inputMethod()->isVisible());
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QVERIFY(windowRemovedSpy.count() || windowRemovedSpy.wait());
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(!kwinApp()->inputMethod()->isVisible());
inputmethod: Also expose the visibility on dbus Since we adapted inputmethod to support methods like ibus, the input method can be active but not have a visible panel. This includes an extra property that will indicate us if the panel is visible at any time. This will allow us to properly render the virtual keyboard hide button in Plasma Mobile (or wherever we need it).
2021-07-21 00:04:33 +00:00
autotests: client -> window
2022-04-23 19:51:16 +00:00
// Destroy the test window.
inputmethod: Also expose the visibility on dbus Since we adapted inputmethod to support methods like ibus, the input method can be active but not have a visible panel. This includes an extra property that will indicate us if the panel is visible at any time. This will allow us to properly render the virtual keyboard hide button in Plasma Mobile (or wherever we need it).
2021-07-21 00:04:33 +00:00
shellSurface.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(window));
inputmethod: Also expose the visibility on dbus Since we adapted inputmethod to support methods like ibus, the input method can be active but not have a visible panel. This includes an extra property that will indicate us if the panel is visible at any time. This will allow us to properly render the virtual keyboard hide button in Plasma Mobile (or wherever we need it).
2021-07-21 00:04:33 +00:00
}
Try to refresh textInput active focus status
2023-08-15 10:56:11 +00:00
void InputMethodTest::testReactivateFocus()
{
touchNow();
QVERIFY(!kwinApp()->inputMethod()->isActive());
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
Window *window = Test::renderAndWaitForShown(surface.get(), QSize(1280, 1024), Qt::red);
QVERIFY(window);
QVERIFY(window->isActive());
QCOMPARE(window->frameGeometry().size(), QSize(1280, 1024));
// Show the keyboard
QSignalSpy windowAddedSpy(workspace(), &Workspace::windowAdded);
std::unique_ptr<KWayland::Client::TextInput> textInput(Test::waylandTextInputManager()->createTextInput(Test::waylandSeat()));
textInput->enable(surface.get());
QSignalSpy paneladded(kwinApp()->inputMethod(), &KWin::InputMethod::panelChanged);
QVERIFY(paneladded.wait());
textInput->showInputPanel();
QVERIFY(windowAddedSpy.wait());
QVERIFY(kwinApp()->inputMethod()->isActive());
QSignalSpy activeSpy(kwinApp()->inputMethod(), &InputMethod::activeChanged);
// Hide keyboard like keyboardToggle button on navigation panel
kwinApp()->inputMethod()->setActive(false);
activeSpy.wait(200);
QVERIFY(!kwinApp()->inputMethod()->isActive());
// Reactivate
textInput->enable(surface.get());
textInput->showInputPanel();
activeSpy.wait(200);
QVERIFY(kwinApp()->inputMethod()->isActive());
// Destroy the test window
shellSurface.reset();
QVERIFY(Test::waitForWindowClosed(window));
}
inputmethod: Add a test that simulates client switching
2021-07-30 18:29:01 +00:00
void InputMethodTest::testSwitchFocusedSurfaces()
{
autotests: Fix InputMethodTest We now will only be getting the input method panel when there's an enabled surface.
2022-01-19 01:52:44 +00:00
touchNow();
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(!kwinApp()->inputMethod()->isActive());
inputmethod: Add a test that simulates client switching
2021-07-30 18:29:01 +00:00
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QSignalSpy windowAddedSpy(workspace(), &Workspace::windowAdded);
QSignalSpy windowRemovedSpy(workspace(), &Workspace::windowRemoved);
inputmethod: Add a test that simulates client switching
2021-07-30 18:29:01 +00:00
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QSignalSpy activateSpy(kwinApp()->inputMethod(), &InputMethod::activeChanged);
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
std::unique_ptr<KWayland::Client::TextInput> textInput(Test::waylandTextInputManager()->createTextInput(Test::waylandSeat()));
inputmethod: Add a test that simulates client switching
2021-07-30 18:29:01 +00:00
There's no QVector anymore, QList is the QVector in Qt6
2023-10-19 06:50:15 +00:00
QList<Window *> windows;
autotests/integration: use std::unique_ptr for wayland surfaces
2022-08-16 11:43:33 +00:00
std::vector<std::unique_ptr<KWayland::Client::Surface>> surfaces;
autotests: Port xdg-shell factory functions to unique_ptr
2024-03-10 14:32:54 +00:00
std::vector<std::unique_ptr<Test::XdgToplevel>> toplevels;
inputmethod: Add a test that simulates client switching
2021-07-30 18:29:01 +00:00
// We create 3 surfaces
for (int i = 0; i < 3; ++i) {
autotests/integration: use std::unique_ptr for wayland surfaces
2022-08-16 11:43:33 +00:00
std::unique_ptr<KWayland::Client::Surface> surface = Test::createSurface();
auto shellSurface = Test::createXdgToplevelSurface(surface.get());
windows += Test::renderAndWaitForShown(surface.get(), QSize(1280, 1024), Qt::red);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QCOMPARE(workspace()->activeWindow(), windows.constLast());
autotests/integration: use std::unique_ptr for wayland surfaces
2022-08-16 11:43:33 +00:00
surfaces.push_back(std::move(surface));
autotests: Port xdg-shell factory functions to unique_ptr
2024-03-10 14:32:54 +00:00
toplevels.push_back(std::move(shellSurface));
inputmethod: Add a test that simulates client switching
2021-07-30 18:29:01 +00:00
}
Prefer the term "window" over "client" in Workspace
2022-04-23 08:33:23 +00:00
QCOMPARE(windowAddedSpy.count(), 3);
autotests: client -> window
2022-04-23 19:51:16 +00:00
waylandServer()->seat()->setFocusedTextInputSurface(windows.constFirst()->surface());
inputmethod: Add a test that simulates client switching
2021-07-30 18:29:01 +00:00
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(!kwinApp()->inputMethod()->isActive());
autotests/integration: use std::unique_ptr for wayland surfaces
2022-08-16 11:43:33 +00:00
textInput->enable(surfaces.back().get());
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(!kwinApp()->inputMethod()->isActive());
autotests: client -> window
2022-04-23 19:51:16 +00:00
waylandServer()->seat()->setFocusedTextInputSurface(windows.first()->surface());
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(!kwinApp()->inputMethod()->isActive());
inputmethod: Add a test that simulates client switching
2021-07-30 18:29:01 +00:00
activateSpy.clear();
autotests: client -> window
2022-04-23 19:51:16 +00:00
waylandServer()->seat()->setFocusedTextInputSurface(windows.last()->surface());
inputmethod: Add a test that simulates client switching
2021-07-30 18:29:01 +00:00
QVERIFY(activateSpy.count() || activateSpy.wait());
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(kwinApp()->inputMethod()->isActive());
inputmethod: Add a test that simulates client switching
2021-07-30 18:29:01 +00:00
activateSpy.clear();
autotests: client -> window
2022-04-23 19:51:16 +00:00
waylandServer()->seat()->setFocusedTextInputSurface(windows.first()->surface());
inputmethod: Add a test that simulates client switching
2021-07-30 18:29:01 +00:00
QVERIFY(activateSpy.count() || activateSpy.wait());
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(!kwinApp()->inputMethod()->isActive());
inputmethod: Add a test that simulates client switching
2021-07-30 18:29:01 +00:00
}
Fix potential race condition when text input state change and focus change happened at the same time In some cases, stateCommitted may fire after a new surface being focused and in correctly set input method to be inactive. This can be reproduced by switch client between an active text input v3 client and text input v2 client.
2022-10-16 05:03:32 +00:00
void InputMethodTest::testV2V3SameClient()
{
touchNow();
QVERIFY(!kwinApp()->inputMethod()->isActive());
QSignalSpy windowAddedSpy(workspace(), &Workspace::windowAdded);
QSignalSpy windowRemovedSpy(workspace(), &Workspace::windowRemoved);
QSignalSpy activateSpy(kwinApp()->inputMethod(), &InputMethod::activeChanged);
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
std::unique_ptr<KWayland::Client::TextInput> textInput(Test::waylandTextInputManager()->createTextInput(Test::waylandSeat()));
Fix potential race condition when text input state change and focus change happened at the same time In some cases, stateCommitted may fire after a new surface being focused and in correctly set input method to be inactive. This can be reproduced by switch client between an active text input v3 client and text input v2 client.
2022-10-16 05:03:32 +00:00
auto textInputV3 = std::make_unique<Test::TextInputV3>();
textInputV3->init(Test::waylandTextInputManagerV3()->get_text_input(*(Test::waylandSeat())));
std::unique_ptr<KWayland::Client::Surface> surface = Test::createSurface();
std::unique_ptr<Test::XdgToplevel> toplevel(Test::createXdgToplevelSurface(surface.get()));
Window *window = Test::renderAndWaitForShown(surface.get(), QSize(1280, 1024), Qt::red);
QCOMPARE(workspace()->activeWindow(), window);
QCOMPARE(windowAddedSpy.count(), 1);
waylandServer()->seat()->setFocusedTextInputSurface(window->surface());
QVERIFY(!kwinApp()->inputMethod()->isActive());
// Enable and disable v2
textInput->enable(surface.get());
QVERIFY(activateSpy.count() || activateSpy.wait());
QVERIFY(kwinApp()->inputMethod()->isActive());
activateSpy.clear();
textInput->disable(surface.get());
QVERIFY(activateSpy.count() || activateSpy.wait());
QVERIFY(!kwinApp()->inputMethod()->isActive());
// Enable and disable v3
activateSpy.clear();
textInputV3->enable();
textInputV3->commit();
QVERIFY(activateSpy.count() || activateSpy.wait());
QVERIFY(kwinApp()->inputMethod()->isActive());
activateSpy.clear();
textInputV3->disable();
textInputV3->commit();
activateSpy.clear();
QVERIFY(activateSpy.count() || activateSpy.wait());
QVERIFY(!kwinApp()->inputMethod()->isActive());
// Enable v2 and v3
activateSpy.clear();
textInputV3->enable();
textInputV3->commit();
textInput->enable(surface.get());
QVERIFY(activateSpy.count() || activateSpy.wait());
QVERIFY(kwinApp()->inputMethod()->isActive());
// Disable v3, should still be active since v2 is active.
activateSpy.clear();
textInputV3->disable();
textInputV3->commit();
activateSpy.wait(200);
QVERIFY(kwinApp()->inputMethod()->isActive());
// Disable v2
activateSpy.clear();
textInput->disable(surface.get());
QVERIFY(activateSpy.count() || activateSpy.wait());
QVERIFY(!kwinApp()->inputMethod()->isActive());
toplevel.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(window));
Fix potential race condition when text input state change and focus change happened at the same time In some cases, stateCommitted may fire after a new surface being focused and in correctly set input method to be inactive. This can be reproduced by switch client between an active text input v3 client and text input v2 client.
2022-10-16 05:03:32 +00:00
}
Try our best to convert preedit styling to text-input-v3 cursor range. text-input-v3 does not have preedit styling, instead, it can only specify the range of cursor. Try to keep track of any highlight/selection style range and combine them together. If it matches the cursor position, use it as the cursor range.
2021-12-23 08:42:00 +00:00
void InputMethodTest::testV3Styling()
{
// Create an xdg_toplevel surface and wait for the compositor to catch up.
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()));
Window *window = Test::renderAndWaitForShown(surface.get(), QSize(1280, 1024), Qt::red);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window);
QVERIFY(window->isActive());
QCOMPARE(window->frameGeometry().size(), QSize(1280, 1024));
Try our best to convert preedit styling to text-input-v3 cursor range. text-input-v3 does not have preedit styling, instead, it can only specify the range of cursor. Try to keep track of any highlight/selection style range and combine them together. If it matches the cursor position, use it as the cursor range.
2021-12-23 08:42:00 +00:00
Fix potential race condition when text input state change and focus change happened at the same time In some cases, stateCommitted may fire after a new surface being focused and in correctly set input method to be inactive. This can be reproduced by switch client between an active text input v3 client and text input v2 client.
2022-10-16 05:03:32 +00:00
auto textInputV3 = std::make_unique<Test::TextInputV3>();
Try our best to convert preedit styling to text-input-v3 cursor range. text-input-v3 does not have preedit styling, instead, it can only specify the range of cursor. Try to keep track of any highlight/selection style range and combine them together. If it matches the cursor position, use it as the cursor range.
2021-12-23 08:42:00 +00:00
textInputV3->init(Test::waylandTextInputManagerV3()->get_text_input(*(Test::waylandSeat())));
textInputV3->enable();
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QSignalSpy inputMethodActiveSpy(kwinApp()->inputMethod(), &InputMethod::activeChanged);
Try our best to convert preedit styling to text-input-v3 cursor range. text-input-v3 does not have preedit styling, instead, it can only specify the range of cursor. Try to keep track of any highlight/selection style range and combine them together. If it matches the cursor position, use it as the cursor range.
2021-12-23 08:42:00 +00:00
QSignalSpy inputMethodActivateSpy(Test::inputMethod(), &Test::MockInputMethod::activate);
// just enabling the text-input should not show it but rather on commit
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(!kwinApp()->inputMethod()->isActive());
Try our best to convert preedit styling to text-input-v3 cursor range. text-input-v3 does not have preedit styling, instead, it can only specify the range of cursor. Try to keep track of any highlight/selection style range and combine them together. If it matches the cursor position, use it as the cursor range.
2021-12-23 08:42:00 +00:00
textInputV3->commit();
QVERIFY(inputMethodActiveSpy.count() || inputMethodActiveSpy.wait());
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(kwinApp()->inputMethod()->isActive());
Try our best to convert preedit styling to text-input-v3 cursor range. text-input-v3 does not have preedit styling, instead, it can only specify the range of cursor. Try to keep track of any highlight/selection style range and combine them together. If it matches the cursor position, use it as the cursor range.
2021-12-23 08:42:00 +00:00
QVERIFY(inputMethodActivateSpy.wait());
auto context = Test::inputMethod()->context();
Fix potential race condition when text input state change and focus change happened at the same time In some cases, stateCommitted may fire after a new surface being focused and in correctly set input method to be inactive. This can be reproduced by switch client between an active text input v3 client and text input v2 client.
2022-10-16 05:03:32 +00:00
QSignalSpy textInputPreeditSpy(textInputV3.get(), &Test::TextInputV3::preeditString);
Try our best to convert preedit styling to text-input-v3 cursor range. text-input-v3 does not have preedit styling, instead, it can only specify the range of cursor. Try to keep track of any highlight/selection style range and combine them together. If it matches the cursor position, use it as the cursor range.
2021-12-23 08:42:00 +00:00
zwp_input_method_context_v1_preedit_cursor(context, 0);
zwp_input_method_context_v1_preedit_styling(context, 0, 3, 7);
zwp_input_method_context_v1_preedit_string(context, 0, "ABCD", "ABCD");
QVERIFY(textInputPreeditSpy.wait());
QCOMPARE(textInputPreeditSpy.last().at(0), QString("ABCD"));
QCOMPARE(textInputPreeditSpy.last().at(1), 0);
QCOMPARE(textInputPreeditSpy.last().at(2), 0);
zwp_input_method_context_v1_preedit_cursor(context, 1);
zwp_input_method_context_v1_preedit_styling(context, 0, 3, 7);
zwp_input_method_context_v1_preedit_string(context, 0, "ABCDE", "ABCDE");
QVERIFY(textInputPreeditSpy.wait());
QCOMPARE(textInputPreeditSpy.last().at(0), QString("ABCDE"));
QCOMPARE(textInputPreeditSpy.last().at(1), 1);
QCOMPARE(textInputPreeditSpy.last().at(2), 1);
zwp_input_method_context_v1_preedit_cursor(context, 2);
// Use selection for [2, 2+2)
zwp_input_method_context_v1_preedit_styling(context, 2, 2, 6);
// Use high light for [3, 3+3)
zwp_input_method_context_v1_preedit_styling(context, 3, 3, 4);
zwp_input_method_context_v1_preedit_string(context, 0, "ABCDEF", "ABCDEF");
QVERIFY(textInputPreeditSpy.wait());
QCOMPARE(textInputPreeditSpy.last().at(0), QString("ABCDEF"));
// Merged range should be [2, 6)
QCOMPARE(textInputPreeditSpy.last().at(1), 2);
QCOMPARE(textInputPreeditSpy.last().at(2), 6);
zwp_input_method_context_v1_preedit_cursor(context, 2);
// Use selection for [0, 0+2)
zwp_input_method_context_v1_preedit_styling(context, 0, 2, 6);
// Use high light for [3, 3+3)
zwp_input_method_context_v1_preedit_styling(context, 3, 3, 4);
zwp_input_method_context_v1_preedit_string(context, 0, "ABCDEF", "ABCDEF");
QVERIFY(textInputPreeditSpy.wait());
QCOMPARE(textInputPreeditSpy.last().at(0), QString("ABCDEF"));
// Merged range should be none, because of the disjunction highlight.
QCOMPARE(textInputPreeditSpy.last().at(1), 2);
QCOMPARE(textInputPreeditSpy.last().at(2), 2);
zwp_input_method_context_v1_preedit_cursor(context, 1);
// Use selection for [0, 0+2)
zwp_input_method_context_v1_preedit_styling(context, 0, 2, 6);
// Use high light for [2, 2+3)
zwp_input_method_context_v1_preedit_styling(context, 2, 3, 4);
zwp_input_method_context_v1_preedit_string(context, 0, "ABCDEF", "ABCDEF");
QVERIFY(textInputPreeditSpy.wait());
QCOMPARE(textInputPreeditSpy.last().at(0), QString("ABCDEF"));
// Merged range should be none, starting offset does not match.
QCOMPARE(textInputPreeditSpy.last().at(1), 1);
QCOMPARE(textInputPreeditSpy.last().at(2), 1);
// Use different order of styling and cursor
// Use high light for [3, 3+3)
zwp_input_method_context_v1_preedit_styling(context, 3, 3, 4);
zwp_input_method_context_v1_preedit_cursor(context, 1);
// Use selection for [1, 1+2)
zwp_input_method_context_v1_preedit_styling(context, 1, 2, 6);
zwp_input_method_context_v1_preedit_string(context, 0, "ABCDEF", "ABCDEF");
QVERIFY(textInputPreeditSpy.wait());
QCOMPARE(textInputPreeditSpy.last().at(0), QString("ABCDEF"));
// Merged range should be [1,6).
QCOMPARE(textInputPreeditSpy.last().at(1), 1);
QCOMPARE(textInputPreeditSpy.last().at(2), 6);
inputmethod: Ensure InputPanelV1Window is always within the screen Currently when input panel is using overlay mode and the cursor rectangle is below or above the screen area, the input panel may be placed off the screen. The change ensure it is always placed within the screen area using similar math like xdg_popup's slide_y constrain.
2024-01-11 06:37:51 +00:00
shellSurface.reset();
QVERIFY(Test::waitForWindowClosed(window));
QVERIFY(!kwinApp()->inputMethod()->isActive());
Try our best to convert preedit styling to text-input-v3 cursor range. text-input-v3 does not have preedit styling, instead, it can only specify the range of cursor. Try to keep track of any highlight/selection style range and combine them together. If it matches the cursor position, use it as the cursor range.
2021-12-23 08:42:00 +00:00
}
Do not call setActive(true) when request input panel to show Observed in kdevelop, that isEnabled() could be false when switching between different tabs with Ctrl+Tab. But Qt may still call show() if you click on the texteditor widget. This leads to isEnabled == false but setActive(true) is called. This causes kdevelop in a usable state because keyboard grab will be created and no key event will reach application because isEnabled == false. Under normal circumstances, key will reach widget first and triggers another text_input_v2 enable to make input method work properly.
2021-12-23 22:33:30 +00:00
void InputMethodTest::testDisableShowInputPanel()
{
// Create an xdg_toplevel surface and wait for the compositor to catch up.
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()));
Window *window = Test::renderAndWaitForShown(surface.get(), QSize(1280, 1024), Qt::red);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window);
QVERIFY(window->isActive());
QCOMPARE(window->frameGeometry().size(), QSize(1280, 1024));
Do not call setActive(true) when request input panel to show Observed in kdevelop, that isEnabled() could be false when switching between different tabs with Ctrl+Tab. But Qt may still call show() if you click on the texteditor widget. This leads to isEnabled == false but setActive(true) is called. This causes kdevelop in a usable state because keyboard grab will be created and no key event will reach application because isEnabled == false. Under normal circumstances, key will reach widget first and triggers another text_input_v2 enable to make input method work properly.
2021-12-23 22:33:30 +00:00
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
std::unique_ptr<KWayland::Client::TextInput> textInputV2(Test::waylandTextInputManager()->createTextInput(Test::waylandSeat()));
Do not call setActive(true) when request input panel to show Observed in kdevelop, that isEnabled() could be false when switching between different tabs with Ctrl+Tab. But Qt may still call show() if you click on the texteditor widget. This leads to isEnabled == false but setActive(true) is called. This causes kdevelop in a usable state because keyboard grab will be created and no key event will reach application because isEnabled == false. Under normal circumstances, key will reach widget first and triggers another text_input_v2 enable to make input method work properly.
2021-12-23 22:33:30 +00:00
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QSignalSpy inputMethodActiveSpy(kwinApp()->inputMethod(), &InputMethod::activeChanged);
Do not call setActive(true) when request input panel to show Observed in kdevelop, that isEnabled() could be false when switching between different tabs with Ctrl+Tab. But Qt may still call show() if you click on the texteditor widget. This leads to isEnabled == false but setActive(true) is called. This causes kdevelop in a usable state because keyboard grab will be created and no key event will reach application because isEnabled == false. Under normal circumstances, key will reach widget first and triggers another text_input_v2 enable to make input method work properly.
2021-12-23 22:33:30 +00:00
// just enabling the text-input should not show it but rather on commit
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(!kwinApp()->inputMethod()->isActive());
Do not call setActive(true) when request input panel to show Observed in kdevelop, that isEnabled() could be false when switching between different tabs with Ctrl+Tab. But Qt may still call show() if you click on the texteditor widget. This leads to isEnabled == false but setActive(true) is called. This causes kdevelop in a usable state because keyboard grab will be created and no key event will reach application because isEnabled == false. Under normal circumstances, key will reach widget first and triggers another text_input_v2 enable to make input method work properly.
2021-12-23 22:33:30 +00:00
textInputV2->enable(surface.get());
QVERIFY(inputMethodActiveSpy.count() || inputMethodActiveSpy.wait());
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(kwinApp()->inputMethod()->isActive());
Do not call setActive(true) when request input panel to show Observed in kdevelop, that isEnabled() could be false when switching between different tabs with Ctrl+Tab. But Qt may still call show() if you click on the texteditor widget. This leads to isEnabled == false but setActive(true) is called. This causes kdevelop in a usable state because keyboard grab will be created and no key event will reach application because isEnabled == false. Under normal circumstances, key will reach widget first and triggers another text_input_v2 enable to make input method work properly.
2021-12-23 22:33:30 +00:00
// disable text input and ensure that it is not hiding input panel without commit
inputMethodActiveSpy.clear();
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(kwinApp()->inputMethod()->isActive());
Do not call setActive(true) when request input panel to show Observed in kdevelop, that isEnabled() could be false when switching between different tabs with Ctrl+Tab. But Qt may still call show() if you click on the texteditor widget. This leads to isEnabled == false but setActive(true) is called. This causes kdevelop in a usable state because keyboard grab will be created and no key event will reach application because isEnabled == false. Under normal circumstances, key will reach widget first and triggers another text_input_v2 enable to make input method work properly.
2021-12-23 22:33:30 +00:00
textInputV2->disable(surface.get());
QVERIFY(inputMethodActiveSpy.count() || inputMethodActiveSpy.wait());
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(!kwinApp()->inputMethod()->isActive());
Do not call setActive(true) when request input panel to show Observed in kdevelop, that isEnabled() could be false when switching between different tabs with Ctrl+Tab. But Qt may still call show() if you click on the texteditor widget. This leads to isEnabled == false but setActive(true) is called. This causes kdevelop in a usable state because keyboard grab will be created and no key event will reach application because isEnabled == false. Under normal circumstances, key will reach widget first and triggers another text_input_v2 enable to make input method work properly.
2021-12-23 22:33:30 +00:00
wayland: Integrate KWaylandServer classes into KWin namespace
2023-09-13 17:59:29 +00:00
QSignalSpy requestShowInputPanelSpy(waylandServer()->seat()->textInputV2(), &TextInputV2Interface::requestShowInputPanel);
Do not call setActive(true) when request input panel to show Observed in kdevelop, that isEnabled() could be false when switching between different tabs with Ctrl+Tab. But Qt may still call show() if you click on the texteditor widget. This leads to isEnabled == false but setActive(true) is called. This causes kdevelop in a usable state because keyboard grab will be created and no key event will reach application because isEnabled == false. Under normal circumstances, key will reach widget first and triggers another text_input_v2 enable to make input method work properly.
2021-12-23 22:33:30 +00:00
textInputV2->showInputPanel();
QVERIFY(requestShowInputPanelSpy.count() || requestShowInputPanelSpy.wait());
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(!kwinApp()->inputMethod()->isActive());
inputmethod: Ensure InputPanelV1Window is always within the screen Currently when input panel is using overlay mode and the cursor rectangle is below or above the screen area, the input panel may be placed off the screen. The change ensure it is always placed within the screen area using similar math like xdg_popup's slide_y constrain.
2024-01-11 06:37:51 +00:00
shellSurface.reset();
QVERIFY(Test::waitForWindowClosed(window));
Do not call setActive(true) when request input panel to show Observed in kdevelop, that isEnabled() could be false when switching between different tabs with Ctrl+Tab. But Qt may still call show() if you click on the texteditor widget. This leads to isEnabled == false but setActive(true) is called. This causes kdevelop in a usable state because keyboard grab will be created and no key event will reach application because isEnabled == false. Under normal circumstances, key will reach widget first and triggers another text_input_v2 enable to make input method work properly.
2021-12-23 22:33:30 +00:00
}
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
void InputMethodTest::testModifierForwarding()
{
// Create an xdg_toplevel surface and wait for the compositor to catch up.
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()));
Window *window = Test::renderAndWaitForShown(surface.get(), QSize(1280, 1024), Qt::red);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window);
QVERIFY(window->isActive());
QCOMPARE(window->frameGeometry().size(), QSize(1280, 1024));
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
Fix potential race condition when text input state change and focus change happened at the same time In some cases, stateCommitted may fire after a new surface being focused and in correctly set input method to be inactive. This can be reproduced by switch client between an active text input v3 client and text input v2 client.
2022-10-16 05:03:32 +00:00
auto textInputV3 = std::make_unique<Test::TextInputV3>();
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
textInputV3->init(Test::waylandTextInputManagerV3()->get_text_input(*(Test::waylandSeat())));
textInputV3->enable();
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QSignalSpy inputMethodActiveSpy(kwinApp()->inputMethod(), &InputMethod::activeChanged);
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
QSignalSpy inputMethodActivateSpy(Test::inputMethod(), &Test::MockInputMethod::activate);
// just enabling the text-input should not show it but rather on commit
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(!kwinApp()->inputMethod()->isActive());
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
textInputV3->commit();
QVERIFY(inputMethodActiveSpy.count() || inputMethodActiveSpy.wait());
move InputMethod singleton to Application
2022-07-20 10:14:27 +00:00
QVERIFY(kwinApp()->inputMethod()->isActive());
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
QVERIFY(inputMethodActivateSpy.wait());
auto context = Test::inputMethod()->context();
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
std::unique_ptr<KWayland::Client::Keyboard> keyboardGrab(new KWayland::Client::Keyboard);
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
keyboardGrab->setup(zwp_input_method_context_v1_grab_keyboard(context));
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
QSignalSpy modifierSpy(keyboardGrab.get(), &KWayland::Client::Keyboard::modifiersChanged);
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
// Wait for initial modifiers update
QVERIFY(modifierSpy.wait());
quint32 timestamp = 1;
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
QSignalSpy keySpy(keyboardGrab.get(), &KWayland::Client::Keyboard::keyChanged);
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
bool keyChanged = false;
bool modifiersChanged = false;
// We want to verify the order of two signals, so SignalSpy is not very useful here.
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
auto keyChangedConnection = connect(keyboardGrab.get(), &KWayland::Client::Keyboard::keyChanged, [&keyChanged, &modifiersChanged]() {
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
QVERIFY(!modifiersChanged);
keyChanged = true;
});
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
auto modifiersChangedConnection = connect(keyboardGrab.get(), &KWayland::Client::Keyboard::modifiersChanged, [&keyChanged, &modifiersChanged]() {
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
QVERIFY(keyChanged);
modifiersChanged = true;
});
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
QVERIFY(keySpy.count() == 1 || keySpy.wait());
QVERIFY(modifierSpy.count() == 2 || modifierSpy.wait());
disconnect(keyChangedConnection);
disconnect(modifiersChangedConnection);
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyPressed(KEY_A, timestamp++);
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
QVERIFY(keySpy.count() == 2 || keySpy.wait());
QVERIFY(modifierSpy.count() == 2 || modifierSpy.wait());
// verify the order of key and modifiers again. Key first, then modifiers.
keyChanged = false;
modifiersChanged = false;
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
keyChangedConnection = connect(keyboardGrab.get(), &KWayland::Client::Keyboard::keyChanged, [&keyChanged, &modifiersChanged]() {
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
QVERIFY(!modifiersChanged);
keyChanged = true;
});
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
modifiersChangedConnection = connect(keyboardGrab.get(), &KWayland::Client::Keyboard::modifiersChanged, [&keyChanged, &modifiersChanged]() {
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
QVERIFY(keyChanged);
modifiersChanged = true;
});
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
QVERIFY(keySpy.count() == 3 || keySpy.wait());
QVERIFY(modifierSpy.count() == 3 || modifierSpy.wait());
disconnect(keyChangedConnection);
disconnect(modifiersChangedConnection);
inputmethod: Ensure InputPanelV1Window is always within the screen Currently when input panel is using overlay mode and the cursor rectangle is below or above the screen area, the input panel may be placed off the screen. The change ensure it is always placed within the screen area using similar math like xdg_popup's slide_y constrain.
2024-01-11 06:37:51 +00:00
shellSurface.reset();
QVERIFY(Test::waitForWindowClosed(window));
QVERIFY(!kwinApp()->inputMethod()->isActive());
Ensure modifier change is forwarded after the key sending to input method. Same as real hardware wl_keyboard, key should be sent before modifier change. For example, Left Ctrl press and release should produce key events in the order of Control_L and Control+Control_L.
2021-12-29 17:19:43 +00:00
}
Add a fallback path for input when there is no text-input An application that does not support text-input has no way of communicating with the input method, so even if you show the input method the application receives nothing. As a fallback, instead send fake key events so the application still gets something at least. The key events are synthesised based on the text string that the input method sends, which may result in things that do not actually correspond to real keys. Unfortunately I do not see a way around that. CCBUG: 439911
2022-05-17 11:53:13 +00:00
void InputMethodTest::testFakeEventFallback()
{
// Create an xdg_toplevel surface and wait for the compositor to catch up.
std::unique_ptr<KWayland::Client::Surface> surface = Test::createSurface();
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
Window *window = Test::renderAndWaitForShown(surface.get(), QSize(1280, 1024), Qt::red);
QVERIFY(window);
QVERIFY(window->isActive());
QCOMPARE(window->frameGeometry().size(), QSize(1280, 1024));
// Since we don't have a way to communicate with the client, manually activate
// the input method.
QSignalSpy inputMethodActiveSpy(Test::inputMethod(), &Test::MockInputMethod::activate);
kwinApp()->inputMethod()->setActive(true);
QVERIFY(inputMethodActiveSpy.count() || inputMethodActiveSpy.wait());
// Without a way to communicate to the client, we send fake key events. This
// means the client needs to be able to receive them, so create a keyboard for
// the client and listen whether it gets the right events.
auto keyboard = Test::waylandSeat()->createKeyboard(window);
QSignalSpy keySpy(keyboard, &KWayland::Client::Keyboard::keyChanged);
auto context = Test::inputMethod()->context();
QVERIFY(context);
// First, send a simple one-character string and check to see if that
// generates a key press followed by a key release on the client side.
zwp_input_method_context_v1_commit_string(context, 0, "a");
keySpy.wait();
QVERIFY(keySpy.count() == 2);
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
auto compare = [](const QList<QVariant> &input, quint32 key, KWayland::Client::Keyboard::KeyState state) {
Add a fallback path for input when there is no text-input An application that does not support text-input has no way of communicating with the input method, so even if you show the input method the application receives nothing. As a fallback, instead send fake key events so the application still gets something at least. The key events are synthesised based on the text string that the input method sends, which may result in things that do not actually correspond to real keys. Unfortunately I do not see a way around that. CCBUG: 439911
2022-05-17 11:53:13 +00:00
auto inputKey = input.at(0).toInt();
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
auto inputState = input.at(1).value<KWayland::Client::Keyboard::KeyState>();
Add a fallback path for input when there is no text-input An application that does not support text-input has no way of communicating with the input method, so even if you show the input method the application receives nothing. As a fallback, instead send fake key events so the application still gets something at least. The key events are synthesised based on the text string that the input method sends, which may result in things that do not actually correspond to real keys. Unfortunately I do not see a way around that. CCBUG: 439911
2022-05-17 11:53:13 +00:00
QCOMPARE(inputKey, key);
QCOMPARE(inputState, state);
};
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
compare(keySpy.at(0), KEY_A, KWayland::Client::Keyboard::KeyState::Pressed);
compare(keySpy.at(1), KEY_A, KWayland::Client::Keyboard::KeyState::Released);
Add a fallback path for input when there is no text-input An application that does not support text-input has no way of communicating with the input method, so even if you show the input method the application receives nothing. As a fallback, instead send fake key events so the application still gets something at least. The key events are synthesised based on the text string that the input method sends, which may result in things that do not actually correspond to real keys. Unfortunately I do not see a way around that. CCBUG: 439911
2022-05-17 11:53:13 +00:00
keySpy.clear();
// Capital letters are recognised and sent as a combination of Shift + the
// letter.
zwp_input_method_context_v1_commit_string(context, 0, "A");
keySpy.wait();
QVERIFY(keySpy.count() == 4);
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
compare(keySpy.at(0), KEY_LEFTSHIFT, KWayland::Client::Keyboard::KeyState::Pressed);
compare(keySpy.at(1), KEY_A, KWayland::Client::Keyboard::KeyState::Pressed);
compare(keySpy.at(2), KEY_A, KWayland::Client::Keyboard::KeyState::Released);
compare(keySpy.at(3), KEY_LEFTSHIFT, KWayland::Client::Keyboard::KeyState::Released);
Add a fallback path for input when there is no text-input An application that does not support text-input has no way of communicating with the input method, so even if you show the input method the application receives nothing. As a fallback, instead send fake key events so the application still gets something at least. The key events are synthesised based on the text string that the input method sends, which may result in things that do not actually correspond to real keys. Unfortunately I do not see a way around that. CCBUG: 439911
2022-05-17 11:53:13 +00:00
keySpy.clear();
// Special keys are not sent through commit_string but instead use keysym.
auto enter = input()->keyboard()->xkb()->toKeysym(KEY_ENTER);
wayland: Integrate KWaylandServer classes into KWin namespace
2023-09-13 17:59:29 +00:00
zwp_input_method_context_v1_keysym(context, 0, 0, enter, uint32_t(KeyboardKeyState::Pressed), 0);
zwp_input_method_context_v1_keysym(context, 0, 1, enter, uint32_t(KeyboardKeyState::Released), 0);
Add a fallback path for input when there is no text-input An application that does not support text-input has no way of communicating with the input method, so even if you show the input method the application receives nothing. As a fallback, instead send fake key events so the application still gets something at least. The key events are synthesised based on the text string that the input method sends, which may result in things that do not actually correspond to real keys. Unfortunately I do not see a way around that. CCBUG: 439911
2022-05-17 11:53:13 +00:00
keySpy.wait();
QVERIFY(keySpy.count() == 2);
autotests: Reduce the number of "using namespace KWayland::Client" KWayland::Client has ambiguous type names such as "Compositor" or "Output". Use full types to improve code readability.
2022-11-07 21:33:00 +00:00
compare(keySpy.at(0), KEY_ENTER, KWayland::Client::Keyboard::KeyState::Pressed);
compare(keySpy.at(1), KEY_ENTER, KWayland::Client::Keyboard::KeyState::Released);
inputmethod: Ensure InputPanelV1Window is always within the screen Currently when input panel is using overlay mode and the cursor rectangle is below or above the screen area, the input panel may be placed off the screen. The change ensure it is always placed within the screen area using similar math like xdg_popup's slide_y constrain.
2024-01-11 06:37:51 +00:00
shellSurface.reset();
QVERIFY(Test::waitForWindowClosed(window));
kwinApp()->inputMethod()->setActive(false);
QVERIFY(!kwinApp()->inputMethod()->isActive());
}
void InputMethodTest::testOverlayPositioning_data()
{
QTest::addColumn<QRect>("cursorRectangle");
QTest::addColumn<QRect>("result");
QTest::newRow("regular") << QRect(10, 20, 30, 40) << QRect(60, 160, 200, 50);
QTest::newRow("offscreen-left") << QRect(-200, 40, 30, 40) << QRect(0, 180, 200, 50);
QTest::newRow("offscreen-right") << QRect(1200, 40, 30, 40) << QRect(1080, 180, 200, 50);
QTest::newRow("offscreen-top") << QRect(1200, -400, 30, 40) << QRect(1080, 0, 200, 50);
// Check it is flipped near the bottom of screen (anchor point 844 + 100 + 40 = 1024 - 40)
QTest::newRow("offscreen-bottom-flip") << QRect(1200, 844, 30, 40) << QRect(1080, 894, 200, 50);
// Top is (screen height 1024 - window height 50) = 984
QTest::newRow("offscreen-bottom-slide") << QRect(1200, 1200, 30, 40) << QRect(1080, 974, 200, 50);
}
void InputMethodTest::testOverlayPositioning()
{
QFETCH(QRect, cursorRectangle);
QFETCH(QRect, result);
Test::inputMethod()->setMode(Test::MockInputMethod::Mode::Overlay);
QVERIFY(!kwinApp()->inputMethod()->isActive());
touchNow();
QSignalSpy windowAddedSpy(workspace(), &Workspace::windowAdded);
QSignalSpy windowRemovedSpy(workspace(), &Workspace::windowRemoved);
QSignalSpy activateSpy(kwinApp()->inputMethod(), &InputMethod::activeChanged);
std::unique_ptr<KWayland::Client::TextInput> textInput(Test::waylandTextInputManager()->createTextInput(Test::waylandSeat()));
// Create an xdg_toplevel surface and wait for the compositor to catch up.
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
// Make the window smaller than the screen and move it.
Window *window = Test::renderAndWaitForShown(surface.get(), QSize(1080, 824), Qt::red);
window->move(QPointF(50, 100));
waylandServer()->seat()->setFocusedTextInputSurface(window->surface());
textInput->setCursorRectangle(cursorRectangle);
textInput->enable(surface.get());
// Overlay is shown upon activate
QVERIFY(windowAddedSpy.wait());
QCOMPARE(workspace()->activeWindow(), window);
QCOMPARE(windowAddedSpy.count(), 2);
QVERIFY(activateSpy.count() || activateSpy.wait());
QVERIFY(kwinApp()->inputMethod()->isActive());
auto keyboardWindow = kwinApp()->inputMethod()->panel();
QVERIFY(keyboardWindow);
// Check the overlay window is placed with cursor rectangle + window position.
QCOMPARE(keyboardWindow->frameGeometry(), result);
// Destroy the test window.
shellSurface.reset();
QVERIFY(Test::waitForWindowClosed(window));
Test::inputMethod()->setMode(Test::MockInputMethod::Mode::TopLevel);
Add a fallback path for input when there is no text-input An application that does not support text-input has no way of communicating with the input method, so even if you show the input method the application receives nothing. As a fallback, instead send fake key events so the application still gets something at least. The key events are synthesised based on the text string that the input method sends, which may result in things that do not actually correspond to real keys. Unfortunately I do not see a way around that. CCBUG: 439911
2022-05-17 11:53:13 +00:00
}
autotests: rename to testInputMethod Relevant class got renamed, also update the test name Related: plasma/kwin!302
2020-09-30 10:28:42 +00:00
WAYLANDTEST_MAIN(InputMethodTest)
Fix size restore upon keyboard close in XdgSurfaceClient in XdgSurfaceClient setFrameGeometry is async, so we can't rely on it having the final value immediately. make setVirtualKeyboardGeometry a virtual. in the implementation on setVirtualKeyboardGeometry use requestedFrameGeometry() instead of frameGeometry()
2020-09-01 08:58:46 +00:00
Fix build
2020-09-30 10:46:32 +00:00
#include "inputmethod_test.moc"
Reference in a new issue Copy permalink