imwayland.c 27.7 KB
Newer Older
1 2
/* GTK - The GIMP Toolkit
 * Copyright (C) 2017 Red Hat, Inc.
3
 * Copyright (C) 2018 Purism SPC
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 */

#include "config.h"

#include <string.h>
#include <wayland-client-protocol.h>

#include <gtk/gtk.h>
#include "gtk/gtkintl.h"
#include "gtk/gtkimmodule.h"

#include "gdk/wayland/gdkwayland.h"
29
#include "text-input-unstable-v3-client-protocol.h"
30 31 32 33 34 35 36 37 38

typedef struct _GtkIMContextWaylandGlobal GtkIMContextWaylandGlobal;
typedef struct _GtkIMContextWayland GtkIMContextWayland;
typedef struct _GtkIMContextWaylandClass GtkIMContextWaylandClass;

struct _GtkIMContextWaylandGlobal
{
  struct wl_display *display;
  struct wl_registry *registry;
39
  uint32_t text_input_manager_wl_id;
40 41
  struct zwp_text_input_manager_v3 *text_input_manager;
  struct zwp_text_input_v3 *text_input;
42 43

  GtkIMContext *current;
44

45 46 47 48
  /* The input-method.enter event may happen before or after GTK focus-in,
   * so the context may not exist at the time. Same for leave and focus-out. */
  gboolean focused;

49
  guint serial;
50 51 52 53 54 55 56
};

struct _GtkIMContextWaylandClass
{
  GtkIMContextSimpleClass parent_class;
};

57 58 59 60 61 62 63 64 65 66 67
struct preedit {
  gchar *text;
  gint cursor_begin;
  gint cursor_end;
};

struct surrounding_delete {
  guint before_length;
  guint after_length;
};

68 69 70 71 72 73 74 75 76 77 78 79 80
struct _GtkIMContextWayland
{
  GtkIMContextSimple parent_instance;
  GdkWindow *window;
  GtkWidget *widget;

  GtkGesture *gesture;
  gdouble press_x;
  gdouble press_y;

  struct {
    gchar *text;
    gint cursor_idx;
81
    gint anchor_idx;
82 83
  } surrounding;

84 85 86 87 88 89 90 91
  enum zwp_text_input_v3_change_cause surrounding_change;

  struct surrounding_delete pending_surrounding_delete;

  struct preedit current_preedit;
  struct preedit pending_preedit;

  gchar *pending_commit;
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123

  cairo_rectangle_int_t cursor_rect;
  guint use_preedit : 1;
};

GType type_wayland = 0;
static GObjectClass *parent_class;
static GtkIMContextWaylandGlobal *global = NULL;

static const GtkIMContextInfo imwayland_info =
{
  "wayland",      /* ID */
  NC_("input method menu", "Wayland"),      /* Human readable name */
  GETTEXT_PACKAGE, /* Translation domain */
  GTK_LOCALEDIR,   /* Dir for bindtextdomain (not strictly needed for "gtk+") */
  "",              /* Languages for which this module is the default */
};

static const GtkIMContextInfo *info_list[] =
{
  &imwayland_info,
};

#define GTK_IM_CONTEXT_WAYLAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), type_wayland, GtkIMContextWayland))

#ifndef INCLUDE_IM_wayland
#define MODULE_ENTRY(type,function) G_MODULE_EXPORT type im_module_ ## function
#else
#define MODULE_ENTRY(type, function) type _gtk_immodule_wayland_ ## function
#endif

static void
124
notify_external_change (GtkIMContextWayland *context)
125
{
126
  gboolean result;
127

128 129 130
  if (!global->current)
    return;

131 132
  context->surrounding_change = ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_OTHER;
  g_signal_emit_by_name (global->current, "retrieve-surrounding", &result);
133 134 135 136
}

static void
text_input_preedit (void                     *data,
137
                    struct zwp_text_input_v3 *text_input,
138
                    const char               *text,
139 140
                    gint                      cursor_begin,
                    gint                      cursor_end)
141 142
{
  GtkIMContextWayland *context;
143
  GtkIMContextWaylandGlobal *global = data;
144 145 146 147 148

  if (!global->current)
    return;

  context = GTK_IM_CONTEXT_WAYLAND (global->current);
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
      
  g_free (context->pending_preedit.text);
  context->pending_preedit.text = g_strdup (text);
  context->pending_preedit.cursor_begin = cursor_begin;
  context->pending_preedit.cursor_end = cursor_end;
}

