//
// Implementation of Wayland Screen interface
//
// Copyright 1998-2026 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file.  If this
// file is missing or damaged, see the license at:
//
//     https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
//     https://www.fltk.org/bugs.php
//

#include "Fl_Wayland_Screen_Driver.H"
#include "Fl_Wayland_Window_Driver.H"
#include "Fl_Wayland_Graphics_Driver.H"
#include "../../Fl_Scalable_Graphics_Driver.H"
#include <wayland-cursor.h>
#include "../../../libdecor/build/fl_libdecor.h"
#include "xdg-shell-client-protocol.h"
#include "../Posix/Fl_Posix_System_Driver.H"
#include <FL/Fl.H>
#include <FL/Fl_Image_Surface.H>
#include <FL/platform.H>
#include <FL/fl_ask.H>
#include <FL/filename.H>
#include <vector>
#include "../../print_button.h"
#include <dlfcn.h>
#include <linux/input.h>
#include <stdlib.h>
#include <xkbcommon/xkbcommon.h>
#include <xkbcommon/xkbcommon-compose.h>
#include "text-input-client-protocol.h"
#include "gtk-shell-client-protocol.h"
#if HAVE_XDG_DIALOG
#  include "xdg-dialog-client-protocol.h"
#endif
#if HAVE_CURSOR_SHAPE
#  include "cursor-shape-client-protocol.h"
#endif
#include <assert.h>
#include <sys/mman.h>
#include <poll.h>
#include <errno.h>
#include <string.h> // for strerror()
#include <map>
extern "C" {
  bool libdecor_get_cursor_settings(char **theme, int *size);
  bool fl_is_surface_from_GTK_titlebar (struct wl_surface *surface, struct libdecor_frame *frame,
                                        bool *using_GTK);
}

// set this to 1 for keyboard debug output, 0 for no debug output
#define DEBUG_KEYBOARD 0

#define fl_max(a,b) ((a) > (b) ? (a) : (b))
#define fl_min(a,b) ((a) < (b) ? (a) : (b))

struct pointer_output {
  Fl_Wayland_Screen_Driver::output* output;
  struct wl_list link;
};

/* Implementation note:

- About CSD and SSD :
 * Mutter and Weston use CSD (client-side decoration) which means that libdecor.so draws all window
 titlebars and responds to resize, minimization and maximization events.
 * KWin uses SSD (server-side decoration) which means the OS draws titlebars according to its own rules
 and triggers resize, minimization and maximization events.

- Function registry_handle_global() runs within fl_open_display() and sets public static variable
 Fl_Wayland_Screen_Driver::compositor to either Fl_Wayland_Screen_Driver::MUTTER, ::WESTON, or ::KWIN.

- Specific operations for WESTON:
 * When a libdecor-framed window is minimized under Weston, the frame remains on display. To avoid
 that, function libdecor_frame_set_minimized() is modified so it turns off the frame's visibility, with
 function libdecor_frame_set_visibility(), when the window is minimized. That's implemented in file
 libdecor/build/fl_libdecor.c. The modified libdecor_frame_set_minimized() function, part of libdecor.so,
 needs access to variable Fl_Wayland_Screen_Driver::compositor, part of libfltk.a. This is achieved
 calling FLTK function fl_libdecor_using_weston() which returns whether the running compositor
 is Weston. This Weston bug has been corrected in Weston version 10. Thus, this special processing
 is not performed when Weston version is ≥ 10.

- Support of Fl_Window::border(int) :
 FLTK uses libdecor_frame_set_visibility() to show or hide a toplevel window's frame. This doesn't work
 with KWin which uses Server-Side Decoration. In that case, FLTK hides and re-shows the window to toggle
 between presence and absence of a window's frame.
*/


static std::vector<int> key_vector; // used by Fl_Wayland_Screen_Driver::event_key()
static struct wl_surface *gtk_shell_surface = NULL;

Fl_Wayland_Screen_Driver::compositor_name Fl_Wayland_Screen_Driver::compositor =
  Fl_Wayland_Screen_Driver::unspecified;


extern "C" {
  bool fl_libdecor_using_weston(void) {
    return Fl_Wayland_Screen_Driver::compositor == Fl_Wayland_Screen_Driver::WESTON;
  }
}


static void xdg_wm_base_ping(void *data, struct xdg_wm_base *xdg_wm_base, uint32_t serial)
{
    xdg_wm_base_pong(xdg_wm_base, serial);
}


static const struct xdg_wm_base_listener xdg_wm_base_listener = {
    .ping = xdg_wm_base_ping,
};


// these are set by Fl::args() and override any system colors: from Fl_get_system_colors.cxx
extern const char *fl_fg;
extern const char *fl_bg;
extern const char *fl_bg2;
// end of extern additions workaround


void Fl_Wayland_Screen_Driver::do_set_cursor(
    struct Fl_Wayland_Screen_Driver::seat *seat, struct wl_cursor *wl_cursor, Fl_Cursor cursor) {
  /*
   wl_cursor: when non-NULL means a custom cursor;
              when NULL:
                  - with "Cursor shape" protocol, cursor is meaningful if != FL_CURSOR_NONE;
                  - with old-school cursors, seat->default_cursor gives the desired cursor.
   cursor: used with "Cursor shape" protocol for enumerated cursor shape, otherwise equal to FL_CURSOR_NONE
   */
  struct wl_cursor_image *image;
  struct wl_buffer *buffer;
  const int scale = seat->pointer_scale;

#if HAVE_CURSOR_SHAPE
  static std::map<int, int> cursor_shape_map = {
    {FL_CURSOR_DEFAULT, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DEFAULT },
    {FL_CURSOR_ARROW, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DEFAULT },
    {FL_CURSOR_CROSS, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_CROSSHAIR },
    {FL_CURSOR_WAIT, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_WAIT },
    {FL_CURSOR_INSERT, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_TEXT },
    {FL_CURSOR_HAND, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_GRAB },
    {FL_CURSOR_HELP, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_HELP },
    {FL_CURSOR_MOVE, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_MOVE },
    {FL_CURSOR_N, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_N_RESIZE },
    {FL_CURSOR_E, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_E_RESIZE },
    {FL_CURSOR_W, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_W_RESIZE },
    {FL_CURSOR_S, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_S_RESIZE },
    {FL_CURSOR_NS, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NS_RESIZE },
    {FL_CURSOR_WE, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_EW_RESIZE },
    {FL_CURSOR_SW, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_SW_RESIZE },
    {FL_CURSOR_SE, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_SE_RESIZE },
    {FL_CURSOR_NE, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NE_RESIZE },
    {FL_CURSOR_NW, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NW_RESIZE },
    {FL_CURSOR_NESW, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NESW_RESIZE },
    {FL_CURSOR_NWSE, WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_NWSE_RESIZE }
  };
  Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
  if (scr_driver->wp_cursor_shape_device && !wl_cursor) {
    if (cursor != FL_CURSOR_NONE) wp_cursor_shape_device_v1_set_shape(
      scr_driver->wp_cursor_shape_device, seat->pointer_enter_serial, cursor_shape_map[cursor]);
    return;
  }
#endif

  if ((!seat->cursor_theme && !wl_cursor) || !seat->wl_pointer)
    return;

  if (!wl_cursor) wl_cursor = seat->default_cursor;
  image = wl_cursor->images[0];
  buffer = wl_cursor_image_get_buffer(image);
  wl_pointer_set_cursor(seat->wl_pointer, seat->pointer_enter_serial,
            seat->cursor_surface,
            image->hotspot_x / scale,
            image->hotspot_y / scale);
  wl_surface_attach(seat->cursor_surface, buffer, 0, 0);
  wl_surface_set_buffer_scale(seat->cursor_surface, scale);
  wl_surface_damage_buffer(seat->cursor_surface, 0, 0,
         image->width, image->height);
  wl_surface_commit(seat->cursor_surface);
}


static uint32_t ptime;
static uint32_t wld_event_time;
static int px, py;


static void set_event_xy(Fl_Window *win) {
  // turn off is_click if enough time or mouse movement has passed:
  if (abs(Fl::e_x_root-px)+abs(Fl::e_y_root-py) > 3 ||
      wld_event_time >= ptime+1000) {
    Fl::e_is_click = 0;
//fprintf(stderr, "Fl::e_is_click = 0\n");
  }
}


// if this is same event as last && is_click, increment click count:
static inline void checkdouble() {
  if (Fl::e_is_click == Fl::e_keysym) {
    Fl::e_clicks++;
//fprintf(stderr, "Fl::e_clicks = %d\n", Fl::e_clicks);
  } else {
    Fl::e_clicks = 0;
    Fl::e_is_click = Fl::e_keysym;
//fprintf(stderr, "Fl::e_is_click = %d\n", Fl::e_is_click);
  }
  px = Fl::e_x_root;
  py = Fl::e_y_root;
  ptime = wld_event_time;
}


struct wl_display *Fl_Wayland_Screen_Driver::wl_display = NULL;


static Fl_Window *event_coords_from_surface(struct wl_surface *surface,
                                       wl_fixed_t surface_x, wl_fixed_t surface_y) {
  Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(surface);
  if (!win) return NULL;
  int delta_x = 0, delta_y = 0;
  while (win->parent()) {
    delta_x += win->x();
    delta_y += win->y();
    win = win->window();
  }
  float f = Fl::screen_scale(win->screen_num());
  Fl::e_x = wl_fixed_to_int(surface_x) / f + delta_x;
  Fl::e_x_root = Fl::e_x + win->x();
  Fl::e_y = wl_fixed_to_int(surface_y) / f + delta_y;
  int *poffset = Fl_Window_Driver::menu_offset_y(win);
  if (poffset) Fl::e_y -= *poffset;
  Fl::e_y_root = Fl::e_y + win->y();
  return win;
}

static Fl_Window *need_leave = NULL;

static void pointer_enter(void *data, struct wl_pointer *wl_pointer, uint32_t serial,
        struct wl_surface *surface, wl_fixed_t surface_x, wl_fixed_t surface_y) {
  struct Fl_Wayland_Screen_Driver::seat *seat = (struct Fl_Wayland_Screen_Driver::seat*)data;
  Fl_Window *win = event_coords_from_surface(surface, surface_x, surface_y);
  static bool using_GTK = seat->gtk_shell &&
    (gtk_shell1_get_version(seat->gtk_shell) >= GTK_SURFACE1_TITLEBAR_GESTURE_SINCE_VERSION);
  if (!win && using_GTK) {
    // check whether surface is the headerbar of a GTK-decorated window
    Fl_X *xp = Fl_X::first;
    while (xp && using_GTK) { // all mapped windows
      struct wld_window *xid = (struct wld_window*)xp->xid;
      if (xid->kind == Fl_Wayland_Window_Driver::DECORATED &&
          fl_is_surface_from_GTK_titlebar(surface, xid->frame, &using_GTK)) {
        gtk_shell_surface = surface;
        break;
      }
      xp = xp->next;
    }
  }
  if (!win) return;
  //fprintf(stderr, "pointer_enter window=%p\n", Fl_Wayland_Window_Driver::surface_to_window(surface));
  seat->pointer_focus = surface;
  // use custom cursor if present
  struct wl_cursor *cursor =
    fl_wl_xid(win)->custom_cursor ? fl_wl_xid(win)->custom_cursor->wl_cursor : NULL;
  seat->serial = serial;
  seat->pointer_enter_serial = serial;
  Fl_Wayland_Screen_Driver::do_set_cursor(seat, cursor, Fl_Wayland_Window_Driver::driver(win)->standard_cursor());
  set_event_xy(win);
  need_leave = NULL;
  win = Fl_Wayland_Window_Driver::surface_to_window(surface);
  // Caution: with an Fl_Tooltip this call can hide the window being entered (#1317)
  if (!win->parent()) Fl::handle(FL_ENTER, win);
}


