GHOST_SystemX11.cc

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
 * SPDX-FileCopyrightText: 2009 Nokia Corporation and/or its subsidiary(-ies).
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 *
 * Part of this code from Nokia has been taken from Qt, under LGPL license. */

 
#include <X11/XKBlib.h> /* Allow detectable auto-repeat. */
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
 
#include "GHOST_EventButton.hh"
#include "GHOST_EventCursor.hh"
#include "GHOST_EventDragnDrop.hh"
#include "GHOST_EventKey.hh"
#include "GHOST_EventWheel.hh"
#include "GHOST_SystemX11.hh"
#include "GHOST_TimerManager.hh"
#include "GHOST_WindowManager.hh"
#include "GHOST_WindowX11.hh"
#ifdef WITH_INPUT_NDOF
#  include "GHOST_NDOFManagerUnix.hh"
#endif
#include "GHOST_utildefines.hh"
 
#ifdef WITH_XDND
#  include "GHOST_DropTargetX11.hh"
#endif
 
#include "GHOST_Debug.hh"
 
#ifdef WITH_OPENGL_BACKEND
#  include "GHOST_ContextEGL.hh"
#  include "GHOST_ContextGLX.hh"
#endif
 
#ifdef WITH_VULKAN_BACKEND
#  include "GHOST_ContextVK.hh"
#endif
 
#ifdef WITH_XF86KEYSYM
#  include <X11/XF86keysym.h>
#endif
 
#ifdef WITH_X11_XFIXES
#  include <X11/extensions/Xfixes.h>
/* Workaround for XWayland grab glitch: #53004. */
#  define WITH_XWAYLAND_HACK
#endif
 
/* for XIWarpPointer */
#ifdef WITH_X11_XINPUT
#  include <X11/extensions/XInput2.h>
#endif
 
/* For timing */
#include <sys/time.h>
#include <unistd.h>
 
#include <cstdio>  /* for fprintf only */
#include <cstdlib> /* for exit */
#include <iostream>
#include <vector>
 
/* For debugging, so we can break-point X11 errors. */
// #define USE_X11_ERROR_HANDLERS
 
#ifdef WITH_X11_XINPUT
#  define USE_XINPUT_HOTPLUG
#endif
 
/* see #34039 Fix Alt key glitch on Unity desktop */
#define USE_UNITY_WORKAROUND
 
/* Fix 'shortcut' part of keyboard reading code only ever using first defined key-map
 * instead of active one. See #47228 and D1746 */
#define USE_NON_LATIN_KB_WORKAROUND
 
static uchar bit_is_on(const uchar *ptr, int bit)
{
  return ptr[bit >> 3] & (1 << (bit & 7));
}
 
static GHOST_TKey ghost_key_from_keysym(const KeySym key);
static GHOST_TKey ghost_key_from_keycode(const XkbDescPtr xkb_descr, const KeyCode keycode);
static GHOST_TKey ghost_key_from_keysym_or_keycode(const KeySym key_sym,
                                                   const XkbDescPtr xkb_descr,
                                                   const KeyCode keycode);
 
/* these are for copy and select copy */
static char *txt_cut_buffer = nullptr;
static char *txt_select_buffer = nullptr;
 
#ifdef WITH_XWAYLAND_HACK
static bool use_xwayland_hack = false;
#endif
 
using namespace std;
 
GHOST_SystemX11::GHOST_SystemX11()
    : GHOST_System(),
      xkb_descr_(nullptr),
      keyboard_vector_{0},
#ifdef WITH_X11_XINPUT
      last_key_time_(0),
#endif
      keycode_last_repeat_key_(uint(-1))
{
  XInitThreads();
  display_ = XOpenDisplay(nullptr);
 
  if (!display_) {
    throw std::runtime_error("unable to open a display!");
  }
 
#ifdef USE_X11_ERROR_HANDLERS
  (void)XSetErrorHandler(GHOST_X11_ApplicationErrorHandler);
  (void)XSetIOErrorHandler(GHOST_X11_ApplicationIOErrorHandler);
#endif
 
#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
  /* NOTE: Don't open connection to XIM server here, because the locale has to be
   * set before opening the connection but `setlocale()` has not been called yet.
   * the connection will be opened after entering the event loop. */
  xim_ = nullptr;
#endif
 
#define GHOST_INTERN_ATOM_IF_EXISTS(atom) \
  { \
    atom_.atom = XInternAtom(display_, #atom, True); \
  } \
  (void)0
#define GHOST_INTERN_ATOM(atom) \
  { \
    atom_.atom = XInternAtom(display_, #atom, False); \
  } \
  (void)0
 
  GHOST_INTERN_ATOM_IF_EXISTS(WM_DELETE_WINDOW);
  GHOST_INTERN_ATOM(WM_PROTOCOLS);
  GHOST_INTERN_ATOM(WM_TAKE_FOCUS);
  GHOST_INTERN_ATOM(WM_STATE);
  GHOST_INTERN_ATOM(WM_CHANGE_STATE);
  GHOST_INTERN_ATOM(_NET_WM_STATE);
  GHOST_INTERN_ATOM(_NET_WM_STATE_MAXIMIZED_HORZ);
  GHOST_INTERN_ATOM(_NET_WM_STATE_MAXIMIZED_VERT);
 
  GHOST_INTERN_ATOM(_NET_WM_STATE_FULLSCREEN);
  GHOST_INTERN_ATOM(_MOTIF_WM_HINTS);
  GHOST_INTERN_ATOM(TARGETS);
  GHOST_INTERN_ATOM(STRING);
  GHOST_INTERN_ATOM(COMPOUND_TEXT);
  GHOST_INTERN_ATOM(TEXT);
  GHOST_INTERN_ATOM(CLIPBOARD);
  GHOST_INTERN_ATOM(PRIMARY);
  GHOST_INTERN_ATOM(XCLIP_OUT);
  GHOST_INTERN_ATOM(INCR);
  GHOST_INTERN_ATOM(UTF8_STRING);
#ifdef WITH_X11_XINPUT
  atom_.TABLET = XInternAtom(display_, XI_TABLET, False);
#endif
 
#undef GHOST_INTERN_ATOM_IF_EXISTS
#undef GHOST_INTERN_ATOM
 
  last_warp_x_ = 0;
  last_warp_y_ = 0;
  last_release_keycode_ = 0;
  last_release_time_ = 0;
 
  /* Use detectable auto-repeat, mac and windows also do this. */
  int use_xkb;
  int xkb_opcode, xkb_event, xkb_error;
  int xkb_major = XkbMajorVersion, xkb_minor = XkbMinorVersion;
 
  use_xkb = XkbQueryExtension(
      display_, &xkb_opcode, &xkb_event, &xkb_error, &xkb_major, &xkb_minor);
  if (use_xkb) {
    XkbSetDetectableAutoRepeat(display_, true, nullptr);
 
    xkb_descr_ = XkbGetMap(display_, 0, XkbUseCoreKbd);
    if (xkb_descr_) {
      XkbGetNames(display_, XkbKeyNamesMask, xkb_descr_);
      XkbGetControls(display_, XkbPerKeyRepeatMask | XkbRepeatKeysMask, xkb_descr_);
    }
  }
 
#ifdef WITH_XWAYLAND_HACK
  use_xwayland_hack = getenv("WAYLAND_DISPLAY") != nullptr;
#endif
 
#ifdef WITH_X11_XINPUT
  /* Detect if we have XINPUT (for reuse). */
  {
    memset(&xinput_version_, 0, sizeof(xinput_version_));
    XExtensionVersion *version = XGetExtensionVersion(display_, INAME);
    if (version && (version != (XExtensionVersion *)NoSuchExtension)) {
      if (version->present) {
        xinput_version_ = *version;
      }
      XFree(version);
    }
  }
 
#  ifdef USE_XINPUT_HOTPLUG
  if (xinput_version_.present) {
    XEventClass class_presence;
    int xi_presence;
    DevicePresence(display_, xi_presence, class_presence);
    XSelectExtensionEvent(
        display_, RootWindow(display_, DefaultScreen(display_)), &class_presence, 1);
    (void)xi_presence;
  }
#  endif /* USE_XINPUT_HOTPLUG */
 
  refreshXInputDevices();
#endif /* WITH_X11_XINPUT */
}
 
GHOST_SystemX11::~GHOST_SystemX11()
{
#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
  if (xim_) {
    XCloseIM(xim_);
  }
#endif
 
#ifdef WITH_X11_XINPUT
  /* Close tablet devices. */
  clearXInputDevices();
#endif /* WITH_X11_XINPUT */
 
  if (xkb_descr_) {
    XkbFreeKeyboard(xkb_descr_, XkbAllComponentsMask, true);
  }
 
  XCloseDisplay(display_);
}
 
GHOST_TSuccess GHOST_SystemX11::init()
{
  GHOST_TSuccess success = GHOST_System::init();
 
  if (success) {
#ifdef WITH_INPUT_NDOF
    ndof_manager_ = new GHOST_NDOFManagerUnix(*this);
#endif
    return GHOST_kSuccess;
  }
 
  return GHOST_kFailure;
}
 
uint64_t GHOST_SystemX11::getMilliSeconds() const
{
  timespec ts = {0, 0};
  if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
    GHOST_ASSERT(false, "Could not instantiate monotonic timer!");
  }
  /* Taking care not to overflow the tv.tv_sec * 1000 */
  const uint64_t time = (uint64_t(ts.tv_sec) * 1000) + uint64_t(ts.tv_nsec / 1000000);
  return time;
}
 
uint64_t GHOST_SystemX11::ms_from_input_time(Time timestamp) const
{
  /* NOTE(@ideasman42): Return a time compatible with `getMilliSeconds()`,
   * this is needed as X11 time-stamps use monotonic time.
   * The X11 implementation *could* use any basis, in practice though we are supporting
   * XORG/LIBINPUT which uses time-stamps based on the monotonic time,
   * Needed to resolve failure to detect double-clicking, see: #40009. */
 
  /* Accumulate time rollover (as well as store the initial delta from #getMilliSeconds). */
  static uint64_t timestamp_offset = 0;
 
  /* The last event time (to detect rollover). */
  static uint32_t timestamp_prev = 0;
  /* Causes the X11 time-stamp to be zero based. */
  static uint32_t timestamp_start = 0;
 
  static bool is_time_init = false;
 
#if 0
  /* Force rollover after 2 seconds (for testing). */
  {
    const uint32_t timestamp_wrap_ms = 2000;
    static uint32_t timestamp_offset_fake = 0;
    if (!is_time_init) {
      timestamp_offset_fake = UINT32_MAX - (timestamp + timestamp_wrap_ms);
    }
    timestamp = uint32_t(timestamp + timestamp_offset_fake);
  }
#endif
 
  if (!is_time_init) {
    /* Store the initial delta in the rollover. */
    const uint64_t current_time = getMilliSeconds();
    timestamp_offset = current_time;
    timestamp_start = timestamp;
  }
 
  /* Always remove the start time.
   * This changes the point where `uint32_t` rolls over, but that's OK. */
  timestamp = uint32_t(timestamp) - timestamp_start;
 
  if (!is_time_init) {
    is_time_init = true;
    timestamp_prev = timestamp;
  }
 
  if (UNLIKELY(timestamp < timestamp_prev)) {
    /* Only rollover if this is within a reasonable range. */
    if (UNLIKELY(timestamp_prev - timestamp > UINT32_MAX / 2)) {
      timestamp_offset += uint64_t(UINT32_MAX) + 1;
    }
  }
  timestamp_prev = timestamp;
 
  uint64_t timestamp_final = (uint64_t(timestamp) + timestamp_offset);
 
  return timestamp_final;
}
 
uint8_t GHOST_SystemX11::getNumDisplays() const
{
  return uint8_t(1);
}
 
void GHOST_SystemX11::getMainDisplayDimensions(uint32_t &width, uint32_t &height) const
{
  if (display_) {
    /* NOTE(@ideasman42): for this to work as documented,
     * we would need to use Xinerama check r54370 for code that did this,
     * we've since removed since its not worth the extra dependency. */
    getAllDisplayDimensions(width, height);
  }
}
 
void GHOST_SystemX11::getAllDisplayDimensions(uint32_t &width, uint32_t &height) const
{
  if (display_) {
    width = DisplayWidth(display_, DefaultScreen(display_));
    height = DisplayHeight(display_, DefaultScreen(display_));
  }
}
 
GHOST_IWindow *GHOST_SystemX11::createWindow(const char *title,
                                             int32_t left,
                                             int32_t top,
                                             uint32_t width,
                                             uint32_t height,
                                             GHOST_TWindowState state,
                                             GHOST_GPUSettings gpu_settings,
                                             const bool exclusive,
                                             const bool is_dialog,
                                             const GHOST_IWindow *parent_window)
{
  GHOST_WindowX11 *window = nullptr;
 
  if (!display_) {
    return nullptr;
  }
 
  const GHOST_ContextParams context_params = GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpu_settings);
  window = new GHOST_WindowX11(this,
                               display_,
                               title,
                               left,
                               top,
                               width,
                               height,
                               state,
                               (GHOST_WindowX11 *)parent_window,
                               gpu_settings.context_type,
                               is_dialog,
                               context_params,
                               exclusive,
                               gpu_settings.preferred_device);
 
  if (window) {
    /* Both are now handle in GHOST_WindowX11.cc
     * Focus and Delete atoms. */
 
    if (window->getValid()) {
      /* Store the pointer to the window */
      window_manager_->addWindow(window);
      window_manager_->setActiveWindow(window);
      pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window));
    }
    else {
      delete window;
      window = nullptr;
    }
  }
  return window;
}
 