static void
text_input_preedit_apply (GtkIMContextWaylandGlobal *global)
{
  GtkIMContextWayland *context;
  gboolean state_change;
  struct preedit defaults = {0};

  if (!global->current)
164 165
    return;

166 167 168 169
  context = GTK_IM_CONTEXT_WAYLAND (global->current);

  state_change = ((context->pending_preedit.text == NULL)
                 != (context->current_preedit.text == NULL));
170

171
  if (state_change && !context->current_preedit.text)
172 173
    g_signal_emit_by_name (context, "preedit-start");

174 175 176
  g_free (context->current_preedit.text);
  context->current_preedit = context->pending_preedit;
  context->pending_preedit = defaults;
177 178 179

  g_signal_emit_by_name (context, "preedit-changed");

180
  if (state_change && !context->current_preedit.text)
181 182 183 184 185
    g_signal_emit_by_name (context, "preedit-end");
}

static void
text_input_commit (void                     *data,
186
                   struct zwp_text_input_v3 *text_input,
187 188 189
                   const char               *text)
{
  GtkIMContextWaylandGlobal *global = data;
190 191 192 193 194 195 196 197 198 199
  GtkIMContextWayland *context;

  if (!global->current)
      return;
  
  context = GTK_IM_CONTEXT_WAYLAND (global->current);

  g_free (context->pending_commit);
  context->pending_commit = g_strdup (text);
}
200

201 202 203 204 205 206 207 208 209
static void
text_input_commit_apply (GtkIMContextWaylandGlobal *global, gboolean valid)
{
  GtkIMContextWayland *context;
  context = GTK_IM_CONTEXT_WAYLAND (global->current);
  if (context->pending_commit && valid)
    g_signal_emit_by_name (global->current, "commit", context->pending_commit);
  g_free (context->pending_commit);
  context->pending_commit = NULL;
210 211 212 213
}

static void
text_input_delete_surrounding_text (void                     *data,
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
                                    struct zwp_text_input_v3 *text_input,
                                    uint32_t                  before_length,
                                    uint32_t                  after_length)
{
  GtkIMContextWaylandGlobal *global = data;
  GtkIMContextWayland *context;

  if (!global->current)
      return;
  
  context = GTK_IM_CONTEXT_WAYLAND (global->current);

  context->pending_surrounding_delete.before_length = before_length;
  context->pending_surrounding_delete.after_length = after_length;
}

static void
text_input_delete_surrounding_text_apply (GtkIMContextWaylandGlobal *global,
  gboolean valid)
{
  GtkIMContextWayland *context;
235
  gboolean retval;
236 237
  gint len;
  struct surrounding_delete defaults = {0};
238

239
  context = GTK_IM_CONTEXT_WAYLAND (global->current);
240

241 242 243 244 245
  len = context->pending_surrounding_delete.after_length
      + context->pending_surrounding_delete.before_length;
  if (len > 0 && valid)
    g_signal_emit_by_name (global->current, "delete-surrounding",
                           -context->pending_surrounding_delete.before_length,
246
                           len, &retval);
247 248 249 250 251 252 253
  context->pending_surrounding_delete = defaults;
}

static void
text_input_done (void                     *data,
                 struct zwp_text_input_v3 *text_input,
                 uint32_t                  serial)
254 255
{
  GtkIMContextWaylandGlobal *global = data;
256 257 258 259 260
  gboolean result;
  gboolean valid;
  
  if (!global->current)
    return;
261

262
  valid = serial == global->serial;
263 264 265 266
  text_input_delete_surrounding_text_apply(global, valid);
  text_input_commit_apply(global, valid);
  g_signal_emit_by_name (global->current, "retrieve-surrounding", &result);
  text_input_preedit_apply(global);
267 268 269 270 271
}