static void pointer_leave(void *data, struct wl_pointer *wl_pointer,
        uint32_t serial, struct wl_surface *surface) {
  struct Fl_Wayland_Screen_Driver::seat *seat = (struct Fl_Wayland_Screen_Driver::seat*)data;
  if (seat->pointer_focus == surface) seat->pointer_focus = NULL;
  Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(surface);
  gtk_shell_surface = NULL;
  if (win) {
    //fprintf(stderr, "pointer_leave window=%p [%s]\n", win, (win->parent()?"sub":"top"));
    set_event_xy(win);
    need_leave = win->top_window(); // we leave a sub or toplevel window
    wl_display_roundtrip(fl_wl_display()); // pointer_enter to other win, if applicable, will run
    if (need_leave) { // we really left the sub-or-top win and did not enter another
      extern Fl_Window *fl_xmousewin;
      fl_xmousewin = 0;
      Fl::handle(FL_LEAVE, need_leave);
    }
  }
}


static void pointer_motion(void *data, struct wl_pointer *wl_pointer,
         uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y) {
  struct Fl_Wayland_Screen_Driver::seat *seat =
    (struct Fl_Wayland_Screen_Driver::seat*)data;
  Fl_Window *win = event_coords_from_surface(seat->pointer_focus, surface_x, surface_y);
  if (!win) return;
  if (Fl::grab() && !Fl::grab()->menu_window() && Fl::grab() != win) {
    // If there's an active, non-menu grab() and the pointer is in a window other than
    // the grab(), make e_x_root too large to be in any window
    Fl::e_x_root = 1000000;
  }
  else if (Fl_Window_Driver::menu_parent(NULL) && // any kind of menu is active now, and
      !win->menu_window() && // we enter a non-menu window
      win != Fl_Window_Driver::menu_parent(NULL) // that's not the window below the menu
      ) {
    Fl::e_x_root = 1000000; // make it too large to be in any window
  }
//fprintf(stderr, "FL_MOVE on win=%p to x:%dx%d root:%dx%d\n", win, Fl::e_x, Fl::e_y, Fl::e_x_root, Fl::e_y_root);
  wld_event_time = time;
  set_event_xy(win);
  Fl::handle(FL_MOVE, win);
}


//#include <FL/names.h>
static void pointer_button(void *data,
         struct wl_pointer *wl_pointer,
         uint32_t serial,
         uint32_t time,
         uint32_t button,
         uint32_t state)
{
  struct Fl_Wayland_Screen_Driver::seat *seat =
    (struct Fl_Wayland_Screen_Driver::seat*)data;
  if (gtk_shell_surface && state == WL_POINTER_BUTTON_STATE_PRESSED &&
      button == BTN_MIDDLE) {
    struct gtk_surface1 *gtk_surface = gtk_shell1_get_gtk_surface(seat->gtk_shell,gtk_shell_surface);
    gtk_surface1_titlebar_gesture(gtk_surface, serial, seat->wl_seat,
                                  GTK_SURFACE1_GESTURE_MIDDLE_CLICK);
    gtk_surface1_release(gtk_surface); // very necessary
    return;
  }
  seat->serial = serial;
  int event = 0;
  Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(seat->pointer_focus);
  if (!win) return;
  win = win->top_window();
  wld_event_time = time;
  int b = 0;
  // Fl::e_state &= ~FL_BUTTONS;    // DO NOT reset the mouse button state!
  if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
    if (button == BTN_LEFT)         { Fl::e_state |= FL_BUTTON1; b = 1; }
    else if (button == BTN_RIGHT)   { Fl::e_state |= FL_BUTTON3; b = 3; }
    else if (button == BTN_MIDDLE)  { Fl::e_state |= FL_BUTTON2; b = 2; }
    else if (button == BTN_BACK)    { Fl::e_state |= FL_BUTTON4; b = 4; } // ?
    else if (button == BTN_SIDE)    { Fl::e_state |= FL_BUTTON4; b = 4; } // OK: Debian 12
    else if (button == BTN_FORWARD) { Fl::e_state |= FL_BUTTON5; b = 5; } // ?
    else if (button == BTN_EXTRA)   { Fl::e_state |= FL_BUTTON5; b = 5; } // OK: Debian 12
  } else { // must be WL_POINTER_BUTTON_STATE_RELEASED
    if (button == BTN_LEFT)         { Fl::e_state &= ~FL_BUTTON1; b = 1; }
    else if (button == BTN_RIGHT)   { Fl::e_state &= ~FL_BUTTON3; b = 3; }
    else if (button == BTN_MIDDLE)  { Fl::e_state &= ~FL_BUTTON2; b = 2; }
    else if (button == BTN_BACK)    { Fl::e_state &= ~FL_BUTTON4; b = 4; } // ?
    else if (button == BTN_SIDE)    { Fl::e_state &= ~FL_BUTTON4; b = 4; } // OK: Debian 12
    else if (button == BTN_FORWARD) { Fl::e_state &= ~FL_BUTTON5; b = 5; } // ?
    else if (button == BTN_EXTRA)   { Fl::e_state &= ~FL_BUTTON5; b = 5; } // OK: Debian 12
  }
  Fl::e_keysym = FL_Button + b;
  Fl::e_dx = Fl::e_dy = 0;

  set_event_xy(win);
  if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
    event = FL_PUSH;
    checkdouble();
  } else if (state == WL_POINTER_BUTTON_STATE_RELEASED) {
    event = FL_RELEASE;
  }
  // fprintf(stderr, "%s %s\n", fl_eventnames[event], win->label() ? win->label():"[]");
  Fl::handle(event, win);
}


static void pointer_axis(void *data, struct wl_pointer *wl_pointer,
       uint32_t time, uint32_t axis, wl_fixed_t value) {
  struct Fl_Wayland_Screen_Driver::seat *seat = (struct Fl_Wayland_Screen_Driver::seat*)data;
  Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(seat->pointer_focus);
  if (!win) return;
  wld_event_time = time;
  int delta = wl_fixed_to_int(value);
  if (abs(delta) >= 10) delta /= 10;
  // fprintf(stderr, "FL_MOUSEWHEEL: %c delta=%d\n", axis==WL_POINTER_AXIS_HORIZONTAL_SCROLL?'H':'V', delta);
  // allow both horizontal and vertical movements to be processed by the widget
  if (axis == WL_POINTER_AXIS_HORIZONTAL_SCROLL) {
    if (Fl::event_shift()) { // shift key pressed: send vertical mousewheel event
      Fl::e_dx = 0;
      Fl::e_dy = delta;
    } else { // shift key not pressed (normal behavior): send horizontal mousewheel event
      Fl::e_dx = delta;
      Fl::e_dy = 0;
    }
    Fl::handle(FL_MOUSEWHEEL, win->top_window());
  }
  if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL) {
    if (Fl::event_shift()) { // shift key pressed: send horizontal mousewheel event
      Fl::e_dx = delta;
      Fl::e_dy = 0;
    } else {// shift key not pressed (normal behavior): send vertical mousewheel event
      Fl::e_dx = 0;
      Fl::e_dy = delta;
    }
    Fl::handle(FL_MOUSEWHEEL, win->top_window());
  }
}


static struct wl_pointer_listener pointer_listener = {
  pointer_enter,
  pointer_leave,
  pointer_motion,
  pointer_button,
  pointer_axis
};


static const char *proxy_tag = "FLTK for Wayland";


bool Fl_Wayland_Screen_Driver::own_output(struct wl_output *output)
{
  return wl_proxy_get_tag((struct wl_proxy *)output) == &proxy_tag;
}


static void init_cursors(struct Fl_Wayland_Screen_Driver::seat *seat);


static void try_update_cursor(struct Fl_Wayland_Screen_Driver::seat *seat) {
  if (wl_list_empty(&seat->pointer_outputs)) return;
  struct pointer_output *pointer_output;
  int scale = 1;

  wl_list_for_each(pointer_output, &seat->pointer_outputs, link) {
    scale = fl_max(scale, pointer_output->output->wld_scale);
  }

  if (scale != seat->pointer_scale) {
    seat->pointer_scale = scale;
    init_cursors(seat);
    Fl_Wayland_Screen_Driver::do_set_cursor(seat);
  }
}


static void output_scale(void *data, struct wl_output *wl_output, int32_t factor);


static void cursor_surface_enter(void *data,
        struct wl_surface *wl_surface, struct wl_output *wl_output) {
  // Runs when the seat's cursor_surface enters a display
  struct Fl_Wayland_Screen_Driver::seat *seat =
    (struct Fl_Wayland_Screen_Driver::seat*)data;
  struct pointer_output *pointer_output;

  if (!Fl_Wayland_Screen_Driver::own_output(wl_output))
    return;

  pointer_output = (struct pointer_output *)calloc(1, sizeof(struct pointer_output));
  pointer_output->output =
    (Fl_Wayland_Screen_Driver::output *)wl_output_get_user_data(wl_output);
//fprintf(stderr, "cursor_surface_enter: wl_output_get_user_data(%p)=%p\n", wl_output, pointer_output->output);
  wl_list_insert(&seat->pointer_outputs, &pointer_output->link);
  try_update_cursor(seat);
  Fl_Wayland_Screen_Driver::output *output =
    (Fl_Wayland_Screen_Driver::output*)wl_output_get_user_data(wl_output);
  output_scale(output, wl_output, output->wld_scale); // rescale custom cursors
  // maintain custom or standard window cursor
  Fl_Window *win = Fl::first_window();
  if (win) {
    Fl_Wayland_Window_Driver *driver = Fl_Wayland_Window_Driver::driver(win);
    struct wld_window *xid = fl_wl_xid(win);
    if (xid->custom_cursor) Fl_Wayland_Screen_Driver::do_set_cursor(seat, xid->custom_cursor->wl_cursor);
    else if (driver->cursor_default()) driver->set_cursor(driver->cursor_default());
    else win->cursor(driver->standard_cursor());
  }
}


static void cursor_surface_leave(void *data, struct wl_surface *wl_surface,
        struct wl_output *wl_output) {
  struct Fl_Wayland_Screen_Driver::seat *seat =
    (struct Fl_Wayland_Screen_Driver::seat*)data;
  struct pointer_output *pointer_output, *tmp;
  wl_list_for_each_safe(pointer_output, tmp, &seat->pointer_outputs, link) {
    if (pointer_output->output->wl_output == wl_output) {
      wl_list_remove(&pointer_output->link);
      free(pointer_output);
    }
  }
  try_update_cursor(seat);
  // maintain custom window cursor
  Fl_Window *win = Fl::first_window();
  if (win) {
    struct wld_window *xid = fl_wl_xid(win);
    if (xid->custom_cursor) Fl_Wayland_Screen_Driver::do_set_cursor(seat, xid->custom_cursor->wl_cursor);
  }
}


static struct wl_surface_listener cursor_surface_listener = {
  cursor_surface_enter,
  cursor_surface_leave,
};


static void init_cursors(struct Fl_Wayland_Screen_Driver::seat *seat) {
  Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
  if (!seat->cursor_surface) {
    seat->cursor_surface = wl_compositor_create_surface(scr_driver->wl_compositor);
    wl_surface_add_listener(seat->cursor_surface, &cursor_surface_listener, seat);
  }
#if HAVE_CURSOR_SHAPE
  if (scr_driver->wp_cursor_shape_manager) return;
#endif

  char *name;
  int size;
  struct wl_cursor_theme *theme;

  if (!libdecor_get_cursor_settings(&name, &size)) {
    name = NULL;
    size = 24;
  }
  size *= seat->pointer_scale;
  theme = wl_cursor_theme_load(name, size, scr_driver->wl_shm);
  free(name);
  if (theme != NULL) {
    if (seat->cursor_theme) {
     // caution to destroy theme because Fl_Wayland_Window_Driver::set_cursor(Fl_Cursor) caches used cursors
      scr_driver->reset_cursor();
      wl_cursor_theme_destroy(seat->cursor_theme);
    }
    seat->cursor_theme = theme;
  }
  if (seat->cursor_theme) {
    seat->default_cursor = scr_driver->xc_cursor[Fl_Wayland_Screen_Driver::arrow] =
      wl_cursor_theme_get_cursor(seat->cursor_theme, "left_ptr");
  }
}