GHOST_IContext *GHOST_SystemX11::createOffscreenContext(GHOST_GPUSettings gpu_settings)
{
  const GHOST_ContextParams context_params_offscreen =
      GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpu_settings);
 
  switch (gpu_settings.context_type) {
#ifdef WITH_VULKAN_BACKEND
    case GHOST_kDrawingContextTypeVulkan: {
      GHOST_Context *context = new GHOST_ContextVK(context_params_offscreen,
                                                   GHOST_kVulkanPlatformX11,
                                                   0,
                                                   display_,
                                                   nullptr,
                                                   nullptr,
                                                   nullptr,
                                                   1,
                                                   2,
                                                   gpu_settings.preferred_device);
      if (context->initializeDrawingContext()) {
        return context;
      }
      delete context;
      return nullptr;
    }
#endif
 
#ifdef WITH_OPENGL_BACKEND
    case GHOST_kDrawingContextTypeOpenGL: {
      for (int minor = 6; minor >= 3; --minor) {
        GHOST_Context *context = new GHOST_ContextGLX(
            context_params_offscreen,
            (Window) nullptr,
            display_,
            (GLXFBConfig) nullptr,
            GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
            4,
            minor,
            GHOST_OPENGL_GLX_CONTEXT_FLAGS |
                (context_params_offscreen.is_debug ? GLX_CONTEXT_DEBUG_BIT_ARB : 0),
            GHOST_OPENGL_GLX_RESET_NOTIFICATION_STRATEGY);
        if (context->initializeDrawingContext()) {
          return context;
        }
        delete context;
      }
      return nullptr;
    }
#endif
 
    default:
      /* Unsupported backend. */
      return nullptr;
  }
}
 
GHOST_TSuccess GHOST_SystemX11::disposeContext(GHOST_IContext *context)
{
  delete context;
 
  return GHOST_kSuccess;
}
 
#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
static void destroyIMCallback(XIM /*xim*/, XPointer ptr, XPointer /*data*/)
{
  GHOST_PRINT("XIM server died\n");
 
  if (ptr) {
    *(XIM *)ptr = nullptr;
  }
}
 
bool GHOST_SystemX11::openX11_IM()
{
  if (!display_) {
    return false;
  }
 
  /* set locale modifiers such as `@im=ibus` specified by XMODIFIERS. */
  XSetLocaleModifiers("");
 
  xim_ = XOpenIM(display_, nullptr, (char *)GHOST_X11_RES_NAME, (char *)GHOST_X11_RES_CLASS);
  if (!xim_) {
    return false;
  }
 
  XIMCallback destroy;
  destroy.callback = (XIMProc)destroyIMCallback;
  destroy.client_data = (XPointer)&xim_;
  XSetIMValues(xim_, XNDestroyCallback, &destroy, nullptr);
  return true;
}
#endif
 
GHOST_WindowX11 *GHOST_SystemX11::findGhostWindow(Window xwind) const
{
 
  if (xwind == 0) {
    return nullptr;
  }
 
  /* It is not entirely safe to do this as the back-pointer may point
   * to a window that has recently been removed.
   * We should always check the window manager's list of windows
   * and only process events on these windows. */
 
  const vector<GHOST_IWindow *> &win_vec = window_manager_->getWindows();
 
  vector<GHOST_IWindow *>::const_iterator win_it = win_vec.begin();
  vector<GHOST_IWindow *>::const_iterator win_end = win_vec.end();
 
  for (; win_it != win_end; ++win_it) {
    GHOST_WindowX11 *window = static_cast<GHOST_WindowX11 *>(*win_it);
    if (window->getXWindow() == xwind) {
      return window;
    }
  }
  return nullptr;
}
 
static void SleepTillEvent(Display *display, int64_t maxSleep)
{
  int fd = ConnectionNumber(display);
  fd_set fds;
 
  FD_ZERO(&fds);
  FD_SET(fd, &fds);
 
  if (maxSleep == -1) {
    select(fd + 1, &fds, nullptr, nullptr, nullptr);
  }
  else {
    timeval tv;
 
    tv.tv_sec = maxSleep / 1000;
    tv.tv_usec = (maxSleep - tv.tv_sec * 1000) * 1000;
 
    select(fd + 1, &fds, nullptr, nullptr, &tv);
  }
}
 
/* This function borrowed from QT's X11 support `qclipboard_x11.cpp`. */
struct init_timestamp_data {
  Time timestamp;
};
 
static Bool init_timestamp_scanner(Display * /*display*/, XEvent *event, XPointer arg)
{
  init_timestamp_data *data = reinterpret_cast<init_timestamp_data *>(arg);
  switch (event->type) {
    case ButtonPress:
    case ButtonRelease:
      data->timestamp = event->xbutton.time;
      break;
    case MotionNotify:
      data->timestamp = event->xmotion.time;
      break;
    case KeyPress:
    case KeyRelease:
      data->timestamp = event->xkey.time;
      break;
    case PropertyNotify:
      data->timestamp = event->xproperty.time;
      break;
    case EnterNotify:
    case LeaveNotify:
      data->timestamp = event->xcrossing.time;
      break;
    case SelectionClear:
      data->timestamp = event->xselectionclear.time;
      break;
    default:
      break;
  }
 
  return false;
}
 
Time GHOST_SystemX11::lastEventTime(Time default_time)
{
  init_timestamp_data data;
  data.timestamp = default_time;
  XEvent ev;
  XCheckIfEvent(display_, &ev, &init_timestamp_scanner, (XPointer)&data);
 
  return data.timestamp;
}
 
bool GHOST_SystemX11::processEvents(bool waitForEvent)
{
  /* Get all the current events -- translate them into
   * ghost events and call base class pushEvent() method. */
 
  bool anyProcessed = false;
 
  do {
    GHOST_TimerManager *timerMgr = getTimerManager();
 
    if (waitForEvent && dirty_windows_.empty() && !XPending(display_)) {
      uint64_t next = timerMgr->nextFireTime();
 
      if (next == GHOST_kFireTimeNever) {
        SleepTillEvent(display_, -1);
      }
      else {
        const int64_t maxSleep = next - getMilliSeconds();
 
        if (maxSleep >= 0) {
          SleepTillEvent(display_, next - getMilliSeconds());
        }
      }
    }
 
    if (timerMgr->fireTimers(getMilliSeconds())) {
      anyProcessed = true;
    }
 
    while (XPending(display_)) {
      XEvent xevent;
      XNextEvent(display_, &xevent);
 
#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
      /* open connection to XIM server and create input context (XIC)
       * when receiving the first FocusIn or KeyPress event after startup,
       * or recover XIM and XIC when the XIM server has been restarted */
      if (ELEM(xevent.type, FocusIn, KeyPress)) {
        if (!xim_ && openX11_IM()) {
          GHOST_PRINT("Connected to XIM server\n");
        }
 
        if (xim_) {
          GHOST_WindowX11 *window = findGhostWindow(xevent.xany.window);
          if (window && !window->getX11_XIC() && window->createX11_XIC()) {
            GHOST_PRINT("XIM input context created\n");
            if (xevent.type == KeyPress) {
              /* we can assume the window has input focus
               * here, because key events are received only
               * when the window is focused. */
              XSetICFocus(window->getX11_XIC());
            }
          }
        }
      }
 
      /* Ensure generated time-stamps are non-zero. */
      if (ELEM(xevent.type, KeyPress, KeyRelease)) {
        if (xevent.xkey.time != 0) {
          last_key_time_ = xevent.xkey.time;
        }
      }
 
      /* dispatch event to XIM server */
      if (XFilterEvent(&xevent, (Window) nullptr) == True) {
        /* do nothing now, the event is consumed by XIM. */
        continue;
      }
#endif
      /* When using auto-repeat, some key-press events can actually come *after* the
       * last key-release. The next code takes care of that. */
      if (xevent.type == KeyRelease) {
        last_release_keycode_ = xevent.xkey.keycode;
        last_release_time_ = xevent.xkey.time;
      }
      else if (xevent.type == KeyPress) {
        if ((xevent.xkey.keycode == last_release_keycode_) &&
            (xevent.xkey.time <= last_release_time_))
        {
          continue;
        }
      }
 
      processEvent(&xevent);
      anyProcessed = true;
 
#ifdef USE_UNITY_WORKAROUND
      /* NOTE: processEvent() can't include this code because
       * KeymapNotify event have no valid window information. */
 
      /* the X server generates KeymapNotify event immediately after
       * every EnterNotify and FocusIn event.  we handle this event
       * to correct modifier states. */
      if (xevent.type == FocusIn) {
        /* use previous event's window, because KeymapNotify event
         * has no window information. */
        GHOST_WindowX11 *window = findGhostWindow(xevent.xany.window);
        if (window && XPending(display_) >= 2) {
          XNextEvent(display_, &xevent);
 
          if (xevent.type == KeymapNotify) {
            XEvent xev_next;
 
            /* check if KeyPress or KeyRelease event was generated
             * in order to confirm the window is active. */
            XPeekEvent(display_, &xev_next);
 
            if (ELEM(xev_next.type, KeyPress, KeyRelease)) {
              const uint64_t event_ms = ms_from_input_time(xev_next.xkey.time);
              /* XK_Hyper_L/R currently unused. */
              const static KeySym modifiers[] = {
                  XK_Shift_L,
                  XK_Shift_R,
                  XK_Control_L,
                  XK_Control_R,
                  XK_Alt_L,
                  XK_Alt_R,
                  XK_Super_L,
                  XK_Super_R,
                  XK_Hyper_L,
                  XK_Hyper_R,
              };
 
              for (int i = 0; i < int(ARRAY_SIZE(modifiers)); i++) {
                KeyCode kc = XKeysymToKeycode(display_, modifiers[i]);
                if (kc != 0 && ((xevent.xkeymap.key_vector[kc >> 3] >> (kc & 7)) & 1) != 0) {
                  pushEvent(new GHOST_EventKey(event_ms,
                                               GHOST_kEventKeyDown,
                                               window,
                                               ghost_key_from_keysym(modifiers[i]),
                                               false,
                                               nullptr));
                }
              }
            }
          }
        }
      }
#endif /* USE_UNITY_WORKAROUND */
    }
 
    if (generateWindowExposeEvents()) {
      anyProcessed = true;
    }
 
#ifdef WITH_INPUT_NDOF
    if (static_cast<GHOST_NDOFManagerUnix *>(ndof_manager_)->processEvents()) {
      anyProcessed = true;
    }
#endif
 
  } while (waitForEvent && !anyProcessed);
 
  return anyProcessed;
}
 