static void
notify_surrounding_text (GtkIMContextWayland *context)
{
272 273 274 275 276
#define MAX_LEN 4000
  const gchar *start, *end;
  int len, cursor, anchor;
  char *str = NULL;

277 278 279 280 281 282 283
  if (!global || !global->text_input)
    return;
  if (global->current != GTK_IM_CONTEXT (context))
    return;
  if (!context->surrounding.text)
    return;

284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
  len = strlen (context->surrounding.text);
  cursor = context->surrounding.cursor_idx;
  anchor = context->surrounding.anchor_idx;

  /* The protocol specifies a maximum length of 4KiB on transfers,
   * mangle the surrounding text if it's bigger than that, and relocate
   * cursor/anchor locations as per the string being sent.
   */
  if (len > MAX_LEN)
    {
      if (context->surrounding.cursor_idx < MAX_LEN &&
          context->surrounding.anchor_idx < MAX_LEN)
        {
          start = context->surrounding.text;
          end = &context->surrounding.text[MAX_LEN];
        }
      else if (context->surrounding.cursor_idx > len - MAX_LEN &&
301
               context->surrounding.anchor_idx > len - MAX_LEN)
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
        {
          start = &context->surrounding.text[len - MAX_LEN];
          end = &context->surrounding.text[len];
        }
      else
        {
          int mid, a, b;
          int cursor_len = ABS (context->surrounding.cursor_idx -
                                context->surrounding.anchor_idx);

          if (cursor_len > MAX_LEN)
            {
              g_warn_if_reached ();
              return;
            }

          mid = MIN (context->surrounding.cursor_idx,
                     context->surrounding.cursor_idx) + (cursor_len / 2);
          a = MAX (0, mid - (MAX_LEN / 2));
          b = MIN (MAX_LEN, mid + (MAX_LEN / 2));

          start = &context->surrounding.text[a];
          end = &context->surrounding.text[b];
        }

      if (start != context->surrounding.text)
        start = g_utf8_next_char (start);
      if (end != &context->surrounding.text[len])
        end = g_utf8_find_prev_char (context->surrounding.text, end);

      cursor -= start - context->surrounding.text;
      anchor -= start - context->surrounding.text;

      str = g_strndup (start, end - start);
    }

338
  zwp_text_input_v3_set_surrounding_text (global->text_input,
339 340
                                          str ? str : context->surrounding.text,
                                          cursor, anchor);
341 342
  zwp_text_input_v3_set_text_change_cause (global->text_input,
                                           context->surrounding_change);
343 344
  g_free (str);
#undef MAX_LEN
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
}

static void
notify_cursor_location (GtkIMContextWayland *context)
{
  cairo_rectangle_int_t rect;

  if (!global || !global->text_input)
    return;
  if (global->current != GTK_IM_CONTEXT (context))
    return;
  if (!context->window)
    return;

  rect = context->cursor_rect;
  gdk_window_get_root_coords (context->window, rect.x, rect.y,
                              &rect.x, &rect.y);

363 364 365
  zwp_text_input_v3_set_cursor_rectangle (global->text_input,
                                          rect.x, rect.y,
                                          rect.width, rect.height);
366 367 368 369 370 371 372 373 374
}

static uint32_t
translate_hints (GtkInputHints   input_hints,
                 GtkInputPurpose purpose)
{
  uint32_t hints = 0;

  if (input_hints & GTK_INPUT_HINT_SPELLCHECK)
375
    hints |= ZWP_TEXT_INPUT_V3_CONTENT_HINT_SPELLCHECK;
376
  if (input_hints & GTK_INPUT_HINT_WORD_COMPLETION)
377
    hints |= ZWP_TEXT_INPUT_V3_CONTENT_HINT_COMPLETION;
378
  if (input_hints & GTK_INPUT_HINT_LOWERCASE)
379
    hints |= ZWP_TEXT_INPUT_V3_CONTENT_HINT_LOWERCASE;
380
  if (input_hints & GTK_INPUT_HINT_UPPERCASE_CHARS)
381
    hints |= ZWP_TEXT_INPUT_V3_CONTENT_HINT_UPPERCASE;
382
  if (input_hints & GTK_INPUT_HINT_UPPERCASE_WORDS)
383
    hints |= ZWP_TEXT_INPUT_V3_CONTENT_HINT_TITLECASE;
384
  if (input_hints & GTK_INPUT_HINT_UPPERCASE_SENTENCES)
385
    hints |= ZWP_TEXT_INPUT_V3_CONTENT_HINT_AUTO_CAPITALIZATION;
386 387
  if (input_hints & GTK_INPUT_HINT_INHIBIT_OSK)
    hints |= ZWP_TEXT_INPUT_V3_CONTENT_HINT_ON_SCREEN_INPUT_PROVIDED;
388 389 390
  if (purpose == GTK_INPUT_PURPOSE_PIN ||
      purpose == GTK_INPUT_PURPOSE_PASSWORD)
    {
391 392
      hints |= (ZWP_TEXT_INPUT_V3_CONTENT_HINT_HIDDEN_TEXT |
                ZWP_TEXT_INPUT_V3_CONTENT_HINT_SENSITIVE_DATA);
393 394 395 396 397 398 399 400 401 402 403
    }

  return hints;
}