static void wl_keyboard_keymap(void *data, struct wl_keyboard *wl_keyboard,
               uint32_t format, int32_t fd, uint32_t size) {
  struct Fl_Wayland_Screen_Driver::seat *seat =
    (struct Fl_Wayland_Screen_Driver::seat*)data;
  assert(format == WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1);

  char *map_shm = (char*)mmap(NULL, size, PROT_READ,
      wl_keyboard_get_version(wl_keyboard) >= 7 ? MAP_PRIVATE : MAP_SHARED, fd, 0);
  assert(map_shm != MAP_FAILED);

  struct xkb_keymap *xkb_keymap = xkb_keymap_new_from_string(seat->xkb_context, map_shm,
              XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
  munmap(map_shm, size);
  close(fd);
  if (xkb_keymap) {
    struct xkb_state *xkb_state = xkb_state_new(xkb_keymap);
    xkb_keymap_unref(seat->xkb_keymap);
    if (seat->xkb_state) xkb_state_unref(seat->xkb_state);
    seat->xkb_keymap = xkb_keymap;
    seat->xkb_state = xkb_state;
  }
}


static int search_int_vector(std::vector<int>& v, int val) {
  for (unsigned pos = 0; pos < v.size(); pos++) {
    if (v[pos] == val) return pos;
  }
  return -1;
}


static void remove_int_vector(std::vector<int>& v, int val) {
  int pos = search_int_vector(v, val);
  if (pos < 0) return;
  v.erase(v.begin()+pos);
}


static int process_wld_key(struct xkb_state *xkb_state, uint32_t key,
                           uint32_t *p_keycode, xkb_keysym_t *p_sym) {
  uint32_t keycode = key + 8;
  xkb_keysym_t sym = xkb_state_key_get_one_sym(xkb_state, keycode);
  if (sym == 0xfe20) sym = FL_Tab;
  if (sym == 0xffeb) sym = FL_Meta_L; // repair value libxkb gives for FL_Meta_L
  if (sym == 0xffec) sym = FL_Meta_R; // repair value libxkb gives for FL_Meta_R
  if (sym >= 'A' && sym <= 'Z') sym += 32; // replace uppercase by lowercase letter
  int for_key_vector = sym; // for support of Fl::event_key(int)
  // special processing for number keys == keycodes 10-19 :
  if (keycode >= 10 && keycode <= 18) {
    for_key_vector = '1' + (keycode - 10);
  } else if (keycode == 19) {
    for_key_vector = '0';
  }
  if (p_keycode) *p_keycode = keycode;
  if (p_sym) *p_sym = sym;
  return for_key_vector;
}


static uint32_t last_keydown_serial = 0; // serial of last keydown event


static void wl_keyboard_enter(void *data, struct wl_keyboard *wl_keyboard,
               uint32_t serial, struct wl_surface *surface, struct wl_array *keys) {
  struct Fl_Wayland_Screen_Driver::seat *seat =
    (struct Fl_Wayland_Screen_Driver::seat*)data;
//fprintf(stderr, "keyboard enter fl_win=%p; keys pressed are: ", Fl_Wayland_Window_Driver::surface_to_window(surface));
  key_vector.clear();
  // Replace wl_array_for_each(p, keys) rejected by C++
  for (uint32_t *p = (uint32_t *)(keys)->data;
      (const char *) p < ((const char *) (keys)->data + (keys)->size);
      (p)++) {
    int for_key_vector = process_wld_key(seat->xkb_state, *p, NULL, NULL);
//fprintf(stderr, "%d ", for_key_vector);
    if (search_int_vector(key_vector, for_key_vector) < 0) {
      key_vector.push_back(for_key_vector);
    }
  }
//fprintf(stderr, "\n");
  seat->keyboard_surface = surface;
  seat->keyboard_enter_serial = serial;
  last_keydown_serial = 0;
  Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(surface);
  if (win) {
    Fl::handle(FL_FOCUS, win);
    fl_wl_find(fl_wl_xid(win));
  }
}


struct key_repeat_data_t {
  uint32_t serial;
  Fl_Window *window;
};

#define KEY_REPEAT_DELAY 0.5 // sec
#define KEY_REPEAT_INTERVAL 0.05 // sec


static void key_repeat_timer_cb(key_repeat_data_t *key_repeat_data) {
  if (last_keydown_serial == key_repeat_data->serial) {
    Fl::handle(FL_KEYDOWN, key_repeat_data->window);
    Fl::add_timeout(KEY_REPEAT_INTERVAL, (Fl_Timeout_Handler)key_repeat_timer_cb, key_repeat_data);
  }
  else delete key_repeat_data;
}


int Fl_Wayland_Screen_Driver::next_marked_length = 0;


int Fl_Wayland_Screen_Driver::has_marked_text() const {
  return 1;
}


int Fl_Wayland_Screen_Driver::insertion_point_x = 0;
int Fl_Wayland_Screen_Driver::insertion_point_y = 0;
int Fl_Wayland_Screen_Driver::insertion_point_width = 0;
int Fl_Wayland_Screen_Driver::insertion_point_height = 0;
bool Fl_Wayland_Screen_Driver::insertion_point_location_is_valid = false;

static int previous_cursor_x = 0, previous_cursor_y = 0, previous_cursor_h = 0;
static uint32_t commit_serial = 0;
static char *current_pre_edit = NULL;
static char *pending_pre_edit = NULL;
static char *pending_commit = NULL;


static void send_commit(struct zwp_text_input_v3 *zwp_text_input_v3) {
  zwp_text_input_v3_commit(zwp_text_input_v3);
  commit_serial++;
}


// inform TIM about location of the insertion point, and memorize this info.
void Fl_Wayland_Screen_Driver::insertion_point_location(int x, int y, int height) {
//printf("insertion_point_location %dx%d\n",x,y);
  Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
  if (scr_driver->seat->text_input /*&& !current_pre_edit*/ &&
        (x != previous_cursor_x || y != previous_cursor_y  || height != previous_cursor_h)) {
    previous_cursor_x = x;
    previous_cursor_y = y;
    previous_cursor_h = height;
    if (Fl::focus()) {
      Fl_Widget *focuswin = Fl::focus()->window();
      while (focuswin && focuswin->parent()) {
        x += focuswin->x(); y += focuswin->y();
        focuswin = focuswin->window();
      }
    }
    float s = fl_graphics_driver->scale();
    insertion_point_location_is_valid = true;
    insertion_point_x = s*x;
    insertion_point_y = s*(y-height);
    insertion_point_width = s*5;
    insertion_point_height = s*height;
    if (zwp_text_input_v3_get_user_data(scr_driver->seat->text_input) ) {
      zwp_text_input_v3_set_cursor_rectangle(scr_driver->seat->text_input,
                                             insertion_point_x, insertion_point_y,
                                             insertion_point_width, insertion_point_height);
      send_commit(scr_driver->seat->text_input);
    }
  }
}


// computes window coordinates & size of insertion point
bool Fl_Wayland_Screen_Driver::insertion_point_location(int *px, int *py,
                                                        int *pwidth, int *pheight) {
  // return true if the current coordinates and size of the insertion point are available
  if ( ! insertion_point_location_is_valid ) return false;
  *px = insertion_point_x;
  *py = insertion_point_y;
  *pwidth = insertion_point_width;
  *pheight = insertion_point_height;
  return true;
}


int Fl_Wayland_Screen_Driver::compose(int& del) {
  unsigned char ascii = (unsigned char)Fl::e_text[0];
  // letter+modifier key
  int condition = (Fl::e_state & (FL_ALT | FL_META | FL_CTRL)) && ascii < 128 ;
  // pressing modifier key
  // FL_Shift_L, FL_Shift_R, FL_Control_L, FL_Control_R, FL_Caps_Lock
  // FL_Meta_L, FL_Meta_R, FL_Alt_L, FL_Alt_R
  condition |= ((Fl::e_keysym >= FL_Shift_L && Fl::e_keysym <= FL_Alt_R) ||
                Fl::e_keysym == FL_Alt_Gr);
  // FL_Home FL_Left FL_Up FL_Right FL_Down FL_Page_Up FL_Page_Down FL_End
  // FL_Print FL_Insert FL_Menu FL_Help and more
  condition |= (Fl::e_keysym >= FL_Home && Fl::e_keysym <= FL_Num_Lock);
  condition |= (Fl::e_keysym >= FL_F && Fl::e_keysym <= FL_F_Last);
  condition |= Fl::e_keysym == FL_Tab || Fl::e_keysym == FL_Scroll_Lock || Fl::e_keysym == FL_Pause;
//fprintf(stderr, "compose: condition=%d e_state=%x ascii=%d\n", condition, Fl::e_state, ascii);
  if (condition) { del = 0; return 0;}
//fprintf(stderr, "compose: del=%d compose_state=%d next_marked_length=%d \n", del, Fl::compose_state, next_marked_length);
  del = Fl::compose_state;
  Fl::compose_state = next_marked_length;
  // no-underlined-text && (ascii non-printable || ascii == delete)
  if (ascii && (!Fl::compose_state) && (ascii <= 31 || ascii == 127)) { del = 0; return 0; }
  return 1;
}


void Fl_Wayland_Screen_Driver::compose_reset() {
  if (!Fl_Wayland_Screen_Driver::wl_registry) open_display();
  Fl::compose_state = 0;
  next_marked_length = 0;
  if (seat->xkb_compose_state) xkb_compose_state_reset(seat->xkb_compose_state);
}


struct dead_key_struct {
  xkb_keysym_t keysym; // the keysym obtained when hitting a dead key
  const char *marked_text; // the temporary text to display for that dead key
};


static dead_key_struct dead_keys[] = {
  {XKB_KEY_dead_grave, "`"},
  {XKB_KEY_dead_acute, "´"},
  {XKB_KEY_dead_circumflex, "^"},
  {XKB_KEY_dead_tilde, "~"},
  {XKB_KEY_dead_macron, "¯"},
  {XKB_KEY_dead_breve, "˘"},
  {XKB_KEY_dead_abovedot, "˙"},
  {XKB_KEY_dead_diaeresis, "¨"},
  {XKB_KEY_dead_abovering, "˚"},
  {XKB_KEY_dead_doubleacute, "˝"},
  {XKB_KEY_dead_caron, "ˇ"},
  {XKB_KEY_dead_cedilla, "¸"},
  {XKB_KEY_dead_ogonek, "˛"},
  {XKB_KEY_dead_iota, "ι"},
  {XKB_KEY_dead_doublegrave, " ̏"},
};


const int dead_key_count = sizeof(dead_keys)/sizeof(struct dead_key_struct);

static void wl_keyboard_key(void *data, struct wl_keyboard *wl_keyboard,
               uint32_t serial, uint32_t time, uint32_t key, uint32_t state) {
  struct Fl_Wayland_Screen_Driver::seat *seat =
    (struct Fl_Wayland_Screen_Driver::seat*)data;
  seat->serial = serial;
  static char buf[128];
  uint32_t keycode;
  xkb_keysym_t sym;
  int for_key_vector = process_wld_key(seat->xkb_state, key, &keycode, &sym);
#if (DEBUG_KEYBOARD)
  xkb_keysym_get_name(sym, buf, sizeof(buf));
  const char *action = (state == WL_KEYBOARD_KEY_STATE_PRESSED ? "press" : "release");
  fprintf(stderr, "wl_keyboard_key: key %s: sym: %-12s(%d) code:%u fl_win=%p, ",
          action, buf, sym, keycode,
          Fl_Wayland_Window_Driver::surface_to_window(seat->keyboard_surface));
#endif
  xkb_state_key_get_utf8(seat->xkb_state, keycode, buf, sizeof(buf));
#if (DEBUG_KEYBOARD)
  fprintf(stderr, "utf8: '%s' e_length=%d [%d]\n", buf, (int)strlen(buf), *buf);
#endif
  Fl::e_keysym = Fl::e_original_keysym = for_key_vector;
  if (!(Fl::e_state & FL_NUM_LOCK) && sym >= XKB_KEY_KP_Home && sym <= XKB_KEY_KP_Delete) {
    // compute e_keysym and e_original_keysym for keypad number keys and '.|,' when NumLock is off
    static const int table[11] = {FL_Home      /* 7 */, FL_Left   /* 4 */, FL_Up      /* 8 */,
                                  FL_Right     /* 6 */, FL_Down   /* 2 */, FL_Page_Up /* 9 */,
                                  FL_Page_Down /* 3 */, FL_End    /* 1 */, 0xff0b     /* 5 */,
                                  FL_Insert    /* 0 */, FL_Delete /* .|, */};
    static const int table_original[11] = {0xffb7 /* 7 */, 0xffb4 /* 4 */, 0xffb8 /* 8 */,
                                           0xffb6 /* 6 */, 0xffb2 /* 2 */, 0xffb9 /* 9 */,
                                           0xffb3 /* 3 */, 0xffb1 /* 1 */, 0xffb5 /* 5 */,
                                           0xffb0 /* 0 */, 0xffac /* .|, */};
    Fl::e_keysym          =          table[sym - XKB_KEY_KP_Home];
    Fl::e_original_keysym = table_original[sym - XKB_KEY_KP_Home];
    for_key_vector = Fl::e_original_keysym;
  }
#if (DEBUG_KEYBOARD)
  fprintf(stderr, "wl_keyboard_key: e_keysym=%x e_original_keysym=%x\n", Fl::e_keysym, Fl::e_original_keysym);
#endif
  if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
    if (search_int_vector(key_vector, for_key_vector) < 0) {
      key_vector.push_back(for_key_vector);
    }
  } else {
    last_keydown_serial = 0;
    remove_int_vector(key_vector, for_key_vector);
  }
  Fl::e_text = buf;
  Fl::e_length = (int)strlen(buf);
  // Process dead keys and compose sequences :
  enum xkb_compose_status status = XKB_COMPOSE_NOTHING;
  // This part is useful only if the compositor doesn't support protocol text-input-unstable-v3
  if (seat->xkb_compose_state && state == WL_KEYBOARD_KEY_STATE_PRESSED &&
      !(sym >= FL_Shift_L && sym <= FL_Alt_R) && sym != XKB_KEY_ISO_Level3_Shift) {
    xkb_compose_state_feed(seat->xkb_compose_state, sym);
    status = xkb_compose_state_get_status(seat->xkb_compose_state);
    if (status == XKB_COMPOSE_COMPOSING) {
      if (Fl::e_length == 0) { // dead keys produce e_length = 0
        int i;
        for (i = 0; i < dead_key_count; i++) {
          if (dead_keys[i].keysym == sym) break;
        }
        if (i < dead_key_count) strcpy(buf, dead_keys[i].marked_text);
        else buf[0] = 0;
        Fl::e_length = (int)strlen(buf);
        Fl::compose_state = 0;
      }
      Fl_Wayland_Screen_Driver::next_marked_length = Fl::e_length;
    } else if (status == XKB_COMPOSE_COMPOSED) {
      Fl::e_length = xkb_compose_state_get_utf8(seat->xkb_compose_state, buf, sizeof(buf));
      Fl::compose_state = Fl_Wayland_Screen_Driver::next_marked_length;
      Fl_Wayland_Screen_Driver::next_marked_length = 0;
    } else if (status == XKB_COMPOSE_CANCELLED) {
      Fl::e_length = 0;
      Fl::compose_state = Fl_Wayland_Screen_Driver::next_marked_length;
      Fl_Wayland_Screen_Driver::next_marked_length = 0;
    }
//fprintf(stderr, "xkb_compose_status=%d ctxt=%p state=%p l=%d[%s]\n", status, seat->xkb_context, seat->xkb_compose_state, Fl::e_length, buf);
  }
  // end of part used only without text-input-unstable-v3

  wld_event_time = time;
  int event = (state == WL_KEYBOARD_KEY_STATE_PRESSED ? FL_KEYDOWN : FL_KEYUP);
  // Send event to focus-containing top window as defined by FLTK,
  // otherwise send it to Wayland-defined focus window
  Fl_Window *win = ( Fl::focus() ? Fl::focus()->top_window() :
                    Fl_Wayland_Window_Driver::surface_to_window(seat->keyboard_surface) );
  if (win) {
    set_event_xy(win);
    Fl::e_is_click = 0;
    Fl::handle(event, win);
  }
  if (event == FL_KEYDOWN && status == XKB_COMPOSE_NOTHING &&
      !(sym >= FL_Shift_L && sym <= FL_Alt_R)) {
    // Handling of key repeats :
    // Use serial argument rather than time to detect repeated keys because
    // serial value changes at each key up or down in all tested OS and compositors,
    // whereas time value changes in Ubuntu24.04 KDE/Plasma 5.27.11 and Ubuntu22.04 KDE/Plasma 5.24.7
    // but not in Debian-testing KDE/Plasma 5.27.10.
    // Unexplained difference in behaviors of KDE/Plasma compositor:
    // Consider KDE settings -> input -> keyboard -> when a key is held: repeat/do nothing.
    // This setting (repeat) has key-down wayland events repeated when key is held under Debian/KDE
    // but not under Ubuntu/KDE !
    key_repeat_data_t *key_repeat_data = new key_repeat_data_t;
    key_repeat_data->serial = serial;
    key_repeat_data->window = win;
    last_keydown_serial = serial;
    Fl::add_timeout(KEY_REPEAT_DELAY, (Fl_Timeout_Handler)key_repeat_timer_cb,
                    key_repeat_data);
  }
}


