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

496 lines
16 KiB
C++
Raw Normal View History

server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
/*
SPDX-FileCopyrightText: 2020 Bhushan Shah <bshah@kde.org>
SPDX-FileCopyrightText: 2018 Roman Glig <subdiff@gmail.com>
SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
*/
#include "display.h"
wayland: Drop "_interface" from filenames The cpp files in the wayland directory are named after protocol names. "_interface" does not contribute anything new.
2023-09-13 05:52:59 +00:00
#include "seat.h"
#include "surface_p.h"
#include "textinput_v3_p.h"
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
wayland: Integrate KWaylandServer classes into KWin namespace
2023-09-13 17:59:29 +00:00
namespace KWin
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
{
Fix testTextInputV3Interface Put EnableEmitter in the anonymous namespace to avoid it to be linked to the wrong implementation.
2022-01-04 19:24:45 +00:00
namespace
{
const quint32 s_version = 1;
Use global static variables to store protocol version s_version is used only to initialize a global so there is no point for storing protocol version in a static member field and use funky syntax in the cpp file to initialize it. This change also simplifies the code.
2020-10-02 06:59:57 +00:00
Fix testTextInputV3Interface Put EnableEmitter in the anonymous namespace to avoid it to be linked to the wrong implementation.
2022-01-04 19:24:45 +00:00
TextInputContentHints convertContentHint(uint32_t hint)
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
{
Address warnings |-operator on bool Comparison on technically different enums.
2022-10-31 11:23:57 +00:00
const auto hints = QtWaylandServer::zwp_text_input_v3::content_hint(hint);
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
TextInputContentHints ret = TextInputContentHint::None;
if (hints & QtWaylandServer::zwp_text_input_v3::content_hint_completion) {
ret |= TextInputContentHint::AutoCompletion;
}
if (hints & QtWaylandServer::zwp_text_input_v3::content_hint_auto_capitalization) {
ret |= TextInputContentHint::AutoCapitalization;
}
if (hints & QtWaylandServer::zwp_text_input_v3::content_hint_lowercase) {
ret |= TextInputContentHint::LowerCase;
}
if (hints & QtWaylandServer::zwp_text_input_v3::content_hint_uppercase) {
ret |= TextInputContentHint::UpperCase;
}
if (hints & QtWaylandServer::zwp_text_input_v3::content_hint_titlecase) {
ret |= TextInputContentHint::TitleCase;
}
if (hints & QtWaylandServer::zwp_text_input_v3::content_hint_hidden_text) {
ret |= TextInputContentHint::HiddenText;
}
if (hints & QtWaylandServer::zwp_text_input_v3::content_hint_sensitive_data) {
ret |= TextInputContentHint::SensitiveData;
}
if (hints & QtWaylandServer::zwp_text_input_v3::content_hint_latin) {
ret |= TextInputContentHint::Latin;
}
if (hints & QtWaylandServer::zwp_text_input_v3::content_hint_multiline) {
ret |= TextInputContentHint::MultiLine;
}
if (hints & QtWaylandServer::zwp_text_input_v3::content_hint_spellcheck) {
ret |= TextInputContentHint::AutoCorrection;
}
return ret;
}
Fix testTextInputV3Interface Put EnableEmitter in the anonymous namespace to avoid it to be linked to the wrong implementation.
2022-01-04 19:24:45 +00:00
TextInputContentPurpose convertContentPurpose(uint32_t purpose)
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
{
const auto wlPurpose = QtWaylandServer::zwp_text_input_v3::content_purpose(purpose);
switch (wlPurpose) {
case QtWaylandServer::zwp_text_input_v3::content_purpose_alpha:
return TextInputContentPurpose::Alpha;
case QtWaylandServer::zwp_text_input_v3::content_purpose_digits:
return TextInputContentPurpose::Digits;
case QtWaylandServer::zwp_text_input_v3::content_purpose_number:
return TextInputContentPurpose::Number;
case QtWaylandServer::zwp_text_input_v3::content_purpose_phone:
return TextInputContentPurpose::Phone;
case QtWaylandServer::zwp_text_input_v3::content_purpose_url:
return TextInputContentPurpose::Url;
case QtWaylandServer::zwp_text_input_v3::content_purpose_email:
return TextInputContentPurpose::Email;
case QtWaylandServer::zwp_text_input_v3::content_purpose_name:
return TextInputContentPurpose::Name;
case QtWaylandServer::zwp_text_input_v3::content_purpose_password:
return TextInputContentPurpose::Password;
case QtWaylandServer::zwp_text_input_v3::content_purpose_pin:
return TextInputContentPurpose::Pin;
case QtWaylandServer::zwp_text_input_v3::content_purpose_date:
return TextInputContentPurpose::Date;
case QtWaylandServer::zwp_text_input_v3::content_purpose_time:
return TextInputContentPurpose::Time;
case QtWaylandServer::zwp_text_input_v3::content_purpose_datetime:
return TextInputContentPurpose::DateTime;
case QtWaylandServer::zwp_text_input_v3::content_purpose_terminal:
return TextInputContentPurpose::Terminal;
case QtWaylandServer::zwp_text_input_v3::content_purpose_normal:
return TextInputContentPurpose::Normal;
default:
return TextInputContentPurpose::Normal;
}
}
Fix testTextInputV3Interface Put EnableEmitter in the anonymous namespace to avoid it to be linked to the wrong implementation.
2022-01-04 19:24:45 +00:00
TextInputChangeCause convertChangeCause(uint32_t cause)
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
{
const auto wlCause = QtWaylandServer::zwp_text_input_v3::change_cause(cause);
switch (wlCause) {
case QtWaylandServer::zwp_text_input_v3::change_cause_input_method:
return TextInputChangeCause::InputMethod;
case QtWaylandServer::zwp_text_input_v3::change_cause_other:
default:
return TextInputChangeCause::Other;
}
}
Fix testTextInputV3Interface Put EnableEmitter in the anonymous namespace to avoid it to be linked to the wrong implementation.
2022-01-04 19:24:45 +00:00
}
TextInputManagerV3InterfacePrivate::TextInputManagerV3InterfacePrivate(TextInputManagerV3Interface *_q, Display *display)
: QtWaylandServer::zwp_text_input_manager_v3(*display, s_version)
, q(_q)
{
}
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
void TextInputManagerV3InterfacePrivate::zwp_text_input_manager_v3_destroy(Resource *resource)
{
wl_resource_destroy(resource->handle);
}
void TextInputManagerV3InterfacePrivate::zwp_text_input_manager_v3_get_text_input(Resource *resource, uint32_t id, wl_resource *seat)
{
SeatInterface *s = SeatInterface::get(seat);
if (!s) {
wl_resource_post_error(resource->handle, 0, "Invalid seat");
return;
}
TextInputV3InterfacePrivate *textInputPrivate = TextInputV3InterfacePrivate::get(s->textInputV3());
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
auto *textInputResource = textInputPrivate->add(resource->client(), id, resource->version());
// Send enter to this new text input object if the surface is already focused.
if (textInputPrivate->surface && textInputPrivate->surface->client()->client() == resource->client()) {
textInputPrivate->send_enter(textInputResource->handle, textInputPrivate->surface->resource());
}
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
}
Run clang-format If you want git blame to ignore formatting revisions run: git config blame.ignoreRevsFile .git-blame-ignore-revs
2021-08-29 05:11:06 +00:00
TextInputManagerV3Interface::TextInputManagerV3Interface(Display *display, QObject *parent)
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
: QObject(parent)
, d(new TextInputManagerV3InterfacePrivate(this, display))
{
}
TextInputManagerV3Interface::~TextInputManagerV3Interface() = default;
TextInputV3InterfacePrivate::TextInputV3InterfacePrivate(SeatInterface *seat, TextInputV3Interface *_q)
: seat(seat)
, q(_q)
{
}
text-input-v3: track commit counts per resource If we track the commit counts at compositor global, this will fail horribly for anything other than the first text-input-v3 client, as for new client the serial count will not be what it expects in the done() request and it will simply consider events as outdated and will refuse to accept those events
2020-10-07 03:19:15 +00:00
void TextInputV3InterfacePrivate::zwp_text_input_v3_bind_resource(Resource *resource)
{
// we initialize the serial for the resource to be 0
serialHash.insert(resource, 0);
wayland: Disable text-input-v3 when it's destroyed Destroying a zwp_text_input_v3 object should be viewed as disabling it. isEnabled property is cached because it cannot be computed in _destroy_resource() handler. By that time, the resource no longer will be in resourceMap(), so TextInputV3InterfacePrivate::isEnabled() will erroneously return false even though we expect true.
2023-03-22 15:45:17 +00:00
enabledHash.insert(resource, false);
text-input-v3: track commit counts per resource If we track the commit counts at compositor global, this will fail horribly for anything other than the first text-input-v3 client, as for new client the serial count will not be what it expects in the done() request and it will simply consider events as outdated and will refuse to accept those events
2020-10-07 03:19:15 +00:00
}
wayland: Disable text-input-v3 when it's destroyed Destroying a zwp_text_input_v3 object should be viewed as disabling it. isEnabled property is cached because it cannot be computed in _destroy_resource() handler. By that time, the resource no longer will be in resourceMap(), so TextInputV3InterfacePrivate::isEnabled() will erroneously return false even though we expect true.
2023-03-22 15:45:17 +00:00
void TextInputV3InterfacePrivate::zwp_text_input_v3_destroy_resource(Resource *resource)
text-input-v3: track commit counts per resource If we track the commit counts at compositor global, this will fail horribly for anything other than the first text-input-v3 client, as for new client the serial count will not be what it expects in the done() request and it will simply consider events as outdated and will refuse to accept those events
2020-10-07 03:19:15 +00:00
{
// drop resource from the serial hash
serialHash.remove(resource);
wayland: Disable text-input-v3 when it's destroyed Destroying a zwp_text_input_v3 object should be viewed as disabling it. isEnabled property is cached because it cannot be computed in _destroy_resource() handler. By that time, the resource no longer will be in resourceMap(), so TextInputV3InterfacePrivate::isEnabled() will erroneously return false even though we expect true.
2023-03-22 15:45:17 +00:00
enabledHash.remove(resource);
updateEnabled();
}
void TextInputV3InterfacePrivate::zwp_text_input_v3_destroy(Resource *resource)
{
wl_resource_destroy(resource->handle);
text-input-v3: track commit counts per resource If we track the commit counts at compositor global, this will fail horribly for anything other than the first text-input-v3 client, as for new client the serial count will not be what it expects in the done() request and it will simply consider events as outdated and will refuse to accept those events
2020-10-07 03:19:15 +00:00
}
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
void TextInputV3InterfacePrivate::sendEnter(SurfaceInterface *newSurface)
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
{
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
// It should be always synchronized with SeatInterface::focusedTextInputSurface.
Q_ASSERT(!surface && newSurface);
surface = newSurface;
const auto clientResources = textInputsForClient(newSurface->client());
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
for (auto resource : clientResources) {
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
send_enter(resource->handle, newSurface->resource());
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
}
wayland: Disable text-input-v3 when it's destroyed Destroying a zwp_text_input_v3 object should be viewed as disabling it. isEnabled property is cached because it cannot be computed in _destroy_resource() handler. By that time, the resource no longer will be in resourceMap(), so TextInputV3InterfacePrivate::isEnabled() will erroneously return false even though we expect true.
2023-03-22 15:45:17 +00:00
updateEnabled();
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
}
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
void TextInputV3InterfacePrivate::sendLeave(SurfaceInterface *leavingSurface)
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
{
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
// It should be always synchronized with SeatInterface::focusedTextInputSurface.
Q_ASSERT(leavingSurface && surface == leavingSurface);
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
surface.clear();
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
const auto clientResources = textInputsForClient(leavingSurface->client());
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
for (auto resource : clientResources) {
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
send_leave(resource->handle, leavingSurface->resource());
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
}
wayland: Disable text-input-v3 when it's destroyed Destroying a zwp_text_input_v3 object should be viewed as disabling it. isEnabled property is cached because it cannot be computed in _destroy_resource() handler. By that time, the resource no longer will be in resourceMap(), so TextInputV3InterfacePrivate::isEnabled() will erroneously return false even though we expect true.
2023-03-22 15:45:17 +00:00
updateEnabled();
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
}
void TextInputV3InterfacePrivate::sendPreEdit(const QString &text, const quint32 cursorBegin, const quint32 cursorEnd)
{
if (!surface) {
return;
}
Always send a done after commit for text input v3. In Gtk's text-input-v3 implementation it expect done to update the client serial after every commit. Though it is unclear whether this is a protocol requirements, do the same thing like mutter for more compatiblity, especially Gtk3 is in EOL not likely to be patched any time soon. To do so, we will need to keep track of the last active preedit, otherwise only send_done() will clear the preedit.
2022-06-10 23:23:52 +00:00
pending.preeditText = text;
pending.preeditCursorBegin = cursorBegin;
pending.preeditCursorEnd = cursorEnd;
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
const QList<Resource *> textInputs = enabledTextInputsForClient(surface->client());
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
for (auto resource : textInputs) {
send_preedit_string(resource->handle, text, cursorBegin, cursorEnd);
}
}
void TextInputV3InterfacePrivate::commitString(const QString &text)
{
if (!surface) {
return;
}
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
const QList<Resource *> textInputs = enabledTextInputsForClient(surface->client());
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
for (auto resource : textInputs) {
send_commit_string(resource->handle, text);
}
}
void TextInputV3InterfacePrivate::deleteSurroundingText(quint32 before, quint32 after)
{
if (!surface) {
return;
}
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
const QList<Resource *> textInputs = enabledTextInputsForClient(surface->client());
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
for (auto resource : textInputs) {
send_delete_surrounding_text(resource->handle, before, after);
}
}
void TextInputV3InterfacePrivate::done()
{
if (!surface) {
return;
}
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
const QList<Resource *> textInputs = enabledTextInputsForClient(surface->client());
Always send a done after commit for text input v3. In Gtk's text-input-v3 implementation it expect done to update the client serial after every commit. Though it is unclear whether this is a protocol requirements, do the same thing like mutter for more compatiblity, especially Gtk3 is in EOL not likely to be patched any time soon. To do so, we will need to keep track of the last active preedit, otherwise only send_done() will clear the preedit.
2022-06-10 23:23:52 +00:00
preeditText = pending.preeditText;
preeditCursorBegin = pending.preeditCursorBegin;
preeditCursorEnd = pending.preeditCursorEnd;
defaultPendingPreedit();
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
for (auto resource : textInputs) {
// zwp_text_input_v3.done takes the serial argument which is equal to number of commit requests issued
text-input-v3: track commit counts per resource If we track the commit counts at compositor global, this will fail horribly for anything other than the first text-input-v3 client, as for new client the serial count will not be what it expects in the done() request and it will simply consider events as outdated and will refuse to accept those events
2020-10-07 03:19:15 +00:00
send_done(resource->handle, serialHash[resource]);
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
}
}
QList<TextInputV3InterfacePrivate::Resource *> TextInputV3InterfacePrivate::textInputsForClient(ClientConnection *client) const
{
return resourceMap().values(client->client());
}
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
QList<TextInputV3InterfacePrivate::Resource *> TextInputV3InterfacePrivate::enabledTextInputsForClient(ClientConnection *client) const
{
QList<TextInputV3InterfacePrivate::Resource *> result;
const auto [start, end] = resourceMap().equal_range(client->client());
for (auto it = start; it != end; ++it) {
wayland: Disable text-input-v3 when it's destroyed Destroying a zwp_text_input_v3 object should be viewed as disabling it. isEnabled property is cached because it cannot be computed in _destroy_resource() handler. By that time, the resource no longer will be in resourceMap(), so TextInputV3InterfacePrivate::isEnabled() will erroneously return false even though we expect true.
2023-03-22 15:45:17 +00:00
if (enabledHash[*it]) {
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
result.append(*it);
}
}
return result;
}
wayland: Disable text-input-v3 when it's destroyed Destroying a zwp_text_input_v3 object should be viewed as disabling it. isEnabled property is cached because it cannot be computed in _destroy_resource() handler. By that time, the resource no longer will be in resourceMap(), so TextInputV3InterfacePrivate::isEnabled() will erroneously return false even though we expect true.
2023-03-22 15:45:17 +00:00
void TextInputV3InterfacePrivate::updateEnabled()
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
{
wayland: Disable text-input-v3 when it's destroyed Destroying a zwp_text_input_v3 object should be viewed as disabling it. isEnabled property is cached because it cannot be computed in _destroy_resource() handler. By that time, the resource no longer will be in resourceMap(), so TextInputV3InterfacePrivate::isEnabled() will erroneously return false even though we expect true.
2023-03-22 15:45:17 +00:00
bool newEnabled = false;
if (surface) {
const auto clientResources = textInputsForClient(surface->client());
newEnabled = std::any_of(clientResources.begin(), clientResources.end(), [this](Resource *resource) {
return enabledHash[resource];
});
}
if (isEnabled != newEnabled) {
isEnabled = newEnabled;
Q_EMIT q->enabledChanged();
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
}
}
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
void TextInputV3InterfacePrivate::zwp_text_input_v3_enable(Resource *resource)
{
// reset pending state to default
defaultPending();
pending.enabled = true;
}
void TextInputV3InterfacePrivate::zwp_text_input_v3_disable(Resource *resource)
{
// reset pending state to default
defaultPending();
Always send a done after commit for text input v3. In Gtk's text-input-v3 implementation it expect done to update the client serial after every commit. Though it is unclear whether this is a protocol requirements, do the same thing like mutter for more compatiblity, especially Gtk3 is in EOL not likely to be patched any time soon. To do so, we will need to keep track of the last active preedit, otherwise only send_done() will clear the preedit.
2022-06-10 23:23:52 +00:00
preeditText = QString();
preeditCursorBegin = 0;
preeditCursorEnd = 0;
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
}
void TextInputV3InterfacePrivate::zwp_text_input_v3_set_surrounding_text(Resource *resource, const QString &text, int32_t cursor, int32_t anchor)
{
// zwp_text_input_v3_set_surrounding_text is no-op if enabled request is not pending
if (!pending.enabled) {
return;
}
pending.surroundingText = text;
pending.surroundingTextCursorPosition = cursor;
pending.surroundingTextSelectionAnchor = anchor;
}
void TextInputV3InterfacePrivate::zwp_text_input_v3_set_content_type(Resource *resource, uint32_t hint, uint32_t purpose)
{
// zwp_text_input_v3_set_content_type is no-op if enabled request is not pending
if (!pending.enabled) {
return;
}
pending.contentHints = convertContentHint(hint);
pending.contentPurpose = convertContentPurpose(purpose);
}
void TextInputV3InterfacePrivate::zwp_text_input_v3_set_cursor_rectangle(Resource *resource, int32_t x, int32_t y, int32_t width, int32_t height)
{
// zwp_text_input_v3_set_cursor_rectangle is no-op if enabled request is not pending
if (!pending.enabled) {
return;
}
pending.cursorRectangle = QRect(x, y, width, height);
}
void TextInputV3InterfacePrivate::zwp_text_input_v3_set_text_change_cause(Resource *resource, uint32_t cause)
{
// zwp_text_input_v3_set_text_change_cause is no-op if enabled request is not pending
if (!pending.enabled) {
return;
}
pending.surroundingTextChangeCause = convertChangeCause(cause);
}
void TextInputV3InterfacePrivate::zwp_text_input_v3_commit(Resource *resource)
{
text-input-v3: track commit counts per resource If we track the commit counts at compositor global, this will fail horribly for anything other than the first text-input-v3 client, as for new client the serial count will not be what it expects in the done() request and it will simply consider events as outdated and will refuse to accept those events
2020-10-07 03:19:15 +00:00
serialHash[resource]++;
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
wayland: Disable text-input-v3 when it's destroyed Destroying a zwp_text_input_v3 object should be viewed as disabling it. isEnabled property is cached because it cannot be computed in _destroy_resource() handler. By that time, the resource no longer will be in resourceMap(), so TextInputV3InterfacePrivate::isEnabled() will erroneously return false even though we expect true.
2023-03-22 15:45:17 +00:00
auto &resourceEnabled = enabledHash[resource];
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
const auto oldResourceEnabled = resourceEnabled;
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
if (resourceEnabled != pending.enabled) {
resourceEnabled = pending.enabled;
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
}
text-input-v3: track commit counts per resource If we track the commit counts at compositor global, this will fail horribly for anything other than the first text-input-v3 client, as for new client the serial count will not be what it expects in the done() request and it will simply consider events as outdated and will refuse to accept those events
2020-10-07 03:19:15 +00:00
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
if (surroundingTextChangeCause != pending.surroundingTextChangeCause) {
surroundingTextChangeCause = pending.surroundingTextChangeCause;
pending.surroundingTextChangeCause = TextInputChangeCause::InputMethod;
}
if (contentHints != pending.contentHints || contentPurpose != pending.contentPurpose) {
contentHints = pending.contentHints;
contentPurpose = pending.contentPurpose;
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
if (resourceEnabled) {
Use Q_EMIT to make it compile against kf5.82
2021-05-13 09:33:08 +00:00
Q_EMIT q->contentTypeChanged();
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
}
}
text-input-v3: track commit counts per resource If we track the commit counts at compositor global, this will fail horribly for anything other than the first text-input-v3 client, as for new client the serial count will not be what it expects in the done() request and it will simply consider events as outdated and will refuse to accept those events
2020-10-07 03:19:15 +00:00
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
if (cursorRectangle != pending.cursorRectangle) {
cursorRectangle = pending.cursorRectangle;
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
if (resourceEnabled) {
Use Q_EMIT to make it compile against kf5.82
2021-05-13 09:33:08 +00:00
Q_EMIT q->cursorRectangleChanged(cursorRectangle);
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
}
}
Run clang-format If you want git blame to ignore formatting revisions run: git config blame.ignoreRevsFile .git-blame-ignore-revs
2021-08-29 05:11:06 +00:00
if (surroundingText != pending.surroundingText || surroundingTextCursorPosition != pending.surroundingTextCursorPosition
|| surroundingTextSelectionAnchor != pending.surroundingTextSelectionAnchor) {
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
surroundingText = pending.surroundingText;
surroundingTextCursorPosition = pending.surroundingTextCursorPosition;
surroundingTextSelectionAnchor = pending.surroundingTextSelectionAnchor;
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
if (resourceEnabled) {
Use Q_EMIT to make it compile against kf5.82
2021-05-13 09:33:08 +00:00
Q_EMIT q->surroundingTextChanged();
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
}
}
Use Q_EMIT to make it compile against kf5.82
2021-05-13 09:33:08 +00:00
Q_EMIT q->stateCommitted(serialHash[resource]);
Always send a done after commit for text input v3. In Gtk's text-input-v3 implementation it expect done to update the client serial after every commit. Though it is unclear whether this is a protocol requirements, do the same thing like mutter for more compatiblity, especially Gtk3 is in EOL not likely to be patched any time soon. To do so, we will need to keep track of the last active preedit, otherwise only send_done() will clear the preedit.
2022-06-10 23:23:52 +00:00
// Gtk text input implementation expect done to be sent after every commit to synchronize the serial value between commit() and done().
// So we need to send the current preedit text with done().
// If current preedit is empty, there is no need to send it.
if (!preeditText.isEmpty() || preeditCursorBegin != 0 || preeditCursorEnd != 0) {
send_preedit_string(resource->handle, preeditText, preeditCursorBegin, preeditCursorEnd);
}
send_done(resource->handle, serialHash[resource]);
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
if (resourceEnabled && oldResourceEnabled) {
Q_EMIT q->enableRequested();
}
wayland: Disable text-input-v3 when it's destroyed Destroying a zwp_text_input_v3 object should be viewed as disabling it. isEnabled property is cached because it cannot be computed in _destroy_resource() handler. By that time, the resource no longer will be in resourceMap(), so TextInputV3InterfacePrivate::isEnabled() will erroneously return false even though we expect true.
2023-03-22 15:45:17 +00:00
updateEnabled();
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
}
void TextInputV3InterfacePrivate::defaultPending()
{
pending.cursorRectangle = QRect();
pending.surroundingTextChangeCause = TextInputChangeCause::InputMethod;
pending.contentHints = TextInputContentHints(TextInputContentHint::None);
pending.contentPurpose = TextInputContentPurpose::Normal;
pending.enabled = false;
pending.surroundingText = QString();
pending.surroundingTextCursorPosition = 0;
pending.surroundingTextSelectionAnchor = 0;
Always send a done after commit for text input v3. In Gtk's text-input-v3 implementation it expect done to update the client serial after every commit. Though it is unclear whether this is a protocol requirements, do the same thing like mutter for more compatiblity, especially Gtk3 is in EOL not likely to be patched any time soon. To do so, we will need to keep track of the last active preedit, otherwise only send_done() will clear the preedit.
2022-06-10 23:23:52 +00:00
defaultPendingPreedit();
}
void TextInputV3InterfacePrivate::defaultPendingPreedit()
{
pending.preeditText = QString();
pending.preeditCursorBegin = 0;
pending.preeditCursorEnd = 0;
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
}
TextInputV3Interface::TextInputV3Interface(SeatInterface *seat)
Make sure we don't leak interfaces Properly set the parent
2021-04-22 15:30:54 +00:00
: QObject(seat)
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
, d(new TextInputV3InterfacePrivate(seat, this))
{
}
TextInputV3Interface::~TextInputV3Interface() = default;
TextInputContentHints TextInputV3Interface::contentHints() const
{
return d->contentHints;
}
TextInputContentPurpose TextInputV3Interface::contentPurpose() const
{
return d->contentPurpose;
}
QString TextInputV3Interface::surroundingText() const
{
return d->surroundingText;
}
qint32 TextInputV3Interface::surroundingTextCursorPosition() const
{
return d->surroundingTextCursorPosition;
}
qint32 TextInputV3Interface::surroundingTextSelectionAnchor() const
{
return d->surroundingTextSelectionAnchor;
}
void TextInputV3Interface::deleteSurroundingText(quint32 beforeLength, quint32 afterLength)
{
d->deleteSurroundingText(beforeLength, afterLength);
}
void TextInputV3Interface::sendPreEditString(const QString &text, quint32 cursorBegin, quint32 cursorEnd)
{
d->sendPreEdit(text, cursorBegin, cursorEnd);
}
void TextInputV3Interface::commitString(const QString &text)
{
d->commitString(text);
}
void TextInputV3Interface::done()
{
d->done();
}
QPointer<SurfaceInterface> TextInputV3Interface::surface() const
{
Clean up the focus handling for text input. Usually, a client will only use text input v2/v3. Do not return the focused surface for text input if it has no relevant text input resource. If text-input object is created after surface get the focus, send enter to this text input object. Ensure sendEnter and sendLeave always appear in pair. Also, use the same technique in text-input-v2 for text-input-v3 to handle per resource's enable/disable state, and only send update to enabled text-input-v3 object.
2021-12-19 08:00:22 +00:00
if (!d->surface) {
return nullptr;
}
if (!d->resourceMap().contains(d->surface->client()->client())) {
return nullptr;
}
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
return d->surface;
}
QRect TextInputV3Interface::cursorRectangle() const
{
return d->cursorRectangle;
}
bool TextInputV3Interface::isEnabled() const
{
wayland: Disable text-input-v3 when it's destroyed Destroying a zwp_text_input_v3 object should be viewed as disabling it. isEnabled property is cached because it cannot be computed in _destroy_resource() handler. By that time, the resource no longer will be in resourceMap(), so TextInputV3InterfacePrivate::isEnabled() will erroneously return false even though we expect true.
2023-03-22 15:45:17 +00:00
return d->isEnabled;
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
}
inputmethod: Allow forcing the display of the input method This makes it possible to show the input method when using a client that doesn't support Wayland input methods (e.g. Xwayland). This adds 2 dbus API entry points: - activeClientSupported property: That tells us if the current client doesn't support text-input-v* - forceActivate method: forces the activation of the input method. This configures the input method in a state that we can use to forward the input method's keystrokes to the client, emulating a hardware keyboard. BUG: 4399911
2022-09-06 22:56:19 +00:00
bool TextInputV3Interface::clientSupportsTextInput(ClientConnection *client) const
{
return client && d->resourceMap().contains(*client);
}
server: implement the text-input-unstable-v3 This commit implements the zwp_text_input_v3 in kwayland-server, part of code is inspired based on the initial patch from Roman at D16735.
2020-09-15 07:27:46 +00:00
}
Add explicit moc includes to sources for moc-covered headers * speeds up incremental builds as changes to a header will not always need the full mocs_compilation.cpp for all the target's headers rebuild, while having a moc file sourced into a source file only adds minor extra costs, due to small own code and the used headers usually already covered by the source file, being for the same class/struct * seems to not slow down clean builds, due to empty mocs_compilation.cpp resulting in those quickly processed, while the minor extra cost of the sourced moc files does not outweigh that in summary. Measured times actually improved by some percent points. (ideally CMake would just skip empty mocs_compilation.cpp & its object file one day) * enables compiler to see all methods of a class in same compilation unit to do some sanity checks * potentially more inlining in general, due to more in the compilation unit * allows to keep using more forward declarations in the header, as with the moc code being sourced into the cpp file there definitions can be ensured and often are already for the needs of the normal class methods
2023-07-05 06:30:14 +00:00
wayland: Drop "_interface" from filenames The cpp files in the wayland directory are named after protocol names. "_interface" does not contribute anything new.
2023-09-13 05:52:59 +00:00
#include "moc_textinput_v3.cpp"
Reference in a new issue Copy permalink