static uint32_t
translate_purpose (GtkInputPurpose purpose)
{
  switch (purpose)
    {
    case GTK_INPUT_PURPOSE_FREE_FORM:
404
      return ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NORMAL;
405
    case GTK_INPUT_PURPOSE_ALPHA:
406
      return ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_ALPHA;
407
    case GTK_INPUT_PURPOSE_DIGITS:
408
      return ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_DIGITS;
409
    case GTK_INPUT_PURPOSE_NUMBER:
410
      return ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NUMBER;
411
    case GTK_INPUT_PURPOSE_PHONE:
412
      return ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PHONE;
413
    case GTK_INPUT_PURPOSE_URL:
414
      return ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_URL;
415
    case GTK_INPUT_PURPOSE_EMAIL:
416
      return ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_EMAIL;
417
    case GTK_INPUT_PURPOSE_NAME:
418
      return ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NAME;
419
    case GTK_INPUT_PURPOSE_PASSWORD:
420
      return ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PASSWORD;
421
    case GTK_INPUT_PURPOSE_PIN:
422
      return ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PIN;
423 424
    case GTK_INPUT_PURPOSE_TERMINAL:
      return ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_TERMINAL;
425 426
    }

427
  return ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NORMAL;
428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443
}

static void
notify_content_type (GtkIMContextWayland *context)
{
  GtkInputHints hints;
  GtkInputPurpose purpose;

  if (global->current != GTK_IM_CONTEXT (context))
    return;

  g_object_get (context,
                "input-hints", &hints,
                "input-purpose", &purpose,
                NULL);

444 445 446
  zwp_text_input_v3_set_content_type (global->text_input,
                                      translate_hints (hints, purpose),
                                      translate_purpose (purpose));
447 448 449 450 451 452 453
}

static void
commit_state (GtkIMContextWayland *context)
{
  if (global->current != GTK_IM_CONTEXT (context))
    return;
454
  global->serial++;
455 456
  zwp_text_input_v3_commit (global->text_input);
  context->surrounding_change = ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_INPUT_METHOD;
457 458 459 460 461 462 463 464 465
}

static void
gtk_im_context_wayland_finalize (GObject *object)
{
  GtkIMContextWayland *context = GTK_IM_CONTEXT_WAYLAND (object);

  g_clear_object (&context->window);
  g_clear_object (&context->gesture);
Carlos Garnacho's avatar
Carlos Garnacho committed
466 467 468 469
  g_free (context->surrounding.text);
  g_free (context->current_preedit.text);
  g_free (context->pending_preedit.text);
  g_free (context->pending_commit);
470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494

  G_OBJECT_CLASS (parent_class)->finalize (object);
}

static void
pressed_cb (GtkGestureMultiPress *gesture,
            gint                  n_press,
            gdouble               x,
            gdouble               y,
            GtkIMContextWayland  *context)
{
  if (n_press == 1)
    {
      context->press_x = x;
      context->press_y = y;
    }
}

static void
released_cb (GtkGestureMultiPress *gesture,
             gint                  n_press,
             gdouble               x,
             gdouble               y,
             GtkIMContextWayland  *context)
{
495
  gboolean result;
496

497 498 499
  if (!global->current)
    return;

500 501
  if (global->focused &&
      n_press == 1 &&
502 503 504 505 506
      !gtk_drag_check_threshold (context->widget,
                                 context->press_x,
                                 context->press_y,
                                 x, y))
    {
507
      zwp_text_input_v3_enable (global->text_input);
508 509
      g_signal_emit_by_name (global->current, "retrieve-surrounding", &result);
      commit_state (context);
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
    }
}

static void
gtk_im_context_wayland_set_client_window (GtkIMContext *context,
                                          GdkWindow    *window)
{
  GtkIMContextWayland *context_wayland = GTK_IM_CONTEXT_WAYLAND (context);
  GtkWidget *widget = NULL;

  if (window == context_wayland->window)
    return;

  if (window)
    gdk_window_get_user_data (window, (gpointer*) &widget);

  if (context_wayland->widget && context_wayland->widget != widget)
    g_clear_object (&context_wayland->gesture);

  g_set_object (&context_wayland->window, window);

  if (context_wayland->widget != widget)
    {
      context_wayland->widget = widget;

      if (widget)
        {
          GtkGesture *gesture;

          gesture = gtk_gesture_multi_press_new (widget);
          gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (gesture),
                                                      GTK_PHASE_CAPTURE);
          g_signal_connect (gesture, "pressed",
                            G_CALLBACK (pressed_cb), context);
          g_signal_connect (gesture, "released",
                            G_CALLBACK (released_cb), context);
          context_wayland->gesture = gesture;
        }
    }
}