static void wl_keyboard_leave(void *data, struct wl_keyboard *wl_keyboard,
               uint32_t serial, struct wl_surface *surface) {
  struct Fl_Wayland_Screen_Driver::seat *seat = (struct Fl_Wayland_Screen_Driver::seat*)data;
//fprintf(stderr, "keyboard leave fl_win=%p\n", Fl_Wayland_Window_Driver::surface_to_window(surface));
  seat->keyboard_surface = NULL;
  last_keydown_serial = 0;
  Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(surface);
  if (!win && Fl::focus()) win = Fl::focus()->top_window();
  if (win) Fl::handle(FL_UNFOCUS, win);
  key_vector.clear();
}


static void wl_keyboard_modifiers(void *data, struct wl_keyboard *wl_keyboard,
               uint32_t serial, uint32_t mods_depressed,
               uint32_t mods_latched, uint32_t mods_locked,
               uint32_t group) {
  struct Fl_Wayland_Screen_Driver::seat *seat =
    (struct Fl_Wayland_Screen_Driver::seat*)data;
  xkb_state_update_mask(seat->xkb_state, mods_depressed, mods_latched, mods_locked,
                        0, 0, group);
  Fl::e_state &= ~(FL_SHIFT+FL_CTRL+FL_ALT+FL_META+FL_CAPS_LOCK+FL_NUM_LOCK);
  if (xkb_state_mod_name_is_active(seat->xkb_state, XKB_MOD_NAME_SHIFT,
                                   XKB_STATE_MODS_DEPRESSED)) Fl::e_state |= FL_SHIFT;
  if (xkb_state_mod_name_is_active(seat->xkb_state, XKB_MOD_NAME_CTRL,
                                   XKB_STATE_MODS_DEPRESSED)) Fl::e_state |= FL_CTRL;
  if (xkb_state_mod_name_is_active(seat->xkb_state, XKB_MOD_NAME_ALT,
                                   XKB_STATE_MODS_DEPRESSED)) Fl::e_state |= FL_ALT;
  if (xkb_state_mod_name_is_active(seat->xkb_state, XKB_MOD_NAME_LOGO,
                                   XKB_STATE_MODS_DEPRESSED)) Fl::e_state |= FL_META;
  if (xkb_state_mod_name_is_active(seat->xkb_state, XKB_MOD_NAME_CAPS,
                                   XKB_STATE_MODS_LOCKED)) Fl::e_state |= FL_CAPS_LOCK;
  if (xkb_state_mod_name_is_active(seat->xkb_state, XKB_MOD_NAME_NUM,
                                   XKB_STATE_MODS_LOCKED)) Fl::e_state |= FL_NUM_LOCK;
//fprintf(stderr, "mods_depressed=%u Fl::e_state=%X\n", mods_depressed, Fl::e_state);
}


static void wl_keyboard_repeat_info(void *data, struct wl_keyboard *wl_keyboard, int32_t rate, int32_t delay)
{
  // wl_keyboard is version 3 under Debian, but that event isn't sent until version 4
}


static const struct wl_keyboard_listener wl_keyboard_listener = {
       .keymap = wl_keyboard_keymap,
       .enter = wl_keyboard_enter,
       .leave = wl_keyboard_leave,
       .key = wl_keyboard_key,
       .modifiers = wl_keyboard_modifiers,
       .repeat_info = wl_keyboard_repeat_info,
};


void text_input_enter(void *data, struct zwp_text_input_v3 *zwp_text_input_v3,
                      struct wl_surface *surface) {
//puts("text_input_enter");
  zwp_text_input_v3_set_user_data(zwp_text_input_v3, surface);
  zwp_text_input_v3_enable(zwp_text_input_v3);
  zwp_text_input_v3_set_content_type(zwp_text_input_v3, ZWP_TEXT_INPUT_V3_CONTENT_HINT_NONE, ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NORMAL);
  int x, y, width, height;
  if (Fl_Wayland_Screen_Driver::insertion_point_location(&x, &y, &width, &height)) {
    zwp_text_input_v3_set_cursor_rectangle(zwp_text_input_v3,  x,  y,  width, height);
  }
  send_commit(zwp_text_input_v3);
}


void text_input_leave(void *data, struct zwp_text_input_v3 *zwp_text_input_v3,
                      struct wl_surface *surface) {
//puts("text_input_leave");
  zwp_text_input_v3_disable(zwp_text_input_v3);
  zwp_text_input_v3_set_user_data(zwp_text_input_v3, NULL);
  send_commit(zwp_text_input_v3);
  free(pending_pre_edit); pending_pre_edit = NULL;
  free(current_pre_edit); current_pre_edit = NULL;
  free(pending_commit); pending_commit = NULL;
}


static void send_text_to_fltk(const char *text, bool is_marked, struct wl_surface *current_surface) {
//printf("send_text_to_fltk(%s, %d)\n",text,is_marked);
  Fl_Window *win =  Fl_Wayland_Window_Driver::surface_to_window(current_surface);
  Fl::e_text = text ? (char*)text : (char*)"";
  Fl::e_length = text ? (int)strlen(text) : 0;
  Fl::e_keysym = 'a'; // fake a simple key
  set_event_xy(win);
  Fl::e_is_click = 0;
  if (is_marked) { // goes to widget as marked text
    Fl_Wayland_Screen_Driver::next_marked_length = Fl::e_length;
    Fl::handle(FL_KEYDOWN, win);
  } else if (text) {
    Fl_Wayland_Screen_Driver::next_marked_length = 0;
    Fl::handle(FL_KEYDOWN, win);
    Fl::compose_state = 0;
  } else {
    Fl_Wayland_Screen_Driver::next_marked_length = 0;
    Fl::handle(FL_KEYDOWN, win);
  }
}


void text_input_preedit_string(void *data, struct zwp_text_input_v3 *zwp_text_input_v3,
           const char *text, int32_t cursor_begin, int32_t cursor_end) {
//printf("text_input_preedit_string %s cursor_begin=%d cursor_end=%d\n",text, cursor_begin, cursor_end);
  free(pending_pre_edit);
  pending_pre_edit = text ? strdup(text) : NULL;
}


void text_input_commit_string(void *data, struct zwp_text_input_v3 *zwp_text_input_v3,
                              const char *text) {
//printf("text_input_commit_string %s\n",text);
  free(pending_commit);
  pending_commit = (text ? strdup(text) : NULL);
}


void text_input_delete_surrounding_text(void *data,
                                        struct zwp_text_input_v3 *zwp_text_input_v3,
                                        uint32_t before_length, uint32_t after_length) {
  fprintf(stderr, "delete_surrounding_text before=%d adfter=%d\n",
          before_length,after_length);
}