#ifdef WITH_X11_XINPUT
static bool checkTabletProximity(Display *display, XDevice *device)
{
  /* we could have true/false/not-found return value, but for now false is OK */
 
  /* see: state.c from xinput, to get more data out of the device */
  XDeviceState *state;
 
  if (device == nullptr) {
    return false;
  }
 
  /* needed since unplugging will abort() without this */
  GHOST_X11_ERROR_HANDLERS_OVERRIDE(handler_store);
 
  state = XQueryDeviceState(display, device);
 
  GHOST_X11_ERROR_HANDLERS_RESTORE(handler_store);
 
  if (state) {
    XInputClass *cls = state->data;
    // printf("%d class%s :\n", state->num_classes, (state->num_classes > 1) ? "es" : "");
    for (int loop = 0; loop < state->num_classes; loop++) {
      switch (cls->c_class) {
        case ValuatorClass:
          XValuatorState *val_state = (XValuatorState *)cls;
          // printf("ValuatorClass Mode=%s Proximity=%s\n",
          //        val_state->mode & 1 ? "Absolute" : "Relative",
          //        val_state->mode & 2 ? "Out" : "In");
 
          if ((val_state->mode & 2) == 0) {
            XFreeDeviceState(state);
            return true;
          }
          break;
      }
      cls = (XInputClass *)((char *)cls + cls->length);
    }
    XFreeDeviceState(state);
  }
  return false;
}
#endif /* WITH_X11_XINPUT */
 