static void
gtk_im_context_wayland_get_preedit_string (GtkIMContext   *context,
                                           gchar         **str,
                                           PangoAttrList **attrs,
                                           gint           *cursor_pos)
{
  GtkIMContextWayland *context_wayland = GTK_IM_CONTEXT_WAYLAND (context);
  gchar *preedit_str;

560 561 562
  if (attrs)
    *attrs = NULL;

563 564 565
  GTK_IM_CONTEXT_CLASS (parent_class)->get_preedit_string (context,
                                                           str, attrs,
                                                           cursor_pos);
566 567

  /* If the parent implementation returns a len>0 string, go with it */
568 569 570 571 572 573 574
  if (str && *str)
    {
      if (**str)
        return;

      g_free (*str);
    }
575 576

  preedit_str =
577
    context_wayland->current_preedit.text ? context_wayland->current_preedit.text : "";
578 579 580 581

  if (str)
    *str = g_strdup (preedit_str);
  if (cursor_pos)
582
    *cursor_pos = context_wayland->current_preedit.cursor_begin;
583 584 585

  if (attrs)
    {
586 587
      if (!*attrs)
        *attrs = pango_attr_list_new ();
588 589
      pango_attr_list_insert (*attrs,
                              pango_attr_underline_new (PANGO_UNDERLINE_SINGLE));
590 591 592 593 594 595 596 597 598
      if (context_wayland->current_preedit.cursor_begin
          != context_wayland->current_preedit.cursor_end)
        {
          /* FIXME: Oh noes, how to highlight while taking into account user preferences? */
          PangoAttribute *cursor = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
          cursor->start_index = context_wayland->current_preedit.cursor_begin;
          cursor->end_index = context_wayland->current_preedit.cursor_end;
          pango_attr_list_insert (*attrs, cursor);
        }
599 600 601 602 603 604 605 606 607 608 609 610
    }
}

static gboolean
gtk_im_context_wayland_filter_keypress (GtkIMContext *context,
                                        GdkEventKey  *key)
{
  /* This is done by the compositor */
  return GTK_IM_CONTEXT_CLASS (parent_class)->filter_keypress (context, key);
}

static void
611
enable (GtkIMContextWayland *context_wayland)
612
{
613
  gboolean result;
614
  zwp_text_input_v3_enable (global->text_input);
615
  g_signal_emit_by_name (global->current, "retrieve-surrounding", &result);
616 617 618 619 620 621
  notify_content_type (context_wayland);
  notify_cursor_location (context_wayland);
  commit_state (context_wayland);
}

static void
622
disable (GtkIMContextWayland *context_wayland)
623
{
624 625
  zwp_text_input_v3_disable (global->text_input);
  commit_state (context_wayland);
626 627

  /* after disable, incoming state changes won't take effect anyway */
628 629 630 631 632
  if (context_wayland->current_preedit.text)
    {
      text_input_preedit (global, global->text_input, NULL, 0, 0);
      text_input_preedit_apply (global);
    }
633 634
}

635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684
static void
text_input_enter (void                     *data,
                  struct zwp_text_input_v3 *text_input,
                  struct wl_surface        *surface)
{
  global->focused = TRUE;

  if (global->current)
    enable (GTK_IM_CONTEXT_WAYLAND (global->current));
}

static void
text_input_leave (void                     *data,
                  struct zwp_text_input_v3 *text_input,
                  struct wl_surface        *surface)
{
  global->focused = FALSE;

  if (global->current)
    disable (GTK_IM_CONTEXT_WAYLAND (global->current));
}


static const struct zwp_text_input_v3_listener text_input_listener = {
  text_input_enter,
  text_input_leave,
  text_input_preedit,
  text_input_commit,
  text_input_delete_surrounding_text,
  text_input_done,
};