void text_input_done(void *data, struct zwp_text_input_v3 *zwp_text_input_v3,
                     uint32_t serial) {
//puts("text_input_done");
  struct wl_surface *current_surface = (struct wl_surface*)data;
  const bool bad_event = (serial != commit_serial);
  if ((pending_pre_edit == NULL && current_pre_edit == NULL) ||
      (pending_pre_edit && current_pre_edit && strcmp(pending_pre_edit, current_pre_edit) == 0)) {
      free(pending_pre_edit); pending_pre_edit = NULL;
  } else {
      free(current_pre_edit);
      current_pre_edit = pending_pre_edit;
      pending_pre_edit = NULL;
      if (current_pre_edit) {
        send_text_to_fltk(current_pre_edit, !bad_event, current_surface);
      } else {
        send_text_to_fltk(NULL, false, current_surface);
      }
  }
  if (pending_commit) {
    send_text_to_fltk(pending_commit, false, current_surface);
    free(pending_commit); pending_commit = NULL;
  }
}


static const struct zwp_text_input_v3_listener text_input_listener = {
  .enter = text_input_enter,
  .leave = text_input_leave,
  .preedit_string = text_input_preedit_string,
  .commit_string = text_input_commit_string,
  .delete_surrounding_text = text_input_delete_surrounding_text,
  .done = text_input_done,
};


void Fl_Wayland_Screen_Driver::enable_im() {
  if (text_input_base && !seat->text_input) {
    seat->text_input = zwp_text_input_manager_v3_get_text_input(text_input_base,
                                                                seat->wl_seat);
    //printf("seat->text_input=%p\n",seat->text_input);
    zwp_text_input_v3_add_listener(seat->text_input, &text_input_listener, NULL);
  }
}


void Fl_Wayland_Screen_Driver::disable_im() {
  if (seat->text_input) {
    zwp_text_input_v3_disable(seat->text_input);
    zwp_text_input_v3_commit(seat->text_input);
    zwp_text_input_v3_destroy(seat->text_input);
    seat->text_input = NULL;
    free(pending_pre_edit); pending_pre_edit = NULL;
    free(current_pre_edit); current_pre_edit = NULL;
    free(pending_commit); pending_commit = NULL;
  }
}


static void seat_capabilities(void *data, struct wl_seat *wl_seat, uint32_t capabilities)
{
  Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
  struct Fl_Wayland_Screen_Driver::seat *seat =
    (struct Fl_Wayland_Screen_Driver::seat*)data;
  if ((capabilities & WL_SEAT_CAPABILITY_POINTER) && !seat->wl_pointer) {
    seat->wl_pointer = wl_seat_get_pointer(wl_seat);
    wl_pointer_add_listener(seat->wl_pointer, &pointer_listener, seat);
    seat->pointer_scale = 1;
#if HAVE_CURSOR_SHAPE
    if (scr_driver->wp_cursor_shape_manager) {
      scr_driver->wp_cursor_shape_device =
        wp_cursor_shape_manager_v1_get_pointer(scr_driver->wp_cursor_shape_manager, seat->wl_pointer);
    }
#endif // HAVE_CURSOR_SHAPE
    init_cursors(seat);
  } else if (!(capabilities & WL_SEAT_CAPABILITY_POINTER) && seat->wl_pointer) {
    wl_pointer_release(seat->wl_pointer);
    seat->wl_pointer = NULL;
  }

  bool have_keyboard = seat->xkb_context && (capabilities & WL_SEAT_CAPABILITY_KEYBOARD);
  if (have_keyboard && seat->wl_keyboard == NULL) {
          seat->wl_keyboard = wl_seat_get_keyboard(wl_seat);
          wl_keyboard_add_listener(seat->wl_keyboard,
                          &wl_keyboard_listener, seat);
//fprintf(stderr, "wl_keyboard version=%d\n", wl_keyboard_get_version(seat->wl_keyboard));

  } else if (!have_keyboard && seat->wl_keyboard != NULL) {
          wl_keyboard_release(seat->wl_keyboard);
          seat->wl_keyboard = NULL;
  }
  scr_driver->enable_im();
}


static void seat_name(void *data, struct wl_seat *wl_seat, const char *name) {
  struct Fl_Wayland_Screen_Driver::seat *seat = (struct Fl_Wayland_Screen_Driver::seat*)data;
  seat->name = strdup(name);
}


static struct wl_seat_listener seat_listener = {
  seat_capabilities,
  seat_name
};


static void output_geometry(void *data,
    struct wl_output *wl_output,
    int32_t x,
    int32_t y,
    int32_t physical_width,
    int32_t physical_height,
    int32_t subpixel,
    const char *make,
    const char *model,
    int32_t transform)
{
  //fprintf(stderr, "output_geometry: x=%d y=%d physical=%dx%d\n",x,y,physical_width,physical_height);
  Fl_Wayland_Screen_Driver::output *output = (Fl_Wayland_Screen_Driver::output*)data;
  output->x = int(x);
  output->y = int(y);
  output->dpi = 96; // to elaborate
}


static void output_mode(void *data, struct wl_output *wl_output, uint32_t flags,
      int32_t width, int32_t height, int32_t refresh)
{
  Fl_Wayland_Screen_Driver::output *output = (Fl_Wayland_Screen_Driver::output*)data;
  output->pixel_width = int(width);
  output->pixel_height = int(height);
  output->width = output->pixel_width; // until further notice
  output->height = output->pixel_height;
//fprintf(stderr, "output_mode: [%p]=%dx%d\n",output->wl_output,width,height);
}


static void output_done(void *data, struct wl_output *wl_output)
{
  // Runs at startup and when desktop scale factor is changed or screen added
  Fl_Wayland_Screen_Driver::output *output = (Fl_Wayland_Screen_Driver::output*)data;
//fprintf(stderr, "output_done output=%p\n",output);
  Fl_X *xp = Fl_X::first;
  while (xp) { // all mapped windows
    struct wld_window *win = (struct wld_window*)xp->xid;
    Fl_Window *W = win->fl_win;
    if (win->buffer || W->as_gl_window()) {
      if (W->as_gl_window()) {
        wl_surface_set_buffer_scale(win->wl_surface, output->wld_scale);
        Fl_Window_Driver::driver(W)->is_a_rescale(true);
        W->resize(W->x(), W->y(), W->w(), W->h());
        Fl_Window_Driver::driver(W)->is_a_rescale(false);
      } else {
        Fl_Wayland_Graphics_Driver::buffer_release(win);
      }
      W->redraw();
      Fl_Window_Driver::driver(W)->flush();
    }
    xp = xp->next;
  }
  output->done = true;

  Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
  if (scr_driver->screen_count_get() > 0) { // true when output_done runs after initial screen dectection
    scr_driver->screen_count_set( wl_list_length(&(scr_driver->outputs)) );
    scr_driver->init_workarea();
  }
}


static void output_scale(void *data, struct wl_output *wl_output, int32_t factor) {
  Fl_Wayland_Screen_Driver::output *output = (Fl_Wayland_Screen_Driver::output*)data;
  output->wld_scale = factor;
//fprintf(stderr,"output_scale: wl_output=%p factor=%d\n",wl_output, factor);
  // rescale cursors of windows that map here and have a custom cursor
  Fl_Window *win = Fl::first_window();
  while (win) {
    struct wld_window *xid = fl_wl_xid(win);
    struct Fl_Wayland_Window_Driver::surface_output *s_output;
    // get 1st screen where window appears
    s_output = wl_container_of(xid->outputs.next, s_output, link);
    if (xid->custom_cursor && output == s_output->output) {
      Fl_Wayland_Window_Driver *driver = Fl_Wayland_Window_Driver::driver(win);
      driver->set_cursor_4args(xid->custom_cursor->rgb,
                               xid->custom_cursor->hotx, xid->custom_cursor->hoty, false);
    };
    win = Fl::next_window(win);
  }
}


static struct wl_output_listener output_listener = {
  output_geometry,
  output_mode,
  output_done,
  output_scale
};


struct pair_bool {
  bool found_gtk_shell;
  bool found_wf_shell;
};