void GHOST_SystemX11::processEvent(XEvent *xe)
{
  GHOST_WindowX11 *window = findGhostWindow(xe->xany.window);
  GHOST_Event *g_event = nullptr;
 
  /* Detect auto-repeat. */
  bool is_repeat = false;
  if (ELEM(xe->type, KeyPress, KeyRelease)) {
    XKeyEvent *xke = &(xe->xkey);
 
    /* Set to true if this key will repeat. */
    bool is_repeat_keycode = false;
 
    if (xkb_descr_ != nullptr) {
      /* Use XKB support. */
      is_repeat_keycode = (
          /* Should always be true, check just in case. */
          (xke->keycode < (XkbPerKeyBitArraySize << 3)) &&
          bit_is_on(xkb_descr_->ctrls->per_key_repeat, xke->keycode));
    }
    else {
      /* No XKB support (filter by modifier). */
      switch (XLookupKeysym(xke, 0)) {
        case XK_Shift_L:
        case XK_Shift_R:
        case XK_Control_L:
        case XK_Control_R:
        case XK_Alt_L:
        case XK_Alt_R:
        case XK_Super_L:
        case XK_Super_R:
        case XK_Hyper_L:
        case XK_Hyper_R:
        case XK_Caps_Lock:
        case XK_Scroll_Lock:
        case XK_Num_Lock: {
          break;
        }
        default: {
          is_repeat_keycode = true;
        }
      }
    }
 
    if (is_repeat_keycode) {
      if (xe->type == KeyPress) {
        if (keycode_last_repeat_key_ == xke->keycode) {
          is_repeat = true;
        }
        keycode_last_repeat_key_ = xke->keycode;
      }
      else {
        if (keycode_last_repeat_key_ == xke->keycode) {
          keycode_last_repeat_key_ = uint(-1);
        }
      }
    }
  }
  else if (xe->type == EnterNotify) {
    /* We can't tell how the key state changed, clear it to avoid stuck keys. */
    keycode_last_repeat_key_ = uint(-1);
  }
 
#ifdef USE_XINPUT_HOTPLUG
  /* Hot-Plug support */
  if (xinput_version_.present) {
    XEventClass class_presence;
    int xi_presence;
 
    DevicePresence(display_, xi_presence, class_presence);
    (void)class_presence;
 
    if (xe->type == xi_presence) {
      const XDevicePresenceNotifyEvent *notify_event = (const XDevicePresenceNotifyEvent *)xe;
      if (ELEM(notify_event->devchange, DeviceEnabled, DeviceDisabled, DeviceAdded, DeviceRemoved))
      {
        refreshXInputDevices();
 
        /* update all window events */
        {
          const vector<GHOST_IWindow *> &win_vec = window_manager_->getWindows();
          vector<GHOST_IWindow *>::const_iterator win_it = win_vec.begin();
          vector<GHOST_IWindow *>::const_iterator win_end = win_vec.end();
 
          for (; win_it != win_end; ++win_it) {
            GHOST_WindowX11 *window_xinput = static_cast<GHOST_WindowX11 *>(*win_it);
            window_xinput->refreshXInputDevices();
          }
        }
      }
    }
  }
#endif /* USE_XINPUT_HOTPLUG */
 
  if (!window) {
    return;
  }
 
#ifdef WITH_X11_XINPUT
  /* Proximity-Out Events are not reliable, if the tablet is active - check on each event
   * this adds a little overhead but only while the tablet is in use.
   * in the future we could have a ghost call window->CheckTabletProximity()
   * but for now enough parts of the code are checking 'Active'
   * - campbell */
  if (window->GetTabletData().Active != GHOST_kTabletModeNone) {
    bool any_proximity = false;
 
    for (const GHOST_TabletX11 &xtablet : xtablets_) {
      if (checkTabletProximity(xe->xany.display, xtablet.Device)) {
        any_proximity = true;
      }
    }
 
    if (!any_proximity) {
      // printf("proximity disable\n");
      window->GetTabletData().Active = GHOST_kTabletModeNone;
    }
  }
#endif /* WITH_X11_XINPUT */
  switch (xe->type) {
    case Expose: {
      const XExposeEvent &xee = xe->xexpose;
 
      if (xee.count == 0) {
        /* Only generate a single expose event per read of the event queue. */
 
        /* Event has no timestamp. */
        const uint64_t event_ms = getMilliSeconds();
 
        g_event = new GHOST_Event(event_ms, GHOST_kEventWindowUpdate, window);
      }
      break;
    }
 
    case MotionNotify: {
      const XMotionEvent &xme = xe->xmotion;
      const uint64_t event_ms = ms_from_input_time(xme.time);
 
      bool is_tablet = window->GetTabletData().Active != GHOST_kTabletModeNone;
 
      if (is_tablet == false && window->getCursorGrabModeIsWarp()) {
        int32_t x_new = xme.x_root;
        int32_t y_new = xme.y_root;
        int32_t x_accum, y_accum;
 
        /* Warp within bounds. */
        {
          GHOST_Rect bounds;
          int32_t bounds_margin = 0;
          GHOST_TAxisFlag bounds_axis = GHOST_kAxisNone;
 
          if (window->getCursorGrabMode() == GHOST_kGrabHide) {
            window->getClientBounds(bounds);
 
            /* TODO(@ideasman42): warp the cursor to `window->getCursorGrabInitPos`,
             * on every motion event, see: D16557 (alternative fix for #102346). */
            const int32_t subregion_div = 4; /* One quarter of the region. */
            const int32_t size[2] = {bounds.getWidth(), bounds.getHeight()};
            const int32_t center[2] = {
                (bounds.l_ + bounds.r_) / 2,
                (bounds.t_ + bounds.b_) / 2,
            };
            /* Shrink the box to prevent the cursor escaping. */
            bounds.l_ = center[0] - (size[0] / (subregion_div * 2));
            bounds.r_ = center[0] + (size[0] / (subregion_div * 2));
            bounds.t_ = center[1] - (size[1] / (subregion_div * 2));
            bounds.b_ = center[1] + (size[1] / (subregion_div * 2));
            bounds_margin = 0;
            bounds_axis = GHOST_TAxisFlag(GHOST_kAxisX | GHOST_kAxisY);
          }
          else {
            /* Fallback to window bounds. */
            if (window->getCursorGrabBounds(bounds) == GHOST_kFailure) {
              window->getClientBounds(bounds);
            }
            /* Could also clamp to screen bounds wrap with a window outside the view will
             * fail at the moment. Use offset of 8 in case the window is at screen bounds. */
            bounds_margin = 8;
            bounds_axis = window->getCursorGrabAxis();
          }
 
          /* Could also clamp to screen bounds wrap with a window outside the view will
           * fail at the moment. Use inset in case the window is at screen bounds. */
          bounds.wrapPoint(x_new, y_new, bounds_margin, bounds_axis);
        }
 
        window->getCursorGrabAccum(x_accum, y_accum);
 
        if (x_new != xme.x_root || y_new != xme.y_root) {
          /* Use time of last event to avoid wrapping several times on the 'same' actual wrap.
           * Note that we need to deal with X and Y separately as those might wrap at the same time
           * but still in two different events (corner case, see #74918).
           * We also have to add a few extra milliseconds of 'padding', as sometimes we get two
           * close events that will generate extra wrap on the same axis within those few
           * milliseconds. */
          if (x_new != xme.x_root && xme.time > last_warp_x_) {
            x_accum += (xme.x_root - x_new);
            last_warp_x_ = lastEventTime(xme.time) + 25;
          }
          if (y_new != xme.y_root && xme.time > last_warp_y_) {
            y_accum += (xme.y_root - y_new);
            last_warp_y_ = lastEventTime(xme.time) + 25;
          }
          window->setCursorGrabAccum(x_accum, y_accum);
          /* When wrapping we don't need to add an event because the
           * #setCursorPosition call will cause a new event after. */
          setCursorPosition(x_new, y_new); /* wrap */
        }
        else {
          g_event = new GHOST_EventCursor(event_ms,
                                          GHOST_kEventCursorMove,
                                          window,
                                          xme.x_root + x_accum,
                                          xme.y_root + y_accum,
                                          window->GetTabletData());
        }
      }
      else {
        g_event = new GHOST_EventCursor(event_ms,
                                        GHOST_kEventCursorMove,
                                        window,
                                        xme.x_root,
                                        xme.y_root,
                                        window->GetTabletData());
      }
      break;
    }
 
    case KeyPress:
    case KeyRelease: {
      XKeyEvent *xke = &(xe->xkey);
#ifdef WITH_X11_XINPUT
      /* Can be zero for XIM generated events. */
      const Time time = xke->time ? xke->time : last_key_time_;
#else
      const Time time = xke->time;
#endif
      const uint64_t event_ms = ms_from_input_time(time);
 
      KeySym key_sym;
      char *utf8_buf = nullptr;
      char ascii;
 
#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
      /* `utf8_array[]` is initial buffer used for #Xutf8LookupString().
       * if the length of the UTF8 string exceeds this array, allocate
       * another memory area and call #Xutf8LookupString() again.
       * the last 5 bytes are used to avoid segfault that might happen
       * at the end of this buffer when the constructor of #GHOST_EventKey
       * reads 6 bytes regardless of the effective data length. */
      char utf8_array[16 * 6 + 5]; /* 16 UTF8 characters. */
      int len = 1;                 /* At least one null character will be stored. */
#else
      char utf8_array[sizeof(GHOST_TEventKeyData::utf8_buf)] = {'\0'};
#endif
      GHOST_TEventType type = (xke->type == KeyPress) ? GHOST_kEventKeyDown : GHOST_kEventKeyUp;
 
      GHOST_TKey gkey;
 
#ifdef USE_NON_LATIN_KB_WORKAROUND
      /* XXX: Code below is kinda awfully convoluted... Issues are:
       * - In keyboards like Latin ones, numbers need a 'Shift' to be accessed but key_sym
       *   is unmodified (or anyone swapping the keys with `xmodmap`).
       * - #XLookupKeysym seems to always use first defined key-map (see #47228), which generates
       *   key-codes unusable by #ghost_key_from_keysym for non-Latin-compatible key-maps.
       *
       * To address this, we:
       * - Try to get a 'number' key_sym using #XLookupKeysym (with virtual shift modifier),
       *   in a very restrictive set of cases.
       * - Fallback to #XLookupString to get a key_sym from active user-defined key-map.
       *
       * Note that:
       * - This effectively 'lock' main number keys to always output number events
       *   (except when using alt-gr).
       * - This enforces users to use an ASCII-compatible key-map with Blender -
       *   but at least it gives predictable and consistent results.
       *
       * Also, note that nothing in XLib sources [1] makes it obvious why those two functions give
       * different key_sym results.
       *
       * [1] http://cgit.freedesktop.org/xorg/lib/libX11/tree/src/KeyBind.c
       */
      KeySym key_sym_str;
      /* Mode_switch 'modifier' is `AltGr` - when this one or Shift are enabled,
       * we do not want to apply that 'forced number' hack. */
      const uint mode_switch_mask = XkbKeysymToModifiers(xke->display, XK_Mode_switch);
      const uint number_hack_forbidden_kmods_mask = mode_switch_mask | ShiftMask;
      if ((xke->keycode >= 10 && xke->keycode < 20) &&
          ((xke->state & number_hack_forbidden_kmods_mask) == 0))
      {
        key_sym = XLookupKeysym(xke, ShiftMask);
        if (!((key_sym >= XK_0) && (key_sym <= XK_9))) {
          key_sym = XLookupKeysym(xke, 0);
        }
      }
      else {
        key_sym = XLookupKeysym(xke, 0);
      }
 
      if (!XLookupString(xke, &ascii, 1, &key_sym_str, nullptr)) {
        ascii = '\0';
      }
 
      /* Only allow a limited set of keys from XLookupKeysym,
       * all others we take from XLookupString, unless it gives unknown key... */
      gkey = ghost_key_from_keysym_or_keycode(key_sym, xkb_descr_, xke->keycode);
      switch (gkey) {
        case GHOST_kKeyRightAlt:
        case GHOST_kKeyLeftAlt:
        case GHOST_kKeyRightShift:
        case GHOST_kKeyLeftShift:
        case GHOST_kKeyRightControl:
        case GHOST_kKeyLeftControl:
        case GHOST_kKeyLeftOS:
        case GHOST_kKeyRightOS:
        case GHOST_kKeyLeftHyper:
        case GHOST_kKeyRightHyper:
        case GHOST_kKey0:
        case GHOST_kKey1:
        case GHOST_kKey2:
        case GHOST_kKey3:
        case GHOST_kKey4:
        case GHOST_kKey5:
        case GHOST_kKey6:
        case GHOST_kKey7:
        case GHOST_kKey8:
        case GHOST_kKey9:
        case GHOST_kKeyNumpad0:
        case GHOST_kKeyNumpad1:
        case GHOST_kKeyNumpad2:
        case GHOST_kKeyNumpad3:
        case GHOST_kKeyNumpad4:
        case GHOST_kKeyNumpad5:
        case GHOST_kKeyNumpad6:
        case GHOST_kKeyNumpad7:
        case GHOST_kKeyNumpad8:
        case GHOST_kKeyNumpad9:
        case GHOST_kKeyNumpadPeriod:
        case GHOST_kKeyNumpadEnter:
        case GHOST_kKeyNumpadPlus:
        case GHOST_kKeyNumpadMinus:
        case GHOST_kKeyNumpadAsterisk:
        case GHOST_kKeyNumpadSlash:
          break;
        default: {
          GHOST_TKey gkey_str = ghost_key_from_keysym(key_sym_str);
          if (gkey_str != GHOST_kKeyUnknown) {
            gkey = gkey_str;
          }
        }
      }
#else
      /* In keyboards like Latin ones,
       * numbers needs a 'Shift' to be accessed but key_sym
       * is unmodified (or anyone swapping the keys with `xmodmap`).
       *
       * Here we look at the 'Shifted' version of the key.
       * If it is a number, then we take it instead of the normal key.
       *
       * The modified key is sent in the `ascii`s variable anyway.
       */
      if ((xke->keycode >= 10 && xke->keycode < 20) &&
          ((key_sym = XLookupKeysym(xke, ShiftMask)) >= XK_0) && (key_sym <= XK_9))
      {
        /* Pass (keep shifted `key_sym`). */
      }
      else {
        /* regular case */
        key_sym = XLookupKeysym(xke, 0);
      }
 
      gkey = ghost_key_from_keysym_or_keycode(key_sym, xkb_descr_, xke->keycode);
 
      if (!XLookupString(xke, &ascii, 1, nullptr, nullptr)) {
        ascii = '\0';
      }
#endif
 
#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
      /* Only used for key-press. */
      XIC xic = nullptr;
#endif
 
      if (xke->type == KeyPress) {
        utf8_buf = utf8_array;
#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
        /* Setting unicode on key-up events gives #XLookupNone status. */
        xic = window->getX11_XIC();
        if (xic) {
          Status status;
 
          /* Use UTF8 because its not locale repentant, from XORG docs. */
          if (!(len = Xutf8LookupString(
                    xic, xke, utf8_buf, sizeof(utf8_array) - 5, &key_sym, &status)))
          {
            utf8_buf[0] = '\0';
          }
 
          if (status == XBufferOverflow) {
            utf8_buf = (char *)malloc(len + 5);
            len = Xutf8LookupString(xic, xke, utf8_buf, len, &key_sym, &status);
          }
 
          if (ELEM(status, XLookupChars, XLookupBoth)) {
            /* Check for ASCII control characters.
             * Inline `iscntrl` because the users locale must not change behavior. */
            if ((utf8_buf[0] < 32 && utf8_buf[0] > 0) || (utf8_buf[0] == 127)) {
              utf8_buf[0] = '\0';
            }
          }
          else if (status == XLookupKeySym) {
            /* this key doesn't have a text representation, it is a command
             * key of some sort */
          }
          else {
            printf("Bad keycode lookup. Keysym 0x%x Status: %s\n",
                   uint(key_sym),
                   (status == XLookupNone   ? "XLookupNone" :
                    status == XLookupKeySym ? "XLookupKeySym" :
                                              "Unknown status"));
 
            printf("'%.*s' %p %p\n", len, utf8_buf, xic, xim_);
          }
        }
        else {
          utf8_buf[0] = '\0';
        }
#endif
        if (!utf8_buf[0] && ascii) {
          utf8_buf[0] = ascii;
          utf8_buf[1] = '\0';
        }
      }
 
      g_event = new GHOST_EventKey(event_ms, type, window, gkey, is_repeat, utf8_buf);
 
#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
      /* When using IM for some languages such as Japanese,
       * one event inserts multiple UTF8 characters. */
      if (xke->type == KeyPress && xic) {
        uchar c;
        int i = 0;
        while (true) {
          /* Search character boundary. */
          if (uchar(utf8_buf[i++]) > 0x7f) {
            for (; i < len; ++i) {
              c = utf8_buf[i];
              if (c < 0x80 || c > 0xbf) {
                break;
              }
            }
          }
 
          if (i >= len) {
            break;
          }
          /* Enqueue previous character. */
          pushEvent(g_event);
 
          g_event = new GHOST_EventKey(event_ms, type, window, gkey, is_repeat, &utf8_buf[i]);
        }
      }
 
      if (utf8_buf != utf8_array) {
        free(utf8_buf);
      }
#endif
 
      break;
    }
 
    case ButtonPress:
    case ButtonRelease: {
      const XButtonEvent &xbe = xe->xbutton;
      const uint64_t event_ms = ms_from_input_time(xbe.time);
      GHOST_TButton gbmask = GHOST_kButtonMaskLeft;
      GHOST_TEventType type = (xbe.type == ButtonPress) ? GHOST_kEventButtonDown :
                                                          GHOST_kEventButtonUp;
 
      /* process wheel mouse events and break, only pass on press events */
      if (xbe.button == Button4) {
        if (xbe.type == ButtonPress) {
          g_event = new GHOST_EventWheel(event_ms, window, GHOST_kEventWheelAxisVertical, 1);
        }
        break;
      }
      if (xbe.button == Button5) {
        if (xbe.type == ButtonPress) {
          g_event = new GHOST_EventWheel(event_ms, window, GHOST_kEventWheelAxisVertical, -1);
        }
        break;
      }
 
      /* process rest of normal mouse buttons */
      if (xbe.button == Button1) {
        gbmask = GHOST_kButtonMaskLeft;
      }
      else if (xbe.button == Button2) {
        gbmask = GHOST_kButtonMaskMiddle;
      }
      else if (xbe.button == Button3) {
        gbmask = GHOST_kButtonMaskRight;
        /* It seems events 6 and 7 are for horizontal scrolling.
         * you can re-order button mapping like this... (swaps 6,7 with 8,9)
         * `xmodmap -e "pointer = 1 2 3 4 5 8 9 6 7"` */
      }
      else if (xbe.button == 6) {
        gbmask = GHOST_kButtonMaskButton6;
      }
      else if (xbe.button == 7) {
        gbmask = GHOST_kButtonMaskButton7;
      }
      else if (xbe.button == 8) {
        gbmask = GHOST_kButtonMaskButton4;
      }
      else if (xbe.button == 9) {
        gbmask = GHOST_kButtonMaskButton5;
      }
      else {
        break;
      }
 
      g_event = new GHOST_EventButton(event_ms, type, window, gbmask, window->GetTabletData());
      break;
    }
 
    /* change of size, border, layer etc. */
    case ConfigureNotify: {
      // const XConfigureEvent & xce = xe->xconfigure;
      /* Event has no timestamp. */
      const uint64_t event_ms = getMilliSeconds();
 
      g_event = new GHOST_Event(event_ms, GHOST_kEventWindowSize, window);
      break;
    }
 
    case FocusIn:
    case FocusOut: {
      const XFocusChangeEvent &xfe = xe->xfocus;
 
      /* TODO: make sure this is the correct place for activate/deactivate */
#if 0
      printf("X: focus %s for window %d\n", xfe.type == FocusIn ? "in" : "out", int(xfe.window));
#endif
 
      /* May have to look at the type of event and filter some out. */
 
      GHOST_TEventType gtype = (xfe.type == FocusIn) ? GHOST_kEventWindowActivate :
                                                       GHOST_kEventWindowDeactivate;
 
#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
      XIC xic = window->getX11_XIC();
      if (xic) {
        if (xe->type == FocusIn) {
          XSetICFocus(xic);
        }
        else {
          XUnsetICFocus(xic);
        }
      }
#endif
 
      g_event = new GHOST_Event(getMilliSeconds(), gtype, window);
      break;
    }
    case ClientMessage: {
      XClientMessageEvent &xcme = xe->xclient;
 
      if (((Atom)xcme.data.l[0]) == atom_.WM_DELETE_WINDOW) {
        g_event = new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowClose, window);
      }
      else if (((Atom)xcme.data.l[0]) == atom_.WM_TAKE_FOCUS) {
        XWindowAttributes attr;
        Window fwin;
        int revert_to;
 
        /* as ICCCM say, we need reply this event
         * with a #SetInputFocus, the data[1] have
         * the valid timestamp (send by the wm).
         *
         * Some WM send this event before the
         * window is really mapped (for example
         * change from virtual desktop), so we need
         * to be sure that our windows is mapped
         * or this call fail and close blender.
         */
        if (XGetWindowAttributes(display_, xcme.window, &attr) == True) {
          if (XGetInputFocus(display_, &fwin, &revert_to) == True) {
            if (attr.map_state == IsViewable) {
              if (fwin != xcme.window) {
                XSetInputFocus(display_, xcme.window, RevertToParent, xcme.data.l[1]);
              }
            }
          }
        }
      }
      else {
#ifdef WITH_XDND
        /* try to handle drag event
         * (if there's no such events, #GHOST_HandleClientMessage will return zero) */
        if (window->getDropTarget()->GHOST_HandleClientMessage(xe) == false) {
          /* Unknown client message, ignore */
        }
#else
        /* Unknown client message, ignore */
#endif
      }
 
      break;
    }
 
    case DestroyNotify:
      ::exit(-1);
    /* We're not interested in the following things.(yet...) */
    case NoExpose:
    case GraphicsExpose:
      break;
 
    case EnterNotify:
    case LeaveNotify: {
      /* #XCrossingEvents pointer leave enter window.
       * also do cursor move here, #MotionNotify only
       * happens when motion starts & ends inside window.
       * we only do moves when the crossing mode is 'normal'
       * (really crossing between windows) since some window-managers
       * also send grab/un-grab crossings for mouse-wheel events.
       */
      const XCrossingEvent &xce = xe->xcrossing;
      const uint64_t event_ms = ms_from_input_time(xce.time);
      if (xce.mode == NotifyNormal) {
        g_event = new GHOST_EventCursor(event_ms,
                                        GHOST_kEventCursorMove,
                                        window,
                                        xce.x_root,
                                        xce.y_root,
                                        window->GetTabletData());
      }
 
#if 0
      printf(
          "X: %s window %d\n", xce.type == EnterNotify ? "entering" : "leaving", int(xce.window));
#endif
 
      if (xce.type == EnterNotify) {
        window_manager_->setActiveWindow(window);
      }
      else {
        window_manager_->setWindowInactive(window);
      }
 
      break;
    }
    case MapNotify:
      /*
       * From ICCCM:
       * [ Clients can select for #StructureNotify on their
       *   top-level windows to track transition between
       *   Normal and Iconic states. Receipt of a #MapNotify
       *   event will indicate a transition to the Normal
       *   state, and receipt of an #UnmapNotify event will
       *   indicate a transition to the Iconic state. ]
       */
      if (window->post_init_ == True) {
        /*
         * Now we are sure that the window is
         * mapped, so only need change the state.
         */
        window->setState(window->post_state_);
        window->post_init_ = False;
      }
      break;
    case UnmapNotify:
      break;
    case MappingNotify:
    case ReparentNotify:
      break;
    case SelectionRequest: {
      XEvent nxe;
      XSelectionRequestEvent *xse = &xe->xselectionrequest;
 
      /* support obsolete clients */
      if (xse->property == None) {
        xse->property = xse->target;
      }
 
      nxe.xselection.type = SelectionNotify;
      nxe.xselection.requestor = xse->requestor;
      nxe.xselection.property = xse->property;
      nxe.xselection.display = xse->display;
      nxe.xselection.selection = xse->selection;
      nxe.xselection.target = xse->target;
      nxe.xselection.time = xse->time;
 
      /* Check to see if the requester is asking for String */
      if (ELEM(xse->target, atom_.UTF8_STRING, atom_.STRING, atom_.COMPOUND_TEXT, atom_.C_STRING))
      {
        if (xse->selection == XInternAtom(display_, "PRIMARY", False)) {
          XChangeProperty(display_,
                          xse->requestor,
                          xse->property,
                          xse->target,
                          8,
                          PropModeReplace,
                          (uchar *)txt_select_buffer,
                          strlen(txt_select_buffer));
        }
        else if (xse->selection == XInternAtom(display_, "CLIPBOARD", False)) {
          XChangeProperty(display_,
                          xse->requestor,
                          xse->property,
                          xse->target,
                          8,
                          PropModeReplace,
                          (uchar *)txt_cut_buffer,
                          strlen(txt_cut_buffer));
        }
      }
      else if (xse->target == atom_.TARGETS) {
        const Atom atom_list[] = {
            atom_.TARGETS, atom_.UTF8_STRING, atom_.STRING, atom_.COMPOUND_TEXT, atom_.C_STRING};
        XChangeProperty(display_,
                        xse->requestor,
                        xse->property,
                        XA_ATOM,
                        32,
                        PropModeReplace,
                        reinterpret_cast<const uchar *>(atom_list),
                        ARRAY_SIZE(atom_list));
        XFlush(display_);
      }
      else {
        /* Change property to None because we do not support the selection request target. */
        nxe.xselection.property = None;
      }
 
      /* Send the event to the client 0 0 == False, #SelectionNotify */
      XSendEvent(display_, xse->requestor, 0, 0, &nxe);
      XFlush(display_);
      break;
    }
 
    default: {
#ifdef WITH_X11_XINPUT
      for (GHOST_TabletX11 &xtablet : xtablets_) {
        if (ELEM(xe->type, xtablet.MotionEvent, xtablet.PressEvent)) {
          const XDeviceMotionEvent *data = (const XDeviceMotionEvent *)xe;
          if (data->deviceid != xtablet.ID) {
            continue;
          }
 
          const uchar axis_first = data->first_axis;
          const uchar axes_end = axis_first + data->axes_count; /* after the last */
          int axis_value;
 
          /* stroke might begin without leading ProxyIn event,
           * this happens when window is opened when stylus is already hovering
           * around tablet surface */
          window->GetTabletData().Active = xtablet.mode;
 
          /* NOTE: This event might be generated with incomplete data-set
           * (don't exactly know why, looks like in some cases, if the value does not change,
           * it is not included in subsequent #XDeviceMotionEvent events).
           * So we have to check which values this event actually contains!
           */
 
#  define AXIS_VALUE_GET(axis, val) \
    ((axis_first <= axis && axes_end > axis) && \
     ((void)(val = data->axis_data[axis - axis_first]), true))
 
          if (AXIS_VALUE_GET(2, axis_value)) {
            window->GetTabletData().Pressure = axis_value / float(xtablet.PressureLevels);
          }
 
          /* NOTE(@broken): the `short` cast and the & 0xffff is bizarre and unexplained anywhere,
           * but I got garbage data without it. Found it in the `xidump.c` source.
           *
           * NOTE(@mont29): The '& 0xffff' just truncates the value to its two lowest bytes,
           * this probably means some drivers do not properly set the whole int value?
           * Since we convert to float afterward,
           * I don't think we need to cast to short here, but do not have a device to check this.
           */
          if (AXIS_VALUE_GET(3, axis_value)) {
            window->GetTabletData().Xtilt = short(axis_value & 0xffff) /
                                            float(xtablet.XtiltLevels);
          }
          if (AXIS_VALUE_GET(4, axis_value)) {
            window->GetTabletData().Ytilt = short(axis_value & 0xffff) /
                                            float(xtablet.YtiltLevels);
          }
 
#  undef AXIS_VALUE_GET
        }
        else if (xe->type == xtablet.ProxInEvent) {
          const XProximityNotifyEvent *data = (const XProximityNotifyEvent *)xe;
          if (data->deviceid != xtablet.ID) {
            continue;
          }
 
          window->GetTabletData().Active = xtablet.mode;
        }
        else if (xe->type == xtablet.ProxOutEvent) {
          window->GetTabletData().Active = GHOST_kTabletModeNone;
        }
      }
#endif  // WITH_X11_XINPUT
      break;
    }
  }
 
  if (g_event) {
    pushEvent(g_event);
  }
}
 