static void
registry_handle_global (void               *data,
                        struct wl_registry *registry,
                        uint32_t            id,
                        const char         *interface,
                        uint32_t            version)
{
  GtkIMContextWaylandGlobal *global = data;
  GdkSeat *seat = gdk_display_get_default_seat (gdk_display_get_default ());

  if (strcmp (interface, "zwp_text_input_manager_v3") == 0)
    {
      global->text_input_manager_wl_id = id;
      global->text_input_manager =
        wl_registry_bind (global->registry, global->text_input_manager_wl_id,
                          &zwp_text_input_manager_v3_interface, 1);
      global->text_input =
        zwp_text_input_manager_v3_get_text_input (global->text_input_manager,
685
                                                  gdk_wayland_seat_get_wl_seat (seat));
686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701
      global->serial = 0;
      zwp_text_input_v3_add_listener (global->text_input,
                                      &text_input_listener, global);
    }
}

static void
registry_handle_global_remove (void               *data,
                               struct wl_registry *registry,
                               uint32_t            id)
{
  GtkIMContextWaylandGlobal *global = data;

  if (id != global->text_input_manager_wl_id)
    return;

702 703
  g_clear_pointer (&global->text_input, zwp_text_input_v3_destroy);
  g_clear_pointer (&global->text_input_manager, zwp_text_input_manager_v3_destroy);
704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722
}

static const struct wl_registry_listener registry_listener = {
    registry_handle_global,
    registry_handle_global_remove
};

static void
gtk_im_context_wayland_global_init (GdkDisplay *display)
{
  g_return_if_fail (global == NULL);

  global = g_new0 (GtkIMContextWaylandGlobal, 1);
  global->display = gdk_wayland_display_get_wl_display (display);
  global->registry = wl_display_get_registry (global->display);

  wl_registry_add_listener (global->registry, &registry_listener, global);
}

723 724 725 726 727 728 729 730 731 732
static void
gtk_im_context_wayland_focus_in (GtkIMContext *context)
{
  GtkIMContextWayland *context_wayland = GTK_IM_CONTEXT_WAYLAND (context);

  if (global->current == context)
    return;
  if (!global->text_input)
    return;

733 734
  if (context_wayland->gesture)
    gtk_event_controller_reset (GTK_EVENT_CONTROLLER (context_wayland->gesture));
735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750
  global->current = context;

  if (global->focused)
    enable (context_wayland);
}

static void
gtk_im_context_wayland_focus_out (GtkIMContext *context)
{
  GtkIMContextWayland *context_wayland = GTK_IM_CONTEXT_WAYLAND (context);

  if (global->current != context)
    return;

  if (global->focused)
    disable (context_wayland);
751

752 753 754 755 756 757
  global->current = NULL;
}

static void
gtk_im_context_wayland_reset (GtkIMContext *context)
{
758
  notify_external_change (GTK_IM_CONTEXT_WAYLAND (context));
759 760 761 762 763 764 765 766 767

  GTK_IM_CONTEXT_CLASS (parent_class)->reset (context);
}

static void
gtk_im_context_wayland_set_cursor_location (GtkIMContext *context,
                                            GdkRectangle *rect)
{
  GtkIMContextWayland *context_wayland;
768
  int side;
769 770 771

  context_wayland = GTK_IM_CONTEXT_WAYLAND (context);

772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
  if (context_wayland->cursor_rect.x == rect->x &&
      context_wayland->cursor_rect.y == rect->y &&
      context_wayland->cursor_rect.width == rect->width &&
      context_wayland->cursor_rect.height == rect->height)
    return;

  /* Reset the gesture if the cursor changes too far (eg. clicking
   * between disjoint positions in the text).
   *
   * Still Allow some jittering (a square almost double the cursor rect height
   * on either side) as clicking on the exact same position between characters
   * is hard.
   */
  side = context_wayland->cursor_rect.height;

  if (context_wayland->gesture &&
      (ABS (rect->x - context_wayland->cursor_rect.x) >= side ||
       ABS (rect->y - context_wayland->cursor_rect.y) >= side))
    gtk_event_controller_reset (GTK_EVENT_CONTROLLER (context_wayland->gesture));

792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818
  context_wayland->cursor_rect = *rect;
  notify_cursor_location (context_wayland);
  commit_state (context_wayland);
}

static void
gtk_im_context_wayland_set_use_preedit (GtkIMContext *context,
                                        gboolean      use_preedit)
{
  GtkIMContextWayland *context_wayland = GTK_IM_CONTEXT_WAYLAND (context);

  context_wayland->use_preedit = !!use_preedit;
}

static void
gtk_im_context_wayland_set_surrounding (GtkIMContext *context,
                                        const gchar  *text,
                                        gint          len,
                                        gint          cursor_index)
{
  GtkIMContextWayland *context_wayland;

  context_wayland = GTK_IM_CONTEXT_WAYLAND (context);

  g_free (context_wayland->surrounding.text);
  context_wayland->surrounding.text = g_strdup (text);
  context_wayland->surrounding.cursor_idx = cursor_index;
819 820
  /* Anchor is not exposed via the set_surrounding interface, emulating. */
  context_wayland->surrounding.anchor_idx = cursor_index;
821 822

  notify_surrounding_text (context_wayland);
823 824 825 826 827
  /* State changes coming from reset don't have any other opportunity to get
   * committed. */
  if (context_wayland->surrounding_change !=
      ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_INPUT_METHOD)
    commit_state (context_wayland);
828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927
}

static gboolean
gtk_im_context_wayland_get_surrounding (GtkIMContext  *context,
                                        gchar        **text,
                                        gint          *cursor_index)
{
  GtkIMContextWayland *context_wayland;

  context_wayland = GTK_IM_CONTEXT_WAYLAND (context);

  if (!context_wayland->surrounding.text)
    return FALSE;

  *text = context_wayland->surrounding.text;
  *cursor_index = context_wayland->surrounding.cursor_idx;
  return TRUE;
}

static void
gtk_im_context_wayland_class_init (GtkIMContextWaylandClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  GtkIMContextClass *im_context_class = GTK_IM_CONTEXT_CLASS (klass);

  object_class->finalize = gtk_im_context_wayland_finalize;

  im_context_class->set_client_window = gtk_im_context_wayland_set_client_window;
  im_context_class->get_preedit_string = gtk_im_context_wayland_get_preedit_string;
  im_context_class->filter_keypress = gtk_im_context_wayland_filter_keypress;
  im_context_class->focus_in = gtk_im_context_wayland_focus_in;
  im_context_class->focus_out = gtk_im_context_wayland_focus_out;
  im_context_class->reset = gtk_im_context_wayland_reset;
  im_context_class->set_cursor_location = gtk_im_context_wayland_set_cursor_location;
  im_context_class->set_use_preedit = gtk_im_context_wayland_set_use_preedit;
  im_context_class->set_surrounding = gtk_im_context_wayland_set_surrounding;
  im_context_class->get_surrounding = gtk_im_context_wayland_get_surrounding;

  parent_class = g_type_class_peek_parent (klass);
}

static void
on_content_type_changed (GtkIMContextWayland *context)
{
  notify_content_type (context);
  commit_state (context);
}

static void
gtk_im_context_wayland_init (GtkIMContextWayland *context)
{
  context->use_preedit = TRUE;
  g_signal_connect_swapped (context, "notify::input-purpose",
                            G_CALLBACK (on_content_type_changed), context);
  g_signal_connect_swapped (context, "notify::input-hints",
                            G_CALLBACK (on_content_type_changed), context);
}

static void
gtk_im_context_wayland_register_type (GTypeModule *module)
{
  const GTypeInfo object_info = {
    sizeof (GtkIMContextWaylandClass),
    NULL, NULL,
    (GClassInitFunc) gtk_im_context_wayland_class_init,
    NULL, NULL,
    sizeof (GtkIMContextWayland),
    0,
    (GInstanceInitFunc) gtk_im_context_wayland_init,
  };

  type_wayland = g_type_module_register_type (module,
                                              GTK_TYPE_IM_CONTEXT_SIMPLE,
                                              "GtkIMContextWayland",
                                              &object_info, 0);
}

MODULE_ENTRY (void, init) (GTypeModule * module)
{
  gtk_im_context_wayland_register_type (module);
  gtk_im_context_wayland_global_init (gdk_display_get_default ());
}

MODULE_ENTRY (void, exit) (void)
{
}

MODULE_ENTRY (void, list) (const GtkIMContextInfo *** contexts, int *n_contexts)
{
  *contexts = info_list;
  *n_contexts = G_N_ELEMENTS (info_list);
}

MODULE_ENTRY (GtkIMContext *, create) (const gchar * context_id)
{
  if (strcmp (context_id, "wayland") == 0)
    return g_object_new (type_wayland, NULL);
  else
    return NULL;
}