// Notice: adding use of unstable protocol "XDG output" would allow FLTK to be notified
// in real time of changes to the relative location of multiple displays;
// with the present code, that information is received at startup only.
static void registry_handle_global(void *user_data, struct wl_registry *wl_registry,
           uint32_t id, const char *interface, uint32_t version) {
//fprintf(stderr, "interface=%s version=%u\n", interface, version);
  Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
  if (strcmp(interface, "wl_compositor") == 0) {
    if (version < 4) {
      Fl::fatal("wl_compositor version >= 4 required");
    }
    scr_driver->wl_compositor = (struct wl_compositor*)wl_registry_bind(wl_registry,
           id, &wl_compositor_interface, 4);

  } else if (strcmp(interface, "wl_subcompositor") == 0) {
    scr_driver->wl_subcompositor = (struct wl_subcompositor*)wl_registry_bind(wl_registry,
           id, &wl_subcompositor_interface, 1);

  } else if (strcmp(interface, "wl_shm") == 0) {
    scr_driver->wl_shm = (struct wl_shm*)wl_registry_bind(wl_registry,
            id, &wl_shm_interface, 1);

  } else if (strcmp(interface, "wl_seat") == 0) {
    if (version < 3) {
      Fl::fatal("%s version 3 required but only version %i is available\n",
                interface, version);
    }
    if (!scr_driver->seat) scr_driver->seat =
      (struct Fl_Wayland_Screen_Driver::seat*)calloc(1,
          sizeof(struct Fl_Wayland_Screen_Driver::seat));
//fprintf(stderr, "registry_handle_global: seat=%p\n", scr_driver->seat);
    wl_list_init(&scr_driver->seat->pointer_outputs);
    scr_driver->seat->wl_seat = (wl_seat*)wl_registry_bind(wl_registry, id,
                                                           &wl_seat_interface, 3);
    scr_driver->seat->xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
    if (scr_driver->seat->xkb_context) {
      const char *locale = getenv("LC_ALL");
      if (!locale || !*locale)
        locale = getenv("LC_CTYPE");
      if (!locale || !*locale)
        locale = getenv("LANG");
      if (!locale || !*locale)
        locale = "C";
      struct xkb_compose_table *table =
        xkb_compose_table_new_from_locale(scr_driver->seat->xkb_context, locale,
                                          XKB_COMPOSE_COMPILE_NO_FLAGS);
      if (table) {
        scr_driver->seat->xkb_compose_state =
          xkb_compose_state_new(table, XKB_COMPOSE_STATE_NO_FLAGS);
      }
    }
    wl_seat_add_listener(scr_driver->seat->wl_seat, &seat_listener, scr_driver->seat);
    if (scr_driver->seat->data_device_manager) {
      scr_driver->seat->data_device =
        wl_data_device_manager_get_data_device(scr_driver->seat->data_device_manager,
                                               scr_driver->seat->wl_seat);
      wl_data_device_add_listener(scr_driver->seat->data_device,
                                  Fl_Wayland_Screen_Driver::p_data_device_listener, NULL);
    }

  } else if (strcmp(interface, wl_data_device_manager_interface.name) == 0) {
    if (!scr_driver->seat) scr_driver->seat =
      (struct Fl_Wayland_Screen_Driver::seat*)calloc(1,
              sizeof(struct Fl_Wayland_Screen_Driver::seat));
    scr_driver->seat->data_device_manager =
      (struct wl_data_device_manager*)wl_registry_bind(wl_registry, id,
                                                       &wl_data_device_manager_interface,
                                                       fl_min(version, 3));
    if (scr_driver->seat->wl_seat) {
      scr_driver->seat->data_device =
        wl_data_device_manager_get_data_device(scr_driver->seat->data_device_manager,
                                               scr_driver->seat->wl_seat);
      wl_data_device_add_listener(scr_driver->seat->data_device,
                                  Fl_Wayland_Screen_Driver::p_data_device_listener, NULL);
    }
//fprintf(stderr, "registry_handle_global: %s\n", interface);

  } else if (strcmp(interface, "wl_output") == 0) {
    if (version < 2) {
      Fl::fatal("%s version 2 required but only version %i is available\n",
                interface, version);
    }
    Fl_Wayland_Screen_Driver::output *output =
      (Fl_Wayland_Screen_Driver::output*)calloc(1, sizeof *output);
    output->id = id;
    output->wld_scale = 1;
#ifdef WL_OUTPUT_RELEASE_SINCE_VERSION
    const int used_version = WL_OUTPUT_RELEASE_SINCE_VERSION;
#else
    const int used_version = 2;
#endif
    output->wl_output = (struct wl_output*)wl_registry_bind(wl_registry,
                 id, &wl_output_interface, fl_min(used_version, version));
    output->gui_scale = 1.f;
    wl_proxy_set_tag((struct wl_proxy *) output->wl_output, &proxy_tag);
    wl_output_add_listener(output->wl_output, &output_listener, output);
    // Put new screen in list of screens, but make sure it's not in list already
    // which may occur after having removed a screen.
    bool found = false;
    Fl_Wayland_Screen_Driver::output *elt;
    wl_list_for_each(elt, &scr_driver->outputs, link) {
      if (elt == output) found = true;
    }
    if (!found) { // add to end of the linked list of displays
      struct wl_list *e = &scr_driver->outputs;
      while (e->next != &scr_driver->outputs) e = e->next; // move e to end of linked list
      wl_list_insert(e, &output->link);
    }
//fprintf(stderr, "wl_output: id=%d wl_output=%p \n", id, output->wl_output);

  } else if (strcmp(interface, xdg_wm_base_interface.name) == 0) {
//fprintf(stderr, "registry_handle_global interface=%s\n", interface);
    scr_driver->xdg_wm_base = (struct xdg_wm_base *)wl_registry_bind(wl_registry, id,
                                                        &xdg_wm_base_interface, 1);
    xdg_wm_base_add_listener(scr_driver->xdg_wm_base, &xdg_wm_base_listener, NULL);
  } else if (strstr(interface, "wf_shell_manager")) {
    ((pair_bool*)user_data)->found_wf_shell = true;
  } else if (strcmp(interface, "gtk_shell1") == 0) {
    ((pair_bool*)user_data)->found_gtk_shell = true;
    //fprintf(stderr, "Running the Mutter compositor\n");
    scr_driver->seat->gtk_shell = (struct gtk_shell1*)wl_registry_bind(wl_registry, id,
                                  &gtk_shell1_interface, version);
  } else if (strcmp(interface, "weston_desktop_shell") == 0) {
    Fl_Wayland_Screen_Driver::compositor = Fl_Wayland_Screen_Driver::WESTON;
    //fprintf(stderr, "Running the Weston compositor\n");
  } else if (strcmp(interface, "org_kde_plasma_shell") == 0) {
    Fl_Wayland_Screen_Driver::compositor = Fl_Wayland_Screen_Driver::KWIN;
    //fprintf(stderr, "Running the KWin compositor\n");
  } else if (strncmp(interface, "zowl_mach_ipc", 13) == 0) {
    Fl_Wayland_Screen_Driver::compositor = Fl_Wayland_Screen_Driver::OWL;
    //fprintf(stderr, "Running the Owl compositor\n");
    if (wl_list_length(&scr_driver->outputs) == 0) {
      Fl_Wayland_Screen_Driver::output *output =
        (Fl_Wayland_Screen_Driver::output*)calloc(1, sizeof *output);
      output->id = 1;
      output->wld_scale = 1;
      output->gui_scale = 1.f;
      output->width = 1440; output->height = 900;
      output->pixel_width = 1440; output->pixel_height = 900;
      output->done = true;
      wl_list_insert(&(scr_driver->outputs), &output->link);
      scr_driver->screen_count_set(1);
    }
  } else if (strcmp(interface, zwp_text_input_manager_v3_interface.name) == 0) {
    scr_driver->text_input_base = (struct zwp_text_input_manager_v3 *)
      wl_registry_bind(wl_registry, id, &zwp_text_input_manager_v3_interface, 1);
//printf("scr_driver->text_input_base=%p version=%d\n",scr_driver->text_input_base,version);
#if HAVE_XDG_DIALOG
  } else if (strcmp(interface, xdg_wm_dialog_v1_interface.name) == 0) {
    scr_driver->xdg_wm_dialog = (struct xdg_wm_dialog_v1 *)
      wl_registry_bind(wl_registry, id, &xdg_wm_dialog_v1_interface, 1);
#endif // HAVE_XDG_DIALOG
#if HAVE_CURSOR_SHAPE
  } else if (strcmp(interface, wp_cursor_shape_manager_v1_interface.name) == 0) {
    scr_driver->wp_cursor_shape_manager = (struct wp_cursor_shape_manager_v1 *)
      wl_registry_bind(wl_registry, id, &wp_cursor_shape_manager_v1_interface, 1);
#endif // HAVE_CURSOR_SHAPE
  }
}


static void registry_handle_global_remove(void *data, struct wl_registry *registry, uint32_t name) {
  Fl_Wayland_Screen_Driver::output *output;
//fprintf(stderr, "registry_handle_global_remove data=%p id=%u\n", data, name);
  Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
  bool has_removed_screen = false;
  wl_list_for_each(output, &(scr_driver->outputs), link) { // all screens
    if (output->id == name) { // the screen being removed
      wl_list_remove(&output->link);
      wl_output_destroy(output->wl_output);
      free(output);
      has_removed_screen = true;
      break;
    }
  }
  if (has_removed_screen) {
    scr_driver->screen_count_set( wl_list_length(&(scr_driver->outputs)) );
    scr_driver->init_workarea();
  }
}


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


static void wayland_socket_callback(int fd, struct wl_display *display)
{
  if (wl_display_prepare_read(display) == -1) {
    wl_display_dispatch_pending(display);
    return;
  }
  wl_display_flush(display);
  struct pollfd fds = (struct pollfd) { fd, POLLIN, 0 };
  if (poll(&fds, 1, 0) <= 0) {
    wl_display_cancel_read(display);
    return;
  }
  if (fds.revents & (POLLERR | POLLHUP)) {
    wl_display_cancel_read(display);
    goto fatal;
  }
  if (wl_display_read_events(display) == -1)
    goto fatal;
  if (wl_display_dispatch_pending(display) == -1)
    goto fatal;
  return;
fatal:
  if (wl_display_get_error(display) == EPROTO) {
    const struct wl_interface *interface;
    int code = wl_display_get_protocol_error(display, &interface, NULL);
    Fl::fatal("Fatal error %d in Wayland protocol: %s",
              code, (interface ? interface->name : "unknown") );
  } else {
    Fl::fatal("Fatal error while communicating with Wayland server: %s",
              strerror(errno));
  }
}


Fl_Wayland_Screen_Driver::Fl_Wayland_Screen_Driver() : Fl_Unix_Screen_Driver() {
  libdecor_context = NULL;
  seat = NULL;
  text_input_base = NULL;
  reset_cursor();
  wl_registry = NULL;
#if HAVE_XDG_DIALOG
  xdg_wm_dialog = NULL;
#endif
#if HAVE_CURSOR_SHAPE
  wp_cursor_shape_manager = NULL;
  wp_cursor_shape_device = NULL;
#endif
}


static void sync_done(void *data, struct wl_callback *cb, uint32_t time) {
  // runs after all calls to registry_handle_global()
  *(struct wl_callback **)data = NULL;
  wl_callback_destroy(cb);
  // keep processing until output_done() has run for each screen
  Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
  Fl_Wayland_Screen_Driver::output *output;
  wl_list_for_each(output, &scr_driver->outputs, link) { // each screen of the system
    while (!output->done) wl_display_dispatch(Fl_Wayland_Screen_Driver::wl_display);
  }
  // Now all screens have been initialized
  scr_driver->screen_count_set( wl_list_length(&(scr_driver->outputs)) );
  struct pair_bool *pair = (struct pair_bool*)wl_registry_get_user_data(scr_driver->wl_registry);
  if (pair->found_gtk_shell || pair->found_wf_shell) {
    Fl_Wayland_Screen_Driver::compositor = (pair->found_wf_shell ?
                          Fl_Wayland_Screen_Driver::WAYFIRE : Fl_Wayland_Screen_Driver::MUTTER);
  }
  if (scr_driver->seat) {
#if HAVE_CURSOR_SHAPE
    if (!scr_driver->wp_cursor_shape_manager)
#endif
      try_update_cursor(scr_driver->seat);
  }
  if (Fl_Wayland_Screen_Driver::compositor != Fl_Wayland_Screen_Driver::OWL) scr_driver->init_workarea();
}


static const struct wl_callback_listener sync_listener = {
  sync_done
};


static void do_atexit() {
  if (Fl_Wayland_Screen_Driver::wl_display) {
    wl_display_roundtrip(Fl_Wayland_Screen_Driver::wl_display);
  }
}


void Fl_Wayland_Screen_Driver::open_display_platform() {
  static bool beenHereDoneThat = false;
  if (beenHereDoneThat)
    return;

  beenHereDoneThat = true;

  if (!wl_display) {
    wl_display = wl_display_connect(NULL);
    if (!wl_display) {
      Fl::fatal("No Wayland connection\n");
    }
  }
  //puts("Using Wayland backend");
  wl_list_init(&outputs);

  wl_registry = wl_display_get_registry(wl_display);
  struct pair_bool pair = {false, false};
  wl_registry_add_listener(wl_registry, &registry_listener, &pair);
  struct wl_callback *registry_cb = wl_display_sync(wl_display);
  wl_callback_add_listener(registry_cb, &sync_listener, &registry_cb);
  while (registry_cb) wl_display_dispatch(wl_display);
  Fl::add_fd(wl_display_get_fd(wl_display), FL_READ, (Fl_FD_Handler)wayland_socket_callback,
             wl_display);
  fl_create_print_window();
  /* This is useful to avoid crash of the Wayland compositor after
   FLTK apps terminate in certain situations:
   - gnome-shell version < 44 (e.g. version 42.9)
   - focus set to "follow-mouse"
   See issue #821 for details.
  */
  atexit(do_atexit);
}


void Fl_Wayland_Screen_Driver::close_display() {
  if (!Fl_Wayland_Screen_Driver::wl_display) return;
  wl_display_roundtrip(Fl_Wayland_Screen_Driver::wl_display);
  if (text_input_base) {
    disable_im();
    zwp_text_input_manager_v3_destroy(text_input_base);
    text_input_base = NULL;
  }
  while (wl_list_length(&outputs) > 0) {
    Fl_Wayland_Screen_Driver::output *output;
    wl_list_for_each(output, &outputs, link) {
      wl_list_remove(&output->link);
      screen_count_set( wl_list_length(&outputs) );
      if (output->wl_output) {
#ifdef WL_OUTPUT_RELEASE_SINCE_VERSION
        if (wl_output_get_version(output->wl_output) >= WL_OUTPUT_RELEASE_SINCE_VERSION)
          wl_output_release(output->wl_output);
        else
#endif
          wl_output_destroy(output->wl_output);
      }
      free(output);
      break;
    }
  }
  wl_subcompositor_destroy(wl_subcompositor); wl_subcompositor = NULL;
  wl_surface_destroy(seat->cursor_surface); seat->cursor_surface = NULL;
  if (seat->cursor_theme) {
    wl_cursor_theme_destroy(seat->cursor_theme);
    seat->cursor_theme = NULL;
  }
  wl_compositor_destroy(wl_compositor); wl_compositor = NULL;
  // wl_shm-related data
  if (Fl_Wayland_Graphics_Driver::current_pool) {
    struct Fl_Wayland_Graphics_Driver::wld_shm_pool_data *pool_data =
    (struct Fl_Wayland_Graphics_Driver::wld_shm_pool_data*)
    wl_shm_pool_get_user_data(Fl_Wayland_Graphics_Driver::current_pool);
    wl_shm_pool_destroy(Fl_Wayland_Graphics_Driver::current_pool);
    Fl_Wayland_Graphics_Driver::current_pool = NULL;
    /*int err = */munmap(pool_data->pool_memory, pool_data->pool_size);
    //printf("close_display munmap(%p)->%d\n", pool_data->pool_memory, err);
    free(pool_data);
  }
  wl_shm_destroy(wl_shm); wl_shm = NULL;
  if (seat->wl_keyboard) {
    if (seat->xkb_state) {
      xkb_state_unref(seat->xkb_state);
      seat->xkb_state = NULL;
    }
    if (seat->xkb_keymap) {
      xkb_keymap_unref(seat->xkb_keymap);
      seat->xkb_keymap = NULL;
    }
    wl_keyboard_destroy(seat->wl_keyboard);
    seat->wl_keyboard = NULL;
  }
  wl_pointer_destroy(seat->wl_pointer); seat->wl_pointer = NULL;
  if (seat->xkb_compose_state) {
    xkb_compose_state_unref(seat->xkb_compose_state);
    seat->xkb_compose_state = NULL;
  }
  if (seat->xkb_context) {
    xkb_context_unref(seat->xkb_context);
    seat->xkb_context = NULL;
  }
  if (seat->data_source) {
    wl_data_source_destroy(seat->data_source);
    seat->data_source = NULL;
  }
  wl_data_device_destroy(seat->data_device); seat->data_device = NULL;
  wl_data_device_manager_destroy(seat->data_device_manager);
  seat->data_device_manager = NULL;
  wl_seat_destroy(seat->wl_seat); seat->wl_seat = NULL;
  if (seat->name) free(seat->name);
  free(seat); seat = NULL;
  if (libdecor_context) {
    libdecor_unref(libdecor_context);
    libdecor_context = NULL;
  }
  xdg_wm_base_destroy(xdg_wm_base); xdg_wm_base = NULL;
  Fl_Wayland_Plugin *plugin = Fl_Wayland_Window_Driver::gl_plugin();
  if (plugin) plugin->terminate();
#if HAVE_XDG_DIALOG
  if (xdg_wm_dialog) {
    xdg_wm_dialog_v1_destroy(xdg_wm_dialog);
    xdg_wm_dialog = NULL;
  }
#endif // HAVE_XDG_DIALOG
#if HAVE_CURSOR_SHAPE
  if (wp_cursor_shape_device ) {
    wp_cursor_shape_device_v1_destroy(wp_cursor_shape_device);
    wp_cursor_shape_device = NULL;
  }
  if (wp_cursor_shape_manager ) {
    wp_cursor_shape_manager_v1_destroy(wp_cursor_shape_manager);
    wp_cursor_shape_manager = NULL;
  }
#endif // HAVE_CURSOR_SHAPE

  Fl::remove_fd(wl_display_get_fd(Fl_Wayland_Screen_Driver::wl_display));
  wl_registry_destroy(wl_registry); wl_registry = NULL;
  wl_display_disconnect(Fl_Wayland_Screen_Driver::wl_display);
  Fl_Wayland_Screen_Driver::wl_display = NULL;
  delete Fl_Display_Device::display_device()->driver();
  delete Fl_Display_Device::display_device();
  delete Fl::system_driver();
  delete this;
}


struct configure_s { int W, H; uint32_t state; };

static void xdg_toplevel_configure(void *v, struct xdg_toplevel *xdg_toplevel,
                                   int32_t width, int32_t height, struct wl_array *states)
{
  struct configure_s *data = (struct configure_s*)v;
  data->W = width;
  data->H = height;
  data->state = (width && height && states ? *(uint32_t *)(states->data) : 0);
}

static const struct xdg_toplevel_listener xdg_toplevel_listener = {
  .configure = xdg_toplevel_configure,
};


static bool compute_full_and_maximized_areas(Fl_Wayland_Screen_Driver::output *output,
                                             int& Wfullscreen, int& Hfullscreen,
                                             int& Wworkarea, int& Hworkarea) {
  if (Fl_Wayland_Screen_Driver::compositor == Fl_Wayland_Screen_Driver::unspecified) {
    Wfullscreen = 0;
    return false;
  }
  bool found_workarea = false;
  Fl_Wayland_Screen_Driver *scr_driver = (Fl_Wayland_Screen_Driver*)Fl::screen_driver();
  struct wl_surface *wl_surface = wl_compositor_create_surface(scr_driver->wl_compositor);
  wl_surface_set_opaque_region(wl_surface, NULL);
  struct xdg_surface *xdg_surface = xdg_wm_base_get_xdg_surface(scr_driver->xdg_wm_base, wl_surface);
  struct xdg_toplevel *xdg_toplevel = xdg_surface_get_toplevel(xdg_surface);
  struct configure_s data = {0, 0, 0};
  xdg_toplevel_add_listener(xdg_toplevel, &xdg_toplevel_listener, &data);
  xdg_toplevel_set_fullscreen(xdg_toplevel, output->wl_output);
  wl_surface_commit(wl_surface); // necessary under KWin
  while (data.state != XDG_TOPLEVEL_STATE_FULLSCREEN)
    wl_display_dispatch(Fl_Wayland_Screen_Driver::wl_display);
  Wfullscreen = data.W;
  Hfullscreen = data.H;
  if (Wfullscreen && Hfullscreen && wl_list_length(&scr_driver->outputs) == 1) {
    struct wl_surface *wl_surface2 = wl_compositor_create_surface(scr_driver->wl_compositor);
    struct xdg_surface *xdg_surface2 = xdg_wm_base_get_xdg_surface(scr_driver->xdg_wm_base, wl_surface2);
    struct xdg_toplevel *xdg_toplevel2 = xdg_surface_get_toplevel(xdg_surface2);
    struct configure_s data2 = {0, 0, 0};
    xdg_toplevel_add_listener(xdg_toplevel2, &xdg_toplevel_listener, &data2);
    xdg_toplevel_set_parent(xdg_toplevel2, xdg_toplevel);
    xdg_toplevel_set_maximized(xdg_toplevel2);
    wl_surface_commit(wl_surface2); // necessary under KWin
    while (data2.state != XDG_TOPLEVEL_STATE_MAXIMIZED)
      wl_display_dispatch(Fl_Wayland_Screen_Driver::wl_display);
    Wworkarea = data2.W;
    Hworkarea = data2.H;
    xdg_toplevel_destroy(xdg_toplevel2);
    xdg_surface_destroy(xdg_surface2);
    wl_surface_destroy(wl_surface2);
    if (Wworkarea == Wfullscreen && Hworkarea < Hfullscreen && Hworkarea > Hfullscreen - 80)
      found_workarea = true;
    if (Hworkarea == Hfullscreen && Wworkarea < Wfullscreen && Wworkarea > Wfullscreen - 80)
      found_workarea = true;
  } else {
    Wworkarea = Wfullscreen;
    Hworkarea = Hfullscreen;
  }
  xdg_toplevel_destroy(xdg_toplevel);
  xdg_surface_destroy(xdg_surface);
  wl_surface_destroy(wl_surface);
  /*int fractional_scale = int(100 * (output->pixel_width / float(Wfullscreen)));
  printf("fullscreen=%dx%d workarea=%dx%d  fractional_scale=%d%%  wld_s=%d\n",
         Wfullscreen,Hfullscreen,Wworkarea,Hworkarea,fractional_scale,output->wld_scale);*/
  return found_workarea;
}

static int workarea_xywh[4] = { -1, -1, -1, -1 };


/* Implementation note about computing work area and about handling fractional scaling.

 FLTK computes 2 pairs of (WxH) values for each display:
 1) (pixel_width x pixel_height) gives the size in pixel of a display. It's unchanged by
 any scaling applied by the compositor; it's assigned by function output_mode().
 2) (width x height) gives the size in pixels of a buffer that would fully cover the display.
 When the active scaling is non-fractional, these equations hold:
   pixel_width = width = wld_scale * configured-width-of-fullscreen-window
   pixel_height = height = wld_scale * configured-height-of-fullscreen-window

 When fractional scaling is active, buffers received from client are scaled down
 by the compositor and mapped to screen. These equations hold:
   pixel_width < width = wld_scale * configured-width-of-fullscreen-window
   pixel_height < height = wld_scale * configured-height-of-fullscreen-window

 One way for a client to discover that fractional scaling is active on a given display
 is to ask for a fullscreen window on that display, get its configured size and compare
 it to that display's pixel size. That's what function compute_full_and_maximized_areas() does.

 One way for a client to discover the work area size of a display is to get the configured size
 of a maximized window on that display. FLTK didn't find a way to control in general
 on what display the compositor puts a maximized window. Therefore, FLTK computes an exact
 work area size only when the system contains a single display. We create first a fullscreen
 window on the display and then we create a maximized window made a child of the
 fullscreen one and record its configured size. That's also done by function
 compute_full_and_maximized_areas().
 */

void Fl_Wayland_Screen_Driver::init_workarea()
{
  wl_display_roundtrip(Fl_Wayland_Screen_Driver::wl_display); // important after screen removal
  bool need_init_workarea = true;
  Fl_Wayland_Screen_Driver::output *output;
  wl_list_for_each(output, &outputs, link) {
    int Wfullscreen, Hfullscreen, Wworkarea, Hworkarea;
    bool found_workarea = compute_full_and_maximized_areas(output, Wfullscreen, Hfullscreen, Wworkarea, Hworkarea);
    if (Wfullscreen && Hfullscreen) { // skip sway which puts 0 there
      output->width = Wfullscreen * output->wld_scale; // pixels
      output->height = Hfullscreen * output->wld_scale; // pixels
      if (found_workarea) {
        workarea_xywh[0] = output->x; // pixels
        workarea_xywh[1] = output->y; // pixels
        workarea_xywh[2] = Wworkarea * output->wld_scale; // pixels
        workarea_xywh[3] = Hworkarea * output->wld_scale; // pixels
        need_init_workarea = false;
      }
    }
  }
  if (need_init_workarea) {
    screen_xywh(workarea_xywh[0], workarea_xywh[1], workarea_xywh[2], workarea_xywh[3], 0);
  }
  Fl::handle(FL_SCREEN_CONFIGURATION_CHANGED, NULL);
}


int Fl_Wayland_Screen_Driver::x() {
  if (!Fl_Wayland_Screen_Driver::wl_registry) open_display();
  Fl_Wayland_Screen_Driver::output *output;
  wl_list_for_each(output, &outputs, link) {
    break;
  }
  return workarea_xywh[0] / (output->gui_scale * output->wld_scale);
}


int Fl_Wayland_Screen_Driver::y() {
  if (!Fl_Wayland_Screen_Driver::wl_registry) open_display();
  Fl_Wayland_Screen_Driver::output *output;
  wl_list_for_each(output, &outputs, link) {
    break;
  }
  return workarea_xywh[1] / (output->gui_scale * output->wld_scale);
}


int Fl_Wayland_Screen_Driver::w() {
  if (!Fl_Wayland_Screen_Driver::wl_registry) open_display();
  Fl_Wayland_Screen_Driver::output *output;
  wl_list_for_each(output, &outputs, link) {
    break;
  }
  return workarea_xywh[2] / (output->gui_scale * output->wld_scale);
}


int Fl_Wayland_Screen_Driver::h() {
  if (!Fl_Wayland_Screen_Driver::wl_registry) open_display();
  Fl_Wayland_Screen_Driver::output *output;
  wl_list_for_each(output, &outputs, link) {
    break;
  }
  return workarea_xywh[3] / (output->gui_scale * output->wld_scale);
}


void Fl_Wayland_Screen_Driver::init() {
  if (!Fl_Wayland_Screen_Driver::wl_registry) open_display();
}


void Fl_Wayland_Screen_Driver::screen_work_area(int &X, int &Y, int &W, int &H, int n)
{
  if (num_screens < 0) init();
  if (n < 0 || n >= num_screens) n = 0;
  if (n == 0) { // for the main screen, these return the work area
    X = Fl::x();
    Y = Fl::y();
    W = Fl::w();
    H = Fl::h();
  } else { // for other screens, work area is full screen,
    screen_xywh(X, Y, W, H, n);
  }
}


void Fl_Wayland_Screen_Driver::screen_xywh(int &X, int &Y, int &W, int &H, int n)
{
  if (num_screens < 0) init();

  if ((n < 0) || (n >= num_screens))
    n = 0;

  if (num_screens > 0) {
    Fl_Wayland_Screen_Driver::output *output;
    int i = 0;
    wl_list_for_each(output, &outputs, link) {
      if (i++ == n) { // n'th screen of the system
        float s = output->gui_scale * output->wld_scale;
        X = output->x / s;
        Y = output->y / s;
        W = output->width / s;
        H = output->height / s;
        break;
      }
    }
  }
}


void Fl_Wayland_Screen_Driver::screen_dpi(float &h, float &v, int n)
{
  if (num_screens < 0) init();
  h = v = 0.0f;

  if (n >= 0 && n < num_screens) {
    Fl_Wayland_Screen_Driver::output *output;
    int i = 0;
    wl_list_for_each(output, &outputs, link) {
      if (i++ == n) { // n'th screen of the system
        h = output->dpi;
        v = output->dpi;
        break;
      }
    }
  }
}


// Implements fl_beep(). See documentation in src/fl_ask.cxx.
void Fl_Wayland_Screen_Driver::beep(int type)
{
  fprintf(stderr, "\007");
}


void Fl_Wayland_Screen_Driver::flush()
{
  if (Fl_Wayland_Screen_Driver::wl_display) {
    wl_display_flush(Fl_Wayland_Screen_Driver::wl_display);
  }
}


extern void fl_fix_focus(); // in Fl.cxx


void Fl_Wayland_Screen_Driver::grab(Fl_Window* win)
{
  if (win) {
    if (!Fl::grab()) {
    }
    Fl::grab_ = win;    // FIXME: Fl::grab_ "should be private", but we need
                        // a way to *set* the variable from the driver!
  } else {
    if (Fl::grab()) {
      // We must keep the grab in the non-EWMH fullscreen case
      Fl::grab_ = 0;    // FIXME: Fl::grab_ "should be private", but we need
                        // a way to *set* the variable from the driver!
      fl_fix_focus();
    }
  }
}


static void set_selection_color(uchar r, uchar g, uchar b)
{
  Fl::set_color(FL_SELECTION_COLOR,r,g,b);
}


static void getsyscolor(const char *key1, const char* key2, const char *arg,
                        const char *defarg, void (*func)(uchar,uchar,uchar)) {
  uchar r, g, b;
  if (!arg) arg = defarg;
  if (!Fl::screen_driver()->parse_color(arg, r, g, b))
    Fl::error("Unknown color: %s", arg);
  else
    func(r, g, b);
}


void Fl_Wayland_Screen_Driver::get_system_colors()
{
  open_display();
  const char* key1 = 0;
  if (Fl::first_window()) key1 = Fl::first_window()->xclass();
  if (!key1) key1 = "fltk";
  if (!bg2_set)
    getsyscolor("Text","background",    fl_bg2, "#ffffff", Fl::background2);
  if (!fg_set)
    getsyscolor(key1,  "foreground",    fl_fg,  "#000000", Fl::foreground);
  if (!bg_set)
    getsyscolor(key1,  "background",    fl_bg,  "#c0c0c0", Fl::background);
  getsyscolor("Text", "selectBackground", 0, "#000080", set_selection_color);
}


Fl_RGB_Image *Fl_Wayland_Screen_Driver::read_win_rectangle(int X, int Y, int w, int h,
                                                           Fl_Window *win,
                                                           bool ignore, bool *p_ignore) {
  struct wld_window* xid = win ? fl_wl_xid(win) : NULL;
  if (win && (!xid || !xid->buffer)) return NULL;
  struct Fl_Wayland_Graphics_Driver::draw_buffer *buffer;
  if (win) buffer = &xid->buffer->draw_buffer;
  else {
    Fl_Image_Surface_Driver *dr = (Fl_Image_Surface_Driver*)Fl_Surface_Device::surface();
    buffer = Fl_Wayland_Graphics_Driver::offscreen_buffer(
                                              dr->image_surface()->offscreen());
  }
  float s = win ?
    Fl_Wayland_Window_Driver::driver(win)->wld_scale() * scale(win->screen_num()) :
                  Fl_Surface_Device::surface()->driver()->scale();
  int Xs, Ys, ws, hs;
  if (s == 1) {
    Xs = X; Ys = Y; ws = w; hs = h;
  } else {
    Xs = Fl_Scalable_Graphics_Driver::floor(X, s);
    Ys = Fl_Scalable_Graphics_Driver::floor(Y, s);
    ws = Fl_Scalable_Graphics_Driver::floor(X+w, s) - Xs;
    hs = Fl_Scalable_Graphics_Driver::floor(Y+h, s) - Ys;
  }
  if (ws == 0 || hs == 0) return NULL;
  uchar *data = new uchar[ws * hs * 3];
  uchar *p = data, *q;
  for (int j = 0; j < hs; j++) {
    q = buffer->buffer + (j+Ys) * buffer->stride + 4 * Xs;
    for (int i = 0; i < ws; i++) {
      *p++ = *(q+2); // R
      *p++ = *(q+1); // G
      *p++ = *q;     // B
      q += 4;
    }
  }
  Fl_RGB_Image *rgb = new Fl_RGB_Image(data, ws, hs, 3);
  rgb->alloc_array = 1;
  return rgb;
}


void Fl_Wayland_Screen_Driver::offscreen_size(Fl_Offscreen off_, int &width, int &height)
{
  struct Fl_Wayland_Graphics_Driver::draw_buffer *off = Fl_Wayland_Graphics_Driver::offscreen_buffer(off_);
  width = off->width;
  height = off->data_size / off->stride;
}


float Fl_Wayland_Screen_Driver::scale(int n) {
  Fl_Wayland_Screen_Driver::output *output;
  int i = 0;
  wl_list_for_each(output, &outputs, link) {
    if (i++ == n) break;
  }
  return output->gui_scale;
}


void Fl_Wayland_Screen_Driver::scale(int n, float f) {
  Fl_Wayland_Screen_Driver::output *output;
  int i = 0;
  wl_list_for_each(output, &outputs, link) {
    if (i++ == n) {
      output->gui_scale = f;
      return;
    }
  }
}


void Fl_Wayland_Screen_Driver::set_cursor() {
  do_set_cursor(seat);
}


struct wl_cursor *Fl_Wayland_Screen_Driver::default_cursor() {
  return seat->default_cursor;
}


void Fl_Wayland_Screen_Driver::default_cursor(struct wl_cursor *cursor) {
  seat->default_cursor = cursor;
  do_set_cursor(seat);
}


struct wl_cursor *Fl_Wayland_Screen_Driver::cache_cursor(const char *cursor_name) {
  return wl_cursor_theme_get_cursor(seat->cursor_theme, cursor_name);
}


void Fl_Wayland_Screen_Driver::reset_cursor() {
  for (int i = 0; i < cursor_count; i++) xc_cursor[i] = NULL;
}


uint32_t Fl_Wayland_Screen_Driver::get_serial() {
  return seat->serial;
}


struct wl_seat*Fl_Wayland_Screen_Driver::get_wl_seat() {
  return seat->wl_seat;
}


char *Fl_Wayland_Screen_Driver::get_seat_name() {
  return seat->name;
}


struct xkb_keymap *Fl_Wayland_Screen_Driver::get_xkb_keymap() {
  return seat->xkb_keymap;
}


int Fl_Wayland_Screen_Driver::get_mouse(int &xx, int &yy) {
  open_display();
  xx = Fl::e_x_root; yy = Fl::e_y_root;
  if (!seat->pointer_focus) return 0;
  Fl_Window *win = Fl_Wayland_Window_Driver::surface_to_window(seat->pointer_focus);
  if (!win) return 0;
  int snum = Fl_Window_Driver::driver(win)->screen_num();
//printf("get_mouse(%dx%d)->%d\n", xx, yy, snum);
  return snum;
}


void Fl_Wayland_Screen_Driver::set_spot(int font, int height, int x, int y, int w, int h, Fl_Window *win) {
  Fl_Wayland_Screen_Driver::insertion_point_location(x, y, height);
}


void Fl_Wayland_Screen_Driver::reset_spot() {
  Fl::compose_state = 0;
  Fl_Wayland_Screen_Driver::next_marked_length = 0;
  Fl_Wayland_Screen_Driver::insertion_point_location_is_valid = false;
}


void Fl_Wayland_Screen_Driver::display(const char *d)
{
  if (d && !wl_registry) { // if display was opened, it's too late
    if (wl_display) {
      // only the wl_display_connect() call was done, redo it because the target
      // Wayland compositor may be different
      wl_display_disconnect(wl_display);
    }
    wl_display = wl_display_connect(d);
    if (!wl_display) {
      fprintf(stderr, "Error: '%s' is not an active Wayland socket\n", d);
      exit(1);
    }
  }
}


void *Fl_Wayland_Screen_Driver::control_maximize_button(void *data) {
  // The code below aims at removing the calling window's fullscreen button
  // while dialog runs. Unfortunately, it doesn't work with some X11 window managers
  // (e.g., KDE, xfce) because the button goes away but doesn't come back,
  // so we move this code to a virtual member function.
  // Noticeably, this code works OK under Wayland.
  struct win_dims {
    Fl_Widget_Tracker *tracker;
    int minw, minh, maxw, maxh;
    struct win_dims *next;
  };

  if (!data) { // this call turns each decorated window's maximize button off
    struct win_dims *first_dim = NULL;
    // consider all bordered, top-level FLTK windows
    Fl_Window *win = Fl::first_window();
    while (win) {
      if (!win->parent() && win->border() &&
          !( ((struct wld_window*)Fl_X::flx(win)->xid)->state &
            LIBDECOR_WINDOW_STATE_MAXIMIZED) ) {
        win_dims *dim = new win_dims;
        dim->tracker = new Fl_Widget_Tracker(win);
        win->get_size_range(&dim->minw, &dim->minh, &dim->maxw, &dim->maxh, NULL, NULL, NULL);
        //make win un-resizable
        win->size_range(win->w(), win->h(), win->w(), win->h());
        dim->next = first_dim;
        first_dim = dim;
      }
      win = Fl::next_window(win);
    }
    return first_dim;
  } else { // this call returns each decorated window's maximize button to its previous state
    win_dims *first_dim = (win_dims *)data;
    while (first_dim) {
      win_dims *dim = first_dim;
      //give back win its resizing parameters
      if (dim->tracker->exists()) {
        Fl_Window *win = (Fl_Window*)dim->tracker->widget();
        win->size_range(dim->minw, dim->minh, dim->maxw, dim->maxh);
      }
      first_dim = dim->next;
      delete dim->tracker;
      delete dim;
    }
    return NULL;
  }
}


int Fl_Wayland_Screen_Driver::poll_or_select_with_delay(double time_to_wait) {
  if (wl_display_dispatch_pending(wl_display) > 0) return 1;
  return Fl_Unix_Screen_Driver::poll_or_select_with_delay(time_to_wait);
}


// like Fl_Wayland_Screen_Driver::poll_or_select_with_delay(0.0) except no callbacks are done:
int Fl_Wayland_Screen_Driver::poll_or_select() {
  int ret = wl_display_prepare_read(wl_display);
  if (ret == 0) wl_display_cancel_read(wl_display);
  else return 1;
  return Fl_Unix_Screen_Driver::poll_or_select();
}


int Fl_Wayland_Screen_Driver::event_key(int k) {
  if (k >= 'A' && k <= 'Z') k += 32;
  return (search_int_vector(key_vector, k) >= 0);
}


int Fl_Wayland_Screen_Driver::get_key(int k) {
  return event_key(k);
}


float Fl_Wayland_Screen_Driver::base_scale(int numscreen) {
  const char *p;
  float factor = 1;
  if ((p = fl_getenv("FLTK_SCALING_FACTOR"))) {
    sscanf(p, "%f", &factor);
  }
  return factor;
}


struct wl_display *fl_wl_display() {
  return Fl_Wayland_Screen_Driver::wl_display;
}