GHOST_TSuccess GHOST_SystemX11::getPixelAtCursor(float r_color[3]) const
{
  /* NOTE: There are known issues/limitations at the moment:
   *
   * - Blender has no control of the cursor outside of its window, so it is
   *   not going to be the eyedropper icon.
   * - GHOST does not report click events from outside of the window, so the
   *   user needs to press Enter instead.
   *
   * Ref #111303. */
 
  XColor c;
  int32_t x, y;
 
  if (getCursorPosition(x, y) == GHOST_kFailure) {
    return GHOST_kFailure;
  }
  XImage *image = XGetImage(
      display_, XRootWindow(display_, XDefaultScreen(display_)), x, y, 1, 1, AllPlanes, XYPixmap);
  if (image == nullptr) {
    return GHOST_kFailure;
  }
  c.pixel = XGetPixel(image, 0, 0);
  XFree(image);
  XQueryColor(display_, XDefaultColormap(display_, XDefaultScreen(display_)), &c);
 
  /* X11 returns colors in the [0, 65535] range, so we need to scale back to [0, 1]. */
  r_color[0] = c.red / 65535.0f;
  r_color[1] = c.green / 65535.0f;
  r_color[2] = c.blue / 65535.0f;
  return GHOST_kSuccess;
}
 
GHOST_TSuccess GHOST_SystemX11::getModifierKeys(GHOST_ModifierKeys &keys) const
{
 
  /* Analyze the masks returned from #XQueryPointer. */
 
  memset((void *)keyboard_vector_, 0, sizeof(keyboard_vector_));
 
  XQueryKeymap(display_, (char *)keyboard_vector_);
 
  /* Now translate key symbols into key-codes and test with vector. */
 
  const static KeyCode shift_l = XKeysymToKeycode(display_, XK_Shift_L);
  const static KeyCode shift_r = XKeysymToKeycode(display_, XK_Shift_R);
  const static KeyCode control_l = XKeysymToKeycode(display_, XK_Control_L);
  const static KeyCode control_r = XKeysymToKeycode(display_, XK_Control_R);
  const static KeyCode alt_l = XKeysymToKeycode(display_, XK_Alt_L);
  const static KeyCode alt_r = XKeysymToKeycode(display_, XK_Alt_R);
  const static KeyCode super_l = XKeysymToKeycode(display_, XK_Super_L);
  const static KeyCode super_r = XKeysymToKeycode(display_, XK_Super_R);
  const static KeyCode hyper_l = XKeysymToKeycode(display_, XK_Hyper_L);
  const static KeyCode hyper_r = XKeysymToKeycode(display_, XK_Hyper_R);
 
  /* shift */
  keys.set(GHOST_kModifierKeyLeftShift,
           ((keyboard_vector_[shift_l >> 3] >> (shift_l & 7)) & 1) != 0);
  keys.set(GHOST_kModifierKeyRightShift,
           ((keyboard_vector_[shift_r >> 3] >> (shift_r & 7)) & 1) != 0);
  /* control */
  keys.set(GHOST_kModifierKeyLeftControl,
           ((keyboard_vector_[control_l >> 3] >> (control_l & 7)) & 1) != 0);
  keys.set(GHOST_kModifierKeyRightControl,
           ((keyboard_vector_[control_r >> 3] >> (control_r & 7)) & 1) != 0);
  /* alt */
  keys.set(GHOST_kModifierKeyLeftAlt, ((keyboard_vector_[alt_l >> 3] >> (alt_l & 7)) & 1) != 0);
  keys.set(GHOST_kModifierKeyRightAlt, ((keyboard_vector_[alt_r >> 3] >> (alt_r & 7)) & 1) != 0);
  /* super (windows) - only one GHOST-kModifierKeyOS, so mapping to either */
  keys.set(GHOST_kModifierKeyLeftOS, ((keyboard_vector_[super_l >> 3] >> (super_l & 7)) & 1) != 0);
  keys.set(GHOST_kModifierKeyRightOS,
           ((keyboard_vector_[super_r >> 3] >> (super_r & 7)) & 1) != 0);
  /* hyper */
  keys.set(GHOST_kModifierKeyLeftHyper,
           ((keyboard_vector_[hyper_l >> 3] >> (hyper_l & 7)) & 1) != 0);
  keys.set(GHOST_kModifierKeyRightHyper,
           ((keyboard_vector_[hyper_r >> 3] >> (hyper_r & 7)) & 1) != 0);
 
  return GHOST_kSuccess;
}
 
GHOST_TSuccess GHOST_SystemX11::getButtons(GHOST_Buttons &buttons) const
{
  Window root_return, child_return;
  int rx, ry, wx, wy;
  uint mask_return;
 
  if (XQueryPointer(display_,
                    RootWindow(display_, DefaultScreen(display_)),
                    &root_return,
                    &child_return,
                    &rx,
                    &ry,
                    &wx,
                    &wy,
                    &mask_return) == True)
  {
    buttons.set(GHOST_kButtonMaskLeft, (mask_return & Button1Mask) != 0);
    buttons.set(GHOST_kButtonMaskMiddle, (mask_return & Button2Mask) != 0);
    buttons.set(GHOST_kButtonMaskRight, (mask_return & Button3Mask) != 0);
    buttons.set(GHOST_kButtonMaskButton4, (mask_return & Button4Mask) != 0);
    buttons.set(GHOST_kButtonMaskButton5, (mask_return & Button5Mask) != 0);
  }
  else {
    return GHOST_kFailure;
  }
 
  return GHOST_kSuccess;
}
 
static GHOST_TSuccess getCursorPosition_impl(Display *display,
                                             int32_t &x,
                                             int32_t &y,
                                             Window *child_return)
{
  int rx, ry, wx, wy;
  uint mask_return;
  Window root_return;
 
  if (XQueryPointer(display,
                    RootWindow(display, DefaultScreen(display)),
                    &root_return,
                    child_return,
                    &rx,
                    &ry,
                    &wx,
                    &wy,
                    &mask_return) == False)
  {
    return GHOST_kFailure;
  }
 
  x = rx;
  y = ry;
 
  return GHOST_kSuccess;
}
 
GHOST_TSuccess GHOST_SystemX11::getCursorPosition(int32_t &x, int32_t &y) const
{
  Window child_return;
  return getCursorPosition_impl(display_, x, y, &child_return);
}
 
GHOST_TSuccess GHOST_SystemX11::setCursorPosition(int32_t x, int32_t y)
{
 
  /* This is a brute force move in screen coordinates
   * #XWarpPointer does relative moves so first determine the
   * current pointer position. */
 
  int cx, cy;
 
#ifdef WITH_XWAYLAND_HACK
  Window child_return = None;
  if (getCursorPosition_impl(display_, cx, cy, &child_return) == GHOST_kFailure) {
    return GHOST_kFailure;
  }
#else
  if (getCursorPosition(cx, cy) == GHOST_kFailure) {
    return GHOST_kFailure;
  }
#endif
 
  int relx = x - cx;
  int rely = y - cy;
 
#ifdef WITH_XWAYLAND_HACK
  if (use_xwayland_hack) {
    if (child_return != None) {
      XFixesHideCursor(display_, child_return);
    }
  }
#endif
 
#if defined(WITH_X11_XINPUT) && defined(USE_X11_XINPUT_WARP)
  if ((xinput_version_.present) && (xinput_version_.major_version >= 2)) {
    /* Needed to account for XInput "Coordinate Transformation Matrix", see #48901 */
    int device_id;
    if (XIGetClientPointer(display_, None, &device_id) != False) {
      XIWarpPointer(display_, device_id, None, None, 0, 0, 0, 0, relx, rely);
    }
  }
  else
#endif
  {
    XWarpPointer(display_, None, None, 0, 0, 0, 0, relx, rely);
  }
 
#ifdef WITH_XWAYLAND_HACK
  if (use_xwayland_hack) {
    if (child_return != None) {
      XFixesShowCursor(display_, child_return);
    }
  }
#endif
 
  XSync(display_, 0); /* Sync to process all requests */
 
  return GHOST_kSuccess;
}
 
