Differential D16735 Diff 45034 src/server/textinput_interface_v3.cpp

Changeset View

Standalone View

View Options

src/server/textinput_interface_v3.cpp

  • This file was added.
1​/****************************************************************************
2​Copyright 2018 Roman Gilg <subdiff@gmail.com>
3​
4​This library is free software; you can redistribute it and/or
5​modify it under the terms of the GNU Lesser General Public
6​License as published by the Free Software Foundation; either
7​version 2.1 of the License, or (at your option) version 3, or any
8​later version accepted by the membership of KDE e.V. (or its
9​successor approved by the membership of KDE e.V.), which shall
10​act as a proxy defined in Section 6 of version 3 of the license.
11​
12​This library is distributed in the hope that it will be useful,
13​but WITHOUT ANY WARRANTY; without even the implied warranty of
14​MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15​Lesser General Public License for more details.
16​
17​You should have received a copy of the GNU Lesser General Public
18​License along with this library. If not, see <http://www.gnu.org/licenses/>.
19​****************************************************************************/
20​#include "textinput_interface_p.h"
21​#include "display.h"
22​#include "resource_p.h"
23​#include "seat_interface_p.h"
24​#include "surface_interface.h"
25​
26​#include <wayland-text-input-unstable-v3-server-protocol.h>
27​
28​namespace KWayland
29​{
30​namespace Server
31​{
32​
33​class TextInputUnstableV3Interface::Private : public TextInputInterface::Private
34​{
35​public:
36​ Private(TextInputInterface *q, TextInputManagerUnstableV3Interface *c, wl_resource *parentResource);
37​ ~Private();
38​
39​ // events
40​ void sendEnter(SurfaceInterface *s, quint32 serial) override;
41​ void sendLeave(quint32 serial, SurfaceInterface *s) override;
42​ void preEdit(const QByteArray &text, const QByteArray &commit) override;
43​ void commit(const QByteArray &text) override;
44​ void deleteSurroundingText(quint32 beforeLength, quint32 afterLength) override;
45​ void setTextDirection(Qt::LayoutDirection direction) override;
46​ void setPreEditCursor(qint32 begin, qint32 end) override;
47​ void setCursorPosition(qint32 index, qint32 anchor) override;
48​ void keysymPressed(quint32 keysym, Qt::KeyboardModifiers modifiers) override;
49​ void keysymReleased(quint32 keysym, Qt::KeyboardModifiers modifiers) override;
50​ TextInputInterfaceVersion interfaceVersion() const override {
51​ return TextInputInterfaceVersion::UnstableV3;
52​ }
53​ void sendInputPanelState() override;
54​ void sendLanguage() override;
55​ void done() override;
56​
57​private:
58​ static const struct zwp_text_input_v3_interface s_interface;
59​
60​ TextInputUnstableV3Interface *q_func() {
61​ return reinterpret_cast<TextInputUnstableV3Interface *>(q);
62​ }
63​
64​ // requests
65​ static void enableCallback(wl_client *client, wl_resource *resource);
66​ static void disableCallback(wl_client *client, wl_resource *resource);
67​ static void setTextChangeCauseCallback(wl_client *client, wl_resource *resource, uint32_t wlCause);
68​ static void commitCallback(wl_client *client, wl_resource *resource);
69​
70​ void enable();
71​ void disable();
72​ void setSurroundingText(const char * text, int32_t cursor, int32_t anchor) override;
73​ void setContentType(TextInputInterface::ContentHints hints, TextInputInterface::ContentPurpose purpose) override;
74​ void setCursorRectangle(const QRect &rect) override;
75​ void commitState();
76​
77​ // helpers
78​ TextInputInterface::ContentHints convertContentHint(uint32_t hint) const override;
79​ TextInputInterface::ContentPurpose convertContentPurpose(uint32_t purpose) const override;
80​ void sendPreeditString();
81​ // set pending values to default ones
82​ void defaultPending();
83​
84​ struct {
85​ QRect cursorRectangle;
86​ TextInputInterface::ChangeCause surroundingTextChangeCause = TextInputInterface::ChangeCause::InputMethod;
87​ TextInputInterface::ContentHints contentHints = TextInputInterface::ContentHint::None;
88​ TextInputInterface::ContentPurpose contentPurpose = TextInputInterface::ContentPurpose::Normal;
89​ bool enabled = false;
90​ QByteArray surroundingText;
91​ qint32 surroundingTextCursorPosition = 0;
92​ qint32 surroundingTextSelectionAnchor = 0;
93​ } pending;
94​
95​ quint32 serial = 0;
96​
97​ struct {
98​ QByteArray string;
99​ struct {
100​ qint32 begin = 0;
101​ qint32 end = 0;
102​ } cursor;
103​ } preedit;
104​};
105​
106​#ifndef DOXYGEN_SHOULD_SKIP_THIS
107​const struct zwp_text_input_v3_interface TextInputUnstableV3Interface::Private::s_interface = {
108​ resourceDestroyedCallback,
109​ enableCallback,
110​ disableCallback,
111​ setSurroundingTextCallback,
112​ setTextChangeCauseCallback,
113​ setContentTypeCallback,
114​ setCursorRectangleCallback,
115​ commitCallback
116​};
117​#endif
118​
119​void TextInputUnstableV3Interface::Private::enable()
120​{
121​ // All properties will be reset to default state
122​ // and following requests amend the state.
123​ defaultPending();
124​ pending.enabled = true;
125​}
126​
127​void TextInputUnstableV3Interface::Private::disable()
128​{
129​ // All properties will be reset to default state.
130​ defaultPending();
131​}
132​
133​
134​void TextInputUnstableV3Interface::Private::setSurroundingText(const char *text, int32_t cursor, int32_t anchor)
135​{
136​ if (!pending.enabled) {
137​ /*
138​ * Pending data can only be amended when the interface
139​ * is (about to be) enabled.
140​ */
zzagUnsubmitted
Not Done

Please use single line comments instead.

zzag: Please use single line comments instead.
141​ return;
142​ }
143​ pending.surroundingText = QByteArray(text);
144​ pending.surroundingTextCursorPosition = cursor;
145​ pending.surroundingTextSelectionAnchor = anchor;
146​}
147​
148​void TextInputUnstableV3Interface::Private::setContentType(TextInputInterface::ContentHints hints, TextInputInterface::ContentPurpose purpose)
149​{
150​ if (!pending.enabled) {
151​ return;
152​ }
153​ pending.contentHints = hints;
154​ pending.contentPurpose = purpose;
155​}
156​
157​void TextInputUnstableV3Interface::Private::setCursorRectangle(const QRect &rect)
158​{
159​ if (!pending.enabled) {
160​ return;
161​ }
162​ pending.cursorRectangle = rect;
163​}
164​
165​void TextInputUnstableV3Interface::Private::commitState()
166​{
167​ serial++;
168​
169​ if (enabled != pending.enabled) {
170​ enabled = pending.enabled;
171​ emit q_func()->enabledChanged();
172​ }
173​
174​ if (surroundingTextChangeCause != pending.surroundingTextChangeCause) {
175​ surroundingTextChangeCause = pending.surroundingTextChangeCause;
176​ // reset to initial value for future commits
177​ pending.surroundingTextChangeCause = TextInputInterface::ChangeCause::InputMethod;
178​ }
179​ if (contentHints != pending.contentHints ||
180​ contentPurpose != pending.contentPurpose) {
181​ contentHints = pending.contentHints;
182​ contentPurpose = pending.contentPurpose;
183​ if (enabled) {
184​ emit q_func()->contentTypeChanged();
185​ }
186​ }
187​ if (cursorRectangle != pending.cursorRectangle) {
188​ cursorRectangle = pending.cursorRectangle;
189​ if (enabled) {
190​ emit q_func()->cursorRectangleChanged(cursorRectangle);
191​ }
192​ }
193​ if (surroundingText != pending.surroundingText ||
194​ surroundingTextCursorPosition != pending.surroundingTextCursorPosition ||
195​ surroundingTextSelectionAnchor != pending.surroundingTextSelectionAnchor) {
196​ surroundingText = pending.surroundingText;
197​ surroundingTextCursorPosition = pending.surroundingTextCursorPosition;
198​ surroundingTextSelectionAnchor = pending.surroundingTextSelectionAnchor;
199​ if (enabled) {
200​ emit q_func()->surroundingTextChanged();
201​ }
202​ }
203​ emit q_func()->committed();
204​}
205​
206​TextInputInterface::ContentHints TextInputUnstableV3Interface::Private::convertContentHint(uint32_t hint) const
207​{
208​ const auto hints = zwp_text_input_v3_content_hint(hint);
209​ TextInputInterface::ContentHints ret = TextInputInterface::ContentHint::None;
210​
211​ if (hints & ZWP_TEXT_INPUT_V3_CONTENT_HINT_COMPLETION) {
212​ ret |= TextInputInterface::ContentHint::AutoCompletion;
213​ }
214​ if (hints & ZWP_TEXT_INPUT_V3_CONTENT_HINT_SPELLCHECK) {
215​ ret |= TextInputInterface::ContentHint::AutoCorrection;
216​ }
217​ if (hints & ZWP_TEXT_INPUT_V3_CONTENT_HINT_AUTO_CAPITALIZATION) {
218​ ret |= TextInputInterface::ContentHint::AutoCapitalization;
219​ }
220​ if (hints & ZWP_TEXT_INPUT_V3_CONTENT_HINT_LOWERCASE) {
221​ ret |= TextInputInterface::ContentHint::LowerCase;
222​ }
223​ if (hints & ZWP_TEXT_INPUT_V3_CONTENT_HINT_UPPERCASE) {
224​ ret |= TextInputInterface::ContentHint::UpperCase;
225​ }
226​ if (hints & ZWP_TEXT_INPUT_V3_CONTENT_HINT_TITLECASE) {
227​ ret |= TextInputInterface::ContentHint::TitleCase;
228​ }
229​ if (hints & ZWP_TEXT_INPUT_V3_CONTENT_HINT_HIDDEN_TEXT) {
230​ ret |= TextInputInterface::ContentHint::HiddenText;
231​ }
232​ if (hints & ZWP_TEXT_INPUT_V3_CONTENT_HINT_SENSITIVE_DATA) {
233​ ret |= TextInputInterface::ContentHint::SensitiveData;
234​ }
235​ if (hints & ZWP_TEXT_INPUT_V3_CONTENT_HINT_LATIN) {
236​ ret |= TextInputInterface::ContentHint::Latin;
237​ }
238​ if (hints & ZWP_TEXT_INPUT_V3_CONTENT_HINT_MULTILINE) {
239​ ret |= TextInputInterface::ContentHint::MultiLine;
240​ }
241​ return ret;
242​}
243​
244​TextInputInterface::ContentPurpose TextInputUnstableV3Interface::Private::convertContentPurpose(uint32_t purpose) const
245​{
246​ const auto wlPurpose = zwp_text_input_v3_content_purpose(purpose);
247​
248​ switch (wlPurpose) {
249​ case ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_ALPHA:
250​ return TextInputInterface::ContentPurpose::Alpha;
251​ case ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_DIGITS:
252​ return TextInputInterface::ContentPurpose::Digits;
253​ case ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NUMBER:
254​ return TextInputInterface::ContentPurpose::Number;
255​ case ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PHONE:
256​ return TextInputInterface::ContentPurpose::Phone;
257​ case ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_URL:
258​ return TextInputInterface::ContentPurpose::Url;
259​ case ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_EMAIL:
260​ return TextInputInterface::ContentPurpose::Email;
261​ case ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NAME:
262​ return TextInputInterface::ContentPurpose::Name;
263​ case ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PASSWORD:
264​ return TextInputInterface::ContentPurpose::Password;
265​ case ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PIN:
266​ return TextInputInterface::ContentPurpose::Pin;
267​ case ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_DATE:
268​ return TextInputInterface::ContentPurpose::Date;
269​ case ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_TIME:
270​ return TextInputInterface::ContentPurpose::Time;
271​ case ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_DATETIME:
272​ return TextInputInterface::ContentPurpose::DateTime;
273​ case ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_TERMINAL:
274​ return TextInputInterface::ContentPurpose::Terminal;
275​ case ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NORMAL:
276​ default:
277​ return TextInputInterface::ContentPurpose::Normal;
278​ }
279​}
280​
281​void TextInputUnstableV3Interface::Private::sendPreeditString()
282​{
283​ if (!resource) {
284​ return;
285​ }
286​ zwp_text_input_v3_send_preedit_string(resource,
287​ preedit.string.constData(),
288​ preedit.cursor.begin,
289​ preedit.cursor.end);
290​}
291​
292​void TextInputUnstableV3Interface::Private::defaultPending()
293​{
294​ pending.cursorRectangle = QRect();
295​ pending.surroundingTextChangeCause = TextInputInterface::ChangeCause::InputMethod;
296​ pending.contentHints = TextInputInterface::ContentHint::None;
297​ pending.contentPurpose = TextInputInterface::ContentPurpose::Normal;
298​ pending.enabled = false;
299​ pending.surroundingText = QByteArray();
300​ pending.surroundingTextCursorPosition = 0;
301​ pending.surroundingTextSelectionAnchor = 0;
302​}
303​
304​
305​void TextInputUnstableV3Interface::Private::sendEnter(SurfaceInterface *s, quint32 serial)
306​{
307​ Q_UNUSED(serial);
308​ if (!resource || !s || !s->resource()) {
309​ return;
310​ }
311​ surface = s;
312​ zwp_text_input_v3_send_enter(resource, s->resource());
313​}
314​
315​void TextInputUnstableV3Interface::Private::sendLeave(quint32 serial, SurfaceInterface *s)
316​{
317​ Q_UNUSED(serial);
318​ if (!resource || !s || !s->resource()) {
319​ return;
320​ }
321​ surface.clear();
322​ zwp_text_input_v3_send_leave(resource, s->resource());
323​}
324​
325​void TextInputUnstableV3Interface::Private::preEdit(const QByteArray &text, const QByteArray &commit)
326​{
327​ Q_UNUSED(commit)
328​ preedit.string = text;
329​ sendPreeditString();
330​}
331​
332​void TextInputUnstableV3Interface::Private::commit(const QByteArray &text)
333​{
334​ if (!resource) {
335​ return;
336​ }
337​ zwp_text_input_v3_send_commit_string(resource, text.constData());
338​}
339​
340​void TextInputUnstableV3Interface::Private::keysymPressed(quint32 keysym, Qt::KeyboardModifiers modifiers)
341​{
342​ Q_UNUSED(keysym)
343​ Q_UNUSED(modifiers)
344​ // not available in v3
345​}
346​
347​void TextInputUnstableV3Interface::Private::keysymReleased(quint32 keysym, Qt::KeyboardModifiers modifiers)
348​{
349​ Q_UNUSED(keysym)
350​ Q_UNUSED(modifiers)
351​ // not available in v3
352​}
353​
354​void TextInputUnstableV3Interface::Private::deleteSurroundingText(quint32 beforeLength, quint32 afterLength)
355​{
356​ if (!resource) {
357​ return;
358​ }
359​ zwp_text_input_v3_send_delete_surrounding_text(resource, beforeLength, afterLength);
360​}
361​
362​void TextInputUnstableV3Interface::Private::setCursorPosition(qint32 index, qint32 anchor)
363​{
364​ Q_UNUSED(index)
365​ Q_UNUSED(anchor)
366​ // not available in v3
367​}
368​
369​void TextInputUnstableV3Interface::Private::setTextDirection(Qt::LayoutDirection direction)
370​{
371​ Q_UNUSED(direction)
372​ // not available in v3
373​}
374​
375​void TextInputUnstableV3Interface::Private::setPreEditCursor(qint32 begin, qint32 end)
376​{
377​ preedit.cursor.begin = begin;
378​ preedit.cursor.end = end;
379​ sendPreeditString();
380​}
381​
382​void TextInputUnstableV3Interface::Private::sendInputPanelState()
383​{
384​ // not available in v3
385​}
386​
387​void TextInputUnstableV3Interface::Private::sendLanguage()
388​{
389​ // not available in v3
390​}
391​
392​void TextInputUnstableV3Interface::Private::done()
393​{
394​ if (!resource) {
395​ return;
396​ }
397​ zwp_text_input_v3_send_done(resource, serial);
398​}
399​
400​TextInputUnstableV3Interface::Private::Private(TextInputInterface *q, TextInputManagerUnstableV3Interface *c, wl_resource *parentResource)
401​ : TextInputInterface::Private(q, c, parentResource, &zwp_text_input_v3_interface, &s_interface)
402​{
403​}
404​
405​TextInputUnstableV3Interface::Private::~Private() = default;
406​
407​TextInputUnstableV3Interface::TextInputUnstableV3Interface(TextInputManagerUnstableV3Interface *parent, wl_resource *parentResource)
408​ : TextInputInterface(new Private(this, parent, parentResource))
409​{
410​}
411​
412​TextInputUnstableV3Interface::~TextInputUnstableV3Interface() = default;
413​
414​void TextInputUnstableV3Interface::Private::enableCallback(wl_client *client, wl_resource *resource)
415​{
416​ auto p = cast<Private>(resource);
417​ Q_ASSERT(*p->client == client);
418​ p->enable();
419​}
420​
421​void TextInputUnstableV3Interface::Private::disableCallback(wl_client *client, wl_resource *resource)
422​{
423​ auto p = cast<Private>(resource);
424​ Q_ASSERT(*p->client == client);
425​ p->disable();
426​}
427​
428​namespace {
zzagUnsubmitted
Not Done

We don't need this namespace because waylandCauseToKWayland is static.

zzag: We don't need this namespace because waylandCauseToKWayland is static.
429​static TextInputInterface::ChangeCause waylandCauseToKWayland(zwp_text_input_v3_change_cause wlCause)
430​{
431​ switch (wlCause) {
432​ case ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_INPUT_METHOD:
433​ return TextInputInterface::ChangeCause::InputMethod;
434​ case ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_OTHER:
435​ default:
436​ return TextInputInterface::ChangeCause::Other;
437​ }
438​}
439​
440​}
441​
442​void TextInputUnstableV3Interface::Private::setTextChangeCauseCallback(wl_client *client, wl_resource *resource, uint32_t wlCause)
443​{
444​ auto p = cast<Private>(resource);
445​ Q_ASSERT(*p->client == client);
446​ if (!p->pending.enabled) {
447​ return;
448​ }
449​ p->pending.surroundingTextChangeCause = waylandCauseToKWayland(zwp_text_input_v3_change_cause(wlCause));
450​}
451​
452​void TextInputUnstableV3Interface::Private::commitCallback(wl_client *client, wl_resource *resource)
453​{
454​ auto p = cast<Private>(resource);
455​ Q_ASSERT(*p->client == client);
456​ p->commitState();
457​}
458​
459​class TextInputManagerUnstableV3Interface::Private : public TextInputManagerInterface::Private
460​{
461​public:
462​ Private(TextInputManagerUnstableV3Interface *q, Display *d);
463​
464​private:
465​ void bind(wl_client *client, uint32_t version, uint32_t id) override;
466​
467​ static void unbind(wl_resource *resource);
468​ static Private *cast(wl_resource *r) {
469​ return reinterpret_cast<Private*>(wl_resource_get_user_data(r));
470​ }
471​
472​ static void destroyCallback(wl_client *client, wl_resource *resource);
473​ static void getTextInputCallback(wl_client *client, wl_resource *resource, uint32_t id, wl_resource * seat);
474​
475​ TextInputManagerUnstableV3Interface *q;
476​ static const struct zwp_text_input_manager_v3_interface s_interface;
477​ static const quint32 s_version;
478​};
479​const quint32 TextInputManagerUnstableV3Interface::Private::s_version = 1;
480​
481​#ifndef DOXYGEN_SHOULD_SKIP_THIS
482​const struct zwp_text_input_manager_v3_interface TextInputManagerUnstableV3Interface::Private::s_interface = {
483​ destroyCallback,
484​ getTextInputCallback
485​};
486​#endif
487​
488​void TextInputManagerUnstableV3Interface::Private::destroyCallback(wl_client *client, wl_resource *resource)
489​{
490​ Q_UNUSED(client)
491​ wl_resource_destroy(resource);
492​}
493​
494​void TextInputManagerUnstableV3Interface::Private::getTextInputCallback(wl_client *client, wl_resource *resource, uint32_t id, wl_resource * seat)
495​{
496​ SeatInterface *s = SeatInterface::get(seat);
497​ if (!s) {
498​ // TODO: send error
499​ return;
500​ }
501​ auto m = cast(resource);
502​ auto *t = new TextInputUnstableV3Interface(m->q, resource);
503​ t->d_func()->seat = s;
504​ m->inputs << t;
505​ QObject::connect(t, &QObject::destroyed, m->q,
506​ [t, m] {
507​ m->inputs.removeAll(t);
508​ }
509​ );
510​ t->d->create(m->display->getConnection(client), version, id);
511​ s->d_func()->registerTextInput(t);
512​}
513​
514​TextInputManagerUnstableV3Interface::Private::Private(TextInputManagerUnstableV3Interface *q, Display *d)
515​ : TextInputManagerInterface::Private(TextInputInterfaceVersion::UnstableV3, q, d, &zwp_text_input_manager_v3_interface, s_version)
516​ , q(q)
517​{
518​}
519​
520​void TextInputManagerUnstableV3Interface::Private::bind(wl_client *client, uint32_t version, uint32_t id)
521​{
522​ auto c = display->getConnection(client);
523​ wl_resource *resource = c->createResource(&zwp_text_input_manager_v3_interface, qMin(version, s_version), id);
524​ if (!resource) {
525​ wl_client_post_no_memory(client);
526​ return;
527​ }
528​ wl_resource_set_implementation(resource, &s_interface, this, unbind);
529​ // TODO: should we track?
530​}
531​
532​void TextInputManagerUnstableV3Interface::Private::unbind(wl_resource *resource)
533​{
534​ Q_UNUSED(resource)
535​ // TODO: implement?
536​}
537​
538​TextInputManagerUnstableV3Interface::TextInputManagerUnstableV3Interface(Display *display, QObject *parent)
539​ : TextInputManagerInterface(new Private(this, display), parent)
540​{
541​}
542​
543​TextInputManagerUnstableV3Interface::~TextInputManagerUnstableV3Interface() = default;
544​
545​}
546​}