GHOST_TCapabilityFlag GHOST_SystemX11::getCapabilities() const
{
  return GHOST_TCapabilityFlag(
      GHOST_CAPABILITY_FLAG_ALL &
      /* NOTE: order the following flags as they they're declared in the source. */
      ~(
          /* No support yet for image copy/paste. */
          GHOST_kCapabilityClipboardImage |
          /* No support yet for IME input methods. */
          GHOST_kCapabilityInputIME |
          /* No support for window decoration styles. */
          GHOST_kCapabilityWindowDecorationStyles |
          /* No support yet for RGBA mouse cursors. */
          GHOST_kCapabilityCursorRGBA |
          /* No support yet for dynamic cursor generation. */
          GHOST_kCapabilityCursorGenerator));
}
 
void GHOST_SystemX11::addDirtyWindow(GHOST_WindowX11 *bad_wind)
{
  GHOST_ASSERT((bad_wind != nullptr), "addDirtyWindow() nullptr ptr trapped (window)");
 
  dirty_windows_.push_back(bad_wind);
}
 
bool GHOST_SystemX11::generateWindowExposeEvents()
{
  vector<GHOST_WindowX11 *>::const_iterator w_start = dirty_windows_.begin();
  vector<GHOST_WindowX11 *>::const_iterator w_end = dirty_windows_.end();
  bool anyProcessed = false;
 
  for (; w_start != w_end; ++w_start) {
    const GHOST_Event *g_event = new GHOST_Event(
        getMilliSeconds(), GHOST_kEventWindowUpdate, *w_start);
 
    (*w_start)->validate();
 
    if (g_event) {
      pushEvent(g_event);
      anyProcessed = true;
    }
  }
 
  dirty_windows_.clear();
  return anyProcessed;
}
 
static GHOST_TKey ghost_key_from_keysym_or_keycode(const KeySym key_sym,
                                                   XkbDescPtr xkb_descr,
                                                   const KeyCode keycode)
{
  GHOST_TKey type = ghost_key_from_keysym(key_sym);
  if (type == GHOST_kKeyUnknown) {
    if (xkb_descr) {
      type = ghost_key_from_keycode(xkb_descr, keycode);
    }
  }
  return type;
}
 
#define GXMAP(k, x, y) \
  case x: \
    k = y; \
    break
 
static GHOST_TKey ghost_key_from_keysym(const KeySym key)
{
  GHOST_TKey type;
 
  if ((key >= XK_A) && (key <= XK_Z)) {
    type = GHOST_TKey(key - XK_A + int(GHOST_kKeyA));
  }
  else if ((key >= XK_a) && (key <= XK_z)) {
    type = GHOST_TKey(key - XK_a + int(GHOST_kKeyA));
  }
  else if ((key >= XK_0) && (key <= XK_9)) {
    type = GHOST_TKey(key - XK_0 + int(GHOST_kKey0));
  }
  else if ((key >= XK_F1) && (key <= XK_F24)) {
    type = GHOST_TKey(key - XK_F1 + int(GHOST_kKeyF1));
  }
  else {
    switch (key) {
      GXMAP(type, XK_BackSpace, GHOST_kKeyBackSpace);
      GXMAP(type, XK_Tab, GHOST_kKeyTab);
      GXMAP(type, XK_ISO_Left_Tab, GHOST_kKeyTab);
      GXMAP(type, XK_Return, GHOST_kKeyEnter);
      GXMAP(type, XK_Escape, GHOST_kKeyEsc);
      GXMAP(type, XK_space, GHOST_kKeySpace);
 
      GXMAP(type, XK_Linefeed, GHOST_kKeyLinefeed);
      GXMAP(type, XK_semicolon, GHOST_kKeySemicolon);
      GXMAP(type, XK_period, GHOST_kKeyPeriod);
      GXMAP(type, XK_comma, GHOST_kKeyComma);
      GXMAP(type, XK_quoteright, GHOST_kKeyQuote);
      GXMAP(type, XK_quoteleft, GHOST_kKeyAccentGrave);
      GXMAP(type, XK_minus, GHOST_kKeyMinus);
      GXMAP(type, XK_plus, GHOST_kKeyPlus);
      GXMAP(type, XK_slash, GHOST_kKeySlash);
      GXMAP(type, XK_backslash, GHOST_kKeyBackslash);
      GXMAP(type, XK_equal, GHOST_kKeyEqual);
      GXMAP(type, XK_bracketleft, GHOST_kKeyLeftBracket);
      GXMAP(type, XK_bracketright, GHOST_kKeyRightBracket);
      GXMAP(type, XK_Pause, GHOST_kKeyPause);
 
      GXMAP(type, XK_Shift_L, GHOST_kKeyLeftShift);
      GXMAP(type, XK_Shift_R, GHOST_kKeyRightShift);
      GXMAP(type, XK_Control_L, GHOST_kKeyLeftControl);
      GXMAP(type, XK_Control_R, GHOST_kKeyRightControl);
      GXMAP(type, XK_Alt_L, GHOST_kKeyLeftAlt);
      GXMAP(type, XK_Alt_R, GHOST_kKeyRightAlt);
      GXMAP(type, XK_Super_L, GHOST_kKeyLeftOS);
      GXMAP(type, XK_Super_R, GHOST_kKeyRightOS);
      GXMAP(type, XK_Hyper_L, GHOST_kKeyLeftHyper);
      GXMAP(type, XK_Hyper_R, GHOST_kKeyRightHyper);
 
      GXMAP(type, XK_Insert, GHOST_kKeyInsert);
      GXMAP(type, XK_Delete, GHOST_kKeyDelete);
      GXMAP(type, XK_Home, GHOST_kKeyHome);
      GXMAP(type, XK_End, GHOST_kKeyEnd);
      GXMAP(type, XK_Page_Up, GHOST_kKeyUpPage);
      GXMAP(type, XK_Page_Down, GHOST_kKeyDownPage);
 
      GXMAP(type, XK_Left, GHOST_kKeyLeftArrow);
      GXMAP(type, XK_Right, GHOST_kKeyRightArrow);
      GXMAP(type, XK_Up, GHOST_kKeyUpArrow);
      GXMAP(type, XK_Down, GHOST_kKeyDownArrow);
 
      GXMAP(type, XK_Caps_Lock, GHOST_kKeyCapsLock);
      GXMAP(type, XK_Scroll_Lock, GHOST_kKeyScrollLock);
      GXMAP(type, XK_Num_Lock, GHOST_kKeyNumLock);
      GXMAP(type, XK_Menu, GHOST_kKeyApp);
 
      /* keypad events */
 
      GXMAP(type, XK_KP_0, GHOST_kKeyNumpad0);
      GXMAP(type, XK_KP_1, GHOST_kKeyNumpad1);
      GXMAP(type, XK_KP_2, GHOST_kKeyNumpad2);
      GXMAP(type, XK_KP_3, GHOST_kKeyNumpad3);
      GXMAP(type, XK_KP_4, GHOST_kKeyNumpad4);
      GXMAP(type, XK_KP_5, GHOST_kKeyNumpad5);
      GXMAP(type, XK_KP_6, GHOST_kKeyNumpad6);
      GXMAP(type, XK_KP_7, GHOST_kKeyNumpad7);
      GXMAP(type, XK_KP_8, GHOST_kKeyNumpad8);
      GXMAP(type, XK_KP_9, GHOST_kKeyNumpad9);
      GXMAP(type, XK_KP_Decimal, GHOST_kKeyNumpadPeriod);
 
      GXMAP(type, XK_KP_Insert, GHOST_kKeyNumpad0);
      GXMAP(type, XK_KP_End, GHOST_kKeyNumpad1);
      GXMAP(type, XK_KP_Down, GHOST_kKeyNumpad2);
      GXMAP(type, XK_KP_Page_Down, GHOST_kKeyNumpad3);
      GXMAP(type, XK_KP_Left, GHOST_kKeyNumpad4);
      GXMAP(type, XK_KP_Begin, GHOST_kKeyNumpad5);
      GXMAP(type, XK_KP_Right, GHOST_kKeyNumpad6);
      GXMAP(type, XK_KP_Home, GHOST_kKeyNumpad7);
      GXMAP(type, XK_KP_Up, GHOST_kKeyNumpad8);
      GXMAP(type, XK_KP_Page_Up, GHOST_kKeyNumpad9);
      GXMAP(type, XK_KP_Delete, GHOST_kKeyNumpadPeriod);
 
      GXMAP(type, XK_KP_Enter, GHOST_kKeyNumpadEnter);
      GXMAP(type, XK_KP_Add, GHOST_kKeyNumpadPlus);
      GXMAP(type, XK_KP_Subtract, GHOST_kKeyNumpadMinus);
      GXMAP(type, XK_KP_Multiply, GHOST_kKeyNumpadAsterisk);
      GXMAP(type, XK_KP_Divide, GHOST_kKeyNumpadSlash);
 
      /* Media keys in some keyboards and laptops with XFree86/XORG. */
#ifdef WITH_XF86KEYSYM
      GXMAP(type, XF86XK_AudioPlay, GHOST_kKeyMediaPlay);
      GXMAP(type, XF86XK_AudioStop, GHOST_kKeyMediaStop);
      GXMAP(type, XF86XK_AudioPrev, GHOST_kKeyMediaFirst);
      GXMAP(type, XF86XK_AudioRewind, GHOST_kKeyMediaFirst);
      GXMAP(type, XF86XK_AudioNext, GHOST_kKeyMediaLast);
#  ifdef XF86XK_AudioForward /* Debian lenny's XF86keysym.h has no XF86XK_AudioForward define */
      GXMAP(type, XF86XK_AudioForward, GHOST_kKeyMediaLast);
#  endif
#endif
      default:
#ifdef WITH_GHOST_DEBUG
        printf("%s: unknown key: %lu / 0x%lx\n", __func__, key, key);
#endif
        type = GHOST_kKeyUnknown;
        break;
    }
  }
 
  return type;
}
 
#undef GXMAP
 
#define MAKE_ID(a, b, c, d) (int(d) << 24 | int(c) << 16 | (b) << 8 | (a))
 
static GHOST_TKey ghost_key_from_keycode(const XkbDescPtr xkb_descr, const KeyCode keycode)
{
  GHOST_ASSERT(XkbKeyNameLength == 4, "Name length is invalid!");
  if (keycode >= xkb_descr->min_key_code && keycode <= xkb_descr->max_key_code) {
    const char *id_str = xkb_descr->names->keys[keycode].name;
    const uint32_t id = MAKE_ID(id_str[0], id_str[1], id_str[2], id_str[3]);
    switch (id) {
      case MAKE_ID('T', 'L', 'D', 'E'):
        return GHOST_kKeyAccentGrave;
      case MAKE_ID('L', 'S', 'G', 'T'):
        return GHOST_kKeyGrLess;
#ifdef WITH_GHOST_DEBUG
      default:
        printf("%s unhandled keycode: %.*s\n", __func__, XkbKeyNameLength, id_str);
        break;
#endif
    }
  }
  else if (keycode != 0) {
    GHOST_ASSERT(false, "KeyCode out of range!");
  }
  return GHOST_kKeyUnknown;
}
 
#undef MAKE_ID
 
/* From `xclip.c` #xcout() v0.11. */
 
#define XCLIB_XCOUT_NONE 0          /* no context */
#define XCLIB_XCOUT_SENTCONVSEL 1   /* sent a request */
#define XCLIB_XCOUT_INCR 2          /* in an incr loop */
#define XCLIB_XCOUT_FALLBACK 3      /* STRING failed, need fallback to UTF8 */
#define XCLIB_XCOUT_FALLBACK_UTF8 4 /* UTF8 failed, move to compound. */
#define XCLIB_XCOUT_FALLBACK_COMP 5 /* compound failed, move to text. */
#define XCLIB_XCOUT_FALLBACK_TEXT 6
 
/* Retrieves the contents of a selections. */
void GHOST_SystemX11::getClipboard_xcout(
    const XEvent *evt, Atom sel, Atom target, uchar **txt, ulong *len, uint *context) const
{
  Atom pty_type;
  int pty_format;
  uchar *buffer;
  ulong pty_size, pty_items;
  uchar *ltxt = *txt;
 
  const vector<GHOST_IWindow *> &win_vec = window_manager_->getWindows();
  vector<GHOST_IWindow *>::const_iterator win_it = win_vec.begin();
  GHOST_WindowX11 *window = static_cast<GHOST_WindowX11 *>(*win_it);
  Window win = window->getXWindow();
 
  switch (*context) {
    /* There is no context, do an XConvertSelection() */
    case XCLIB_XCOUT_NONE:
      /* Initialize return length to 0. */
      if (*len > 0) {
        free(*txt);
        *len = 0;
      }
 
      /* Send a selection request */
      XConvertSelection(display_, sel, target, atom_.XCLIP_OUT, win, CurrentTime);
      *context = XCLIB_XCOUT_SENTCONVSEL;
      return;
 
    case XCLIB_XCOUT_SENTCONVSEL:
      if (evt->type != SelectionNotify) {
        return;
      }
 
      if (target == atom_.UTF8_STRING && evt->xselection.property == None) {
        *context = XCLIB_XCOUT_FALLBACK_UTF8;
        return;
      }
      if (target == atom_.COMPOUND_TEXT && evt->xselection.property == None) {
        *context = XCLIB_XCOUT_FALLBACK_COMP;
        return;
      }
      if (target == atom_.TEXT && evt->xselection.property == None) {
        *context = XCLIB_XCOUT_FALLBACK_TEXT;
        return;
      }
 
      /* find the size and format of the data in property */
      XGetWindowProperty(display_,
                         win,
                         atom_.XCLIP_OUT,
                         0,
                         0,
                         False,
                         AnyPropertyType,
                         &pty_type,
                         &pty_format,
                         &pty_items,
                         &pty_size,
                         &buffer);
      XFree(buffer);
 
      if (pty_type == atom_.INCR) {
        /* start INCR mechanism by deleting property */
        XDeleteProperty(display_, win, atom_.XCLIP_OUT);
        XFlush(display_);
        *context = XCLIB_XCOUT_INCR;
        return;
      }
 
      /* If it's not INCR, and not `format == 8`, then there's
       * nothing in the selection (that `xclip` understands, anyway). */
 
      if (pty_format != 8) {
        *context = XCLIB_XCOUT_NONE;
        return;
      }
 
      /* Not using INCR mechanism, just read the property. */
      XGetWindowProperty(display_,
                         win,
                         atom_.XCLIP_OUT,
                         0,
                         long(pty_size),
                         False,
                         AnyPropertyType,
                         &pty_type,
                         &pty_format,
                         &pty_items,
                         &pty_size,
                         &buffer);
 
      /* finished with property, delete it */
      XDeleteProperty(display_, win, atom_.XCLIP_OUT);
 
      /* copy the buffer to the pointer for returned data */
      ltxt = (uchar *)malloc(pty_items);
      memcpy(ltxt, buffer, pty_items);
 
      /* set the length of the returned data */
      *len = pty_items;
      *txt = ltxt;
 
      /* free the buffer */
      XFree(buffer);
 
      *context = XCLIB_XCOUT_NONE;
 
      /* complete contents of selection fetched, return 1 */
      return;
 
    case XCLIB_XCOUT_INCR:
      /* To use the INCR method, we basically delete the
       * property with the selection in it, wait for an
       * event indicating that the property has been created,
       * then read it, delete it, etc. */
 
      /* make sure that the event is relevant */
      if (evt->type != PropertyNotify) {
        return;
      }
 
      /* skip unless the property has a new value */
      if (evt->xproperty.state != PropertyNewValue) {
        return;
      }
 
      /* check size and format of the property */
      XGetWindowProperty(display_,
                         win,
                         atom_.XCLIP_OUT,
                         0,
                         0,
                         False,
                         AnyPropertyType,
                         &pty_type,
                         &pty_format,
                         &pty_items,
                         &pty_size,
                         &buffer);
 
      if (pty_format != 8) {
        /* property does not contain text, delete it
         * to tell the other X client that we have read
         * it and to send the next property */
        XFree(buffer);
        XDeleteProperty(display_, win, atom_.XCLIP_OUT);
        return;
      }
 
      if (pty_size == 0) {
        /* no more data, exit from loop */
        XFree(buffer);
        XDeleteProperty(display_, win, atom_.XCLIP_OUT);
        *context = XCLIB_XCOUT_NONE;
 
        /* this means that an INCR transfer is now
         * complete, return 1 */
        return;
      }
 
      XFree(buffer);
 
      /* if we have come this far, the property contains
       * text, we know the size. */
      XGetWindowProperty(display_,
                         win,
                         atom_.XCLIP_OUT,
                         0,
                         long(pty_size),
                         False,
                         AnyPropertyType,
                         &pty_type,
                         &pty_format,
                         &pty_items,
                         &pty_size,
                         &buffer);
 
      /* allocate memory to accommodate data in *txt */
      if (*len == 0) {
        *len = pty_items;
        ltxt = (uchar *)malloc(*len);
      }
      else {
        *len += pty_items;
        ltxt = (uchar *)realloc(ltxt, *len);
      }
 
      /* add data to ltxt */
      memcpy(&ltxt[*len - pty_items], buffer, pty_items);
 
      *txt = ltxt;
      XFree(buffer);
 
      /* delete property to get the next item */
      XDeleteProperty(display_, win, atom_.XCLIP_OUT);
      XFlush(display_);
      return;
  }
}
 
char *GHOST_SystemX11::getClipboard(bool selection) const
{
  Atom sseln;
  Atom target = atom_.UTF8_STRING;
  Window owner;
 
  /* From `xclip.c` `doOut()` v0.11. */
  char *sel_buf;
  ulong sel_len = 0;
  XEvent evt;
  uint context = XCLIB_XCOUT_NONE;
 
  if (selection == True) {
    sseln = atom_.PRIMARY;
  }
  else {
    sseln = atom_.CLIPBOARD;
  }
 
  const vector<GHOST_IWindow *> &win_vec = window_manager_->getWindows();
  vector<GHOST_IWindow *>::const_iterator win_it = win_vec.begin();
  GHOST_WindowX11 *window = static_cast<GHOST_WindowX11 *>(*win_it);
  Window win = window->getXWindow();
 
  /* check if we are the owner. */
  owner = XGetSelectionOwner(display_, sseln);
  if (owner == win) {
    if (sseln == atom_.CLIPBOARD) {
      size_t sel_buf_size = strlen(txt_cut_buffer) + 1;
      sel_buf = (char *)malloc(sel_buf_size);
      memcpy(sel_buf, txt_cut_buffer, sel_buf_size);
      return sel_buf;
    }
    size_t sel_buf_size = strlen(txt_select_buffer) + 1;
    sel_buf = (char *)malloc(sel_buf_size);
    memcpy(sel_buf, txt_select_buffer, sel_buf_size);
    return sel_buf;
  }
  if (owner == None) {
    return nullptr;
  }
 
  /* Restore events so copy doesn't swallow other event types (keyboard/mouse). */
  vector<XEvent> restore_events;
 
  while (true) {
    /* only get an event if xcout() is doing something */
    bool restore_this_event = false;
    if (context != XCLIB_XCOUT_NONE) {
      XNextEvent(display_, &evt);
      restore_this_event = (evt.type != SelectionNotify);
    }
 
    /* fetch the selection, or part of it */
    getClipboard_xcout(&evt, sseln, target, (uchar **)&sel_buf, &sel_len, &context);
 
    if (restore_this_event) {
      restore_events.push_back(evt);
    }
 
    /* Fallback is needed. Set #XA_STRING to target and restart the loop. */
    if (context == XCLIB_XCOUT_FALLBACK) {
      context = XCLIB_XCOUT_NONE;
      target = atom_.STRING;
      continue;
    }
    if (context == XCLIB_XCOUT_FALLBACK_UTF8) {
      /* utf8 fail, move to compound text. */
      context = XCLIB_XCOUT_NONE;
      target = atom_.COMPOUND_TEXT;
      continue;
    }
    if (context == XCLIB_XCOUT_FALLBACK_COMP) {
      /* Compound text fail, move to text. */
      context = XCLIB_XCOUT_NONE;
      target = atom_.TEXT;
      continue;
    }
    if (context == XCLIB_XCOUT_FALLBACK_TEXT) {
      /* Text fail, nothing else to try, break. */
      context = XCLIB_XCOUT_NONE;
    }
 
    /* Only continue if #xcout() is doing something. */
    if (context == XCLIB_XCOUT_NONE) {
      break;
    }
  }
 
  while (!restore_events.empty()) {
    XPutBackEvent(display_, &restore_events.back());
    restore_events.pop_back();
  }
 
  if (sel_len) {
    /* Only print the buffer out, and free it, if it's not empty. */
    char *tmp_data = (char *)malloc(sel_len + 1);
    memcpy(tmp_data, (char *)sel_buf, sel_len);
    tmp_data[sel_len] = '\0';
 
    if (sseln == atom_.STRING) {
      XFree(sel_buf);
    }
    else {
      free(sel_buf);
    }
 
    return tmp_data;
  }
  return nullptr;
}
 
void GHOST_SystemX11::putClipboard(const char *buffer, bool selection) const
{
  Window window_, owner;
 
  const vector<GHOST_IWindow *> &win_vec = window_manager_->getWindows();
  vector<GHOST_IWindow *>::const_iterator win_it = win_vec.begin();
  GHOST_WindowX11 *window = static_cast<GHOST_WindowX11 *>(*win_it);
  window_ = window->getXWindow();
 
  if (buffer) {
    if (selection == False) {
      XSetSelectionOwner(display_, atom_.CLIPBOARD, window_, CurrentTime);
      owner = XGetSelectionOwner(display_, atom_.CLIPBOARD);
      if (txt_cut_buffer) {
        free((void *)txt_cut_buffer);
      }
 
      size_t buffer_size = strlen(buffer) + 1;
      txt_cut_buffer = (char *)malloc(buffer_size);
      memcpy(txt_cut_buffer, buffer, buffer_size);
    }
    else {
      XSetSelectionOwner(display_, atom_.PRIMARY, window_, CurrentTime);
      owner = XGetSelectionOwner(display_, atom_.PRIMARY);
      if (txt_select_buffer) {
        free((void *)txt_select_buffer);
      }
 
      size_t buffer_size = strlen(buffer) + 1;
      txt_select_buffer = (char *)malloc(buffer_size);
      memcpy(txt_select_buffer, buffer, buffer_size);
    }
 
    if (owner != window_) {
      fprintf(stderr, "failed to own primary\n");
    }
  }
}
 
/* -------------------------------------------------------------------- */
 
class DialogData {
 public:
  /* Width of the dialog. */
  uint width;
  /* Height of the dialog. */
  uint height;
  /* Default padding (x direction) between controls and edge of dialog. */
  uint padding_x;
  /* Default padding (y direction) between controls and edge of dialog. */
  uint padding_y;
  /* Width of a single button. */
  uint button_width;
  /* Height of a single button. */
  uint button_height;
  /* Inset of a button to its text. */
  uint button_inset_x;
  /* Size of the border of the button. */
  uint button_border_size;
  /* Height of a line of text */
  uint line_height;
  /* Offset of the text inside the button. */
  uint button_text_offset_y;
 
  /* Construct a new #DialogData with the default settings. */
  DialogData()
      : width(640),
        height(175),
        padding_x(10),
        padding_y(5),
        button_width(130),
        button_height(24),
        button_inset_x(10),
        button_border_size(1),
        line_height(16)
  {
    button_text_offset_y = button_height - line_height;
  }
 
  void drawButton(Display *display,
                  Window &window,
                  GC &borderGC,
                  GC &buttonGC,
                  uint button_num,
                  const char *label)
  {
    XFillRectangle(display,
                   window,
                   borderGC,
                   width - (padding_x + button_width) * button_num,
                   height - padding_y - button_height,
                   button_width,
                   button_height);
 
    XFillRectangle(display,
                   window,
                   buttonGC,
                   width - (padding_x + button_width) * button_num + button_border_size,
                   height - padding_y - button_height + button_border_size,
                   button_width - button_border_size * 2,
                   button_height - button_border_size * 2);
 
    XDrawString(display,
                window,
                borderGC,
                width - (padding_x + button_width) * button_num + button_inset_x,
                height - padding_y - button_text_offset_y,
                label,
                strlen(label));
  }
 
  /* Is the mouse inside the given button */
  bool isInsideButton(const XEvent &e, uint button_num) const
  {
    return (
        (e.xmotion.y > int(height - padding_y - button_height)) &&
        (e.xmotion.y < int(height - padding_y)) &&
        (e.xmotion.x > int(width - (padding_x + button_width) * button_num)) &&
        (e.xmotion.x < int(width - padding_x - (padding_x + button_width) * (button_num - 1))));
  }
};
 
static void split(const char *text, const char *seps, char ***str, int *count)
{
  const char *tok;
  char *data;
  int i;
  *count = 0;
 
  data = strdup(text);
  for (tok = strtok(data, seps); tok != nullptr; tok = strtok(nullptr, seps)) {
    (*count)++;
  }
  free(data);
 
  data = strdup(text);
  *str = (char **)malloc(size_t(*count) * sizeof(char *));
  for (i = 0, tok = strtok(data, seps); tok != nullptr; tok = strtok(nullptr, seps), i++) {
    (*str)[i] = strdup(tok);
  }
  free(data);
}
 
GHOST_TSuccess GHOST_SystemX11::showMessageBox(const char *title,
                                               const char *message,
                                               const char *help_label,
                                               const char *continue_label,
                                               const char *link,
                                               GHOST_DialogOptions /*dialog_options*/) const
{
  char **text_splitted = nullptr;
  int textLines = 0;
  split(message, "\n", &text_splitted, &textLines);
 
  DialogData dialog_data;
  XSizeHints hints;
 
  Window window;
  XEvent e;
  int screen = DefaultScreen(display_);
  window = XCreateSimpleWindow(display_,
                               RootWindow(display_, screen),
                               0,
                               0,
                               dialog_data.width,
                               dialog_data.height,
                               1,
                               BlackPixel(display_, screen),
                               WhitePixel(display_, screen));
 
  /* Window Should not be resizable */
  {
    hints.flags = PSize | PMinSize | PMaxSize;
    hints.min_width = hints.max_width = hints.base_width = dialog_data.width;
    hints.min_height = hints.max_height = hints.base_height = dialog_data.height;
    XSetWMNormalHints(display_, window, &hints);
  }
 
  /* Set title */
  {
    Atom wm_Name = XInternAtom(display_, "_NET_WM_NAME", False);
    Atom utf8Str = XInternAtom(display_, "UTF8_STRING", False);
 
    Atom winType = XInternAtom(display_, "_NET_WM_WINDOW_TYPE", False);
    Atom typeDialog = XInternAtom(display_, "_NET_WM_WINDOW_TYPE_DIALOG", False);
 
    XChangeProperty(display_,
                    window,
                    wm_Name,
                    utf8Str,
                    8,
                    PropModeReplace,
                    (const uchar *)title,
                    int(strlen(title)));
 
    XChangeProperty(
        display_, window, winType, XA_ATOM, 32, PropModeReplace, (uchar *)&typeDialog, 1);
  }
 
  /* Create buttons GC */
  XGCValues buttonBorderGCValues;
  buttonBorderGCValues.foreground = BlackPixel(display_, screen);
  buttonBorderGCValues.background = WhitePixel(display_, screen);
  XGCValues buttonGCValues;
  buttonGCValues.foreground = WhitePixel(display_, screen);
  buttonGCValues.background = BlackPixel(display_, screen);
 
  GC buttonBorderGC = XCreateGC(display_, window, GCForeground, &buttonBorderGCValues);
  GC buttonGC = XCreateGC(display_, window, GCForeground, &buttonGCValues);
 
  XSelectInput(display_, window, ExposureMask | ButtonPressMask | ButtonReleaseMask);
  XMapWindow(display_, window);
 
  const bool has_link = link && strlen(link);
 
  while (true) {
    XNextEvent(display_, &e);
    if (e.type == Expose) {
      for (int i = 0; i < textLines; i++) {
        XDrawString(display_,
                    window,
                    DefaultGC(display_, screen),
                    dialog_data.padding_x,
                    dialog_data.padding_x + (i + 1) * dialog_data.line_height,
                    text_splitted[i],
                    int(strlen(text_splitted[i])));
      }
      dialog_data.drawButton(display_, window, buttonBorderGC, buttonGC, 1, continue_label);
      if (has_link) {
        dialog_data.drawButton(display_, window, buttonBorderGC, buttonGC, 2, help_label);
      }
    }
    else if (e.type == ButtonRelease) {
      if (dialog_data.isInsideButton(e, 1)) {
        break;
      }
      if (dialog_data.isInsideButton(e, 2)) {
        if (has_link) {
          string cmd = "xdg-open \"" + string(link) + "\"";
          if (system(cmd.c_str()) != 0) {
            GHOST_PRINTF("GHOST_SystemX11::showMessageBox: Unable to run system command [%s]",
                         cmd.c_str());
          }
        }
        break;
      }
    }
  }
 
  for (int i = 0; i < textLines; i++) {
    free(text_splitted[i]);
  }
  free(text_splitted);
 
  XDestroyWindow(display_, window);
  XFreeGC(display_, buttonBorderGC);
  XFreeGC(display_, buttonGC);
  return GHOST_kSuccess;
}

 
#ifdef WITH_XDND
GHOST_TSuccess GHOST_SystemX11::pushDragDropEvent(GHOST_TEventType eventType,
                                                  GHOST_TDragnDropTypes draggedObjectType,
                                                  GHOST_IWindow *window,
                                                  int mouseX,
                                                  int mouseY,
                                                  void *data)
{
  GHOST_SystemX11 *system = ((GHOST_SystemX11 *)getSystem());
 
  /* Caller has no timestamp. */
  const uint64_t event_ms = system->getMilliSeconds();
 
  return system->pushEvent(new GHOST_EventDragnDrop(
      event_ms, eventType, draggedObjectType, window, mouseX, mouseY, data));
}
#endif
int GHOST_X11_ApplicationErrorHandler(Display *display, XErrorEvent *event)
{
  GHOST_ISystem *system = GHOST_ISystem::getSystem();
  if (!system->isDebugEnabled()) {
    return 0;
  }
 
  char error_code_str[512];
 
  XGetErrorText(display, event->error_code, error_code_str, sizeof(error_code_str));
 
  fprintf(stderr,
          "Received X11 Error:\n"
          "\terror code:   %d\n"
          "\trequest code: %d\n"
          "\tminor code:   %d\n"
          "\terror text:   %s\n",
          event->error_code,
          event->request_code,
          event->minor_code,
          error_code_str);
 
  /* No exit! - but keep lint happy */
  return 0;
}
 
int GHOST_X11_ApplicationIOErrorHandler(Display * /*display*/)
{
  GHOST_ISystem *system = GHOST_ISystem::getSystem();
  if (!system->isDebugEnabled()) {
    return 0;
  }
 
  fprintf(stderr, "Ignoring Xlib error: error IO\n");
 
  /* No exit! - but keep lint happy */
  return 0;
}
 
#ifdef WITH_X11_XINPUT
 
static bool is_filler_char(char c)
{
  return isspace(c) || ELEM(c, '_', '-', ';', ':');
}
 
/* These C functions are copied from Wine 3.12's `wintab.c` */
static bool match_token(const char *haystack, const char *needle)
{
  const char *h, *n;
  for (h = haystack; *h;) {
    while (*h && is_filler_char(*h)) {
      h++;
    }
    if (!*h) {
      break;
    }
 
    for (n = needle; *n && *h && tolower(*h) == tolower(*n); n++) {
      h++;
    }
    if (!*n && (is_filler_char(*h) || !*h)) {
      return true;
    }
 
    while (*h && !is_filler_char(*h)) {
      h++;
    }
  }
  return false;
}
 
/* Determining if an X device is a Tablet style device is an imperfect science.
 * We rely on common conventions around device names as well as the type reported
 * by WACOM tablets.  This code will likely need to be expanded for alternate tablet types
 *
 * WINTAB refers to any device that interacts with the tablet as a cursor,
 * (stylus, eraser, tablet mouse, airbrush, etc)
 * this is not to be confused with WACOM X11 configuration "cursor" device.
 * WACOM tablets X11 configuration "cursor" refers to its device slot (which we mirror with
 * our `gSysCursors`) for puck like devices (tablet mice essentially).
 */
static GHOST_TTabletMode tablet_mode_from_name(const char *name, const char *type)
{
  int i;
  static const char *tablet_stylus_whitelist[] = {"stylus", "wizardpen", "acecad", "pen", nullptr};
 
  static const char *type_blacklist[] = {"pad", "cursor", "touch", nullptr};
 
  /* Skip some known unsupported types. */
  for (i = 0; type_blacklist[i] != nullptr; i++) {
    if (type && (strcasecmp(type, type_blacklist[i]) == 0)) {
      return GHOST_kTabletModeNone;
    }
  }
 
  /* First check device type to avoid cases where name is "Pen and Eraser" and type is "ERASER" */
  for (i = 0; tablet_stylus_whitelist[i] != nullptr; i++) {
    if (type && match_token(type, tablet_stylus_whitelist[i])) {
      return GHOST_kTabletModeStylus;
    }
  }
  if (type && match_token(type, "eraser")) {
    return GHOST_kTabletModeEraser;
  }
  for (i = 0; tablet_stylus_whitelist[i] != nullptr; i++) {
    if (name && match_token(name, tablet_stylus_whitelist[i])) {
      return GHOST_kTabletModeStylus;
    }
  }
  if (name && match_token(name, "eraser")) {
    return GHOST_kTabletModeEraser;
  }
 
  return GHOST_kTabletModeNone;
}
 
/* End code copied from Wine. */
 
void GHOST_SystemX11::refreshXInputDevices()
{
  if (xinput_version_.present) {
    /* Close tablet devices. */
    clearXInputDevices();
 
    /* Install our error handler to override Xlib's termination behavior */
    GHOST_X11_ERROR_HANDLERS_OVERRIDE(handler_store);
 
    {
      int device_count;
      XDeviceInfo *device_info = XListInputDevices(display_, &device_count);
 
      for (int i = 0; i < device_count; ++i) {
        char *device_type = device_info[i].type ? XGetAtomName(display_, device_info[i].type) :
                                                  nullptr;
        GHOST_TTabletMode tablet_mode = tablet_mode_from_name(device_info[i].name, device_type);
 
        // printf("Tablet type:'%s', name:'%s', index:%d\n", device_type, device_info[i].name, i);
 
        if (device_type) {
          XFree((void *)device_type);
        }
 
        if (!ELEM(tablet_mode, GHOST_kTabletModeStylus, GHOST_kTabletModeEraser)) {
          continue;
        }
 
        GHOST_TabletX11 xtablet = {tablet_mode};
        xtablet.ID = device_info[i].id;
        xtablet.Device = XOpenDevice(display_, xtablet.ID);
 
        if (xtablet.Device != nullptr) {
          /* Find how many pressure levels tablet has */
          XAnyClassPtr ici = device_info[i].inputclassinfo;
 
          if (ici != nullptr) {
            for (int j = 0; j < device_info[i].num_classes; ++j) {
              if (ici->c_class == ValuatorClass) {
                XValuatorInfo *xvi = (XValuatorInfo *)ici;
                if (xvi->axes != nullptr) {
                  xtablet.PressureLevels = xvi->axes[2].max_value;
 
                  if (xvi->num_axes > 3) {
                    /* This is assuming that the tablet has the same tilt resolution in both
                     * positive and negative directions. It would be rather weird if it didn't. */
                    xtablet.XtiltLevels = xvi->axes[3].max_value;
                    xtablet.YtiltLevels = xvi->axes[4].max_value;
                  }
                  else {
                    xtablet.XtiltLevels = 0;
                    xtablet.YtiltLevels = 0;
                  }
 
                  break;
                }
              }
 
              ici = (XAnyClassPtr)(((char *)ici) + ici->length);
            }
          }
 
          xtablets_.push_back(xtablet);
        }
      }
 
      XFreeDeviceList(device_info);
    }
 
    GHOST_X11_ERROR_HANDLERS_RESTORE(handler_store);
  }
}
 
void GHOST_SystemX11::clearXInputDevices()
{
  for (GHOST_TabletX11 &xtablet : xtablets_) {
    if (xtablet.Device) {
      XCloseDevice(display_, xtablet.Device);
    }
  }
 
  xtablets_.clear();
}
 
#endif /* WITH_X11_XINPUT */