GHOST_SystemX11.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include <X11/XKBlib.h> /* Allow detectable auto-repeat. */
#include <X11/Xlib.h>
 
#include "../GHOST_Types.h"
#include "GHOST_System.hh"
 
/* For tablets. */
#ifdef WITH_X11_XINPUT
#  include <X11/extensions/XInput.h>
 
/* Disable XINPUT warp, currently not implemented by XORG for multi-head display.
 * (see comment in XSERVER `Xi/xiwarppointer.c` -> `FIXME: panoramix stuff is missing` ~ v1.13.4)
 * If this is supported we can add back XINPUT for warping (fixing #48901).
 * For now disable (see #50383). */
// #  define USE_X11_XINPUT_WARP
#endif
 
#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
#  define GHOST_X11_RES_NAME "Blender"  /* res_name */
#  define GHOST_X11_RES_CLASS "Blender" /* res_class */
#endif
 
/* generic error handlers */
int GHOST_X11_ApplicationErrorHandler(Display *display, XErrorEvent *event);
int GHOST_X11_ApplicationIOErrorHandler(Display *display);
 
#define GHOST_X11_ERROR_HANDLERS_OVERRIDE(var) \
  struct { \
    XErrorHandler handler; \
    XIOErrorHandler handler_io; \
  } var = { \
      XSetErrorHandler(GHOST_X11_ApplicationErrorHandler), \
      XSetIOErrorHandler(GHOST_X11_ApplicationIOErrorHandler), \
  }
 
#define GHOST_X11_ERROR_HANDLERS_RESTORE(var) \
  { \
    (void)XSetErrorHandler(var.handler); \
    (void)XSetIOErrorHandler(var.handler_io); \
  } \
  ((void)0)
 
class GHOST_WindowX11;

class GHOST_SystemX11 : public GHOST_System {
 public:
 
  GHOST_SystemX11();

  ~GHOST_SystemX11() override;
 
  GHOST_TSuccess init() override;


  uint64_t getMilliSeconds() const override;

  uint8_t getNumDisplays() const override;

  void getMainDisplayDimensions(uint32_t &width, uint32_t &height) const override;

  void getAllDisplayDimensions(uint32_t &width, uint32_t &height) const override;

  GHOST_IWindow *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 = false,
                              const bool is_dialog = false,
                              const GHOST_IWindow *parent_window = nullptr) override;

  GHOST_IContext *createOffscreenContext(GHOST_GPUSettings gpu_settings) override;

  GHOST_TSuccess disposeContext(GHOST_IContext *context) override;

  bool processEvents(bool waitForEvent) override;
 
  GHOST_TSuccess getCursorPosition(int32_t &x, int32_t &y) const override;
 
  GHOST_TSuccess setCursorPosition(int32_t x, int32_t y) override;

  GHOST_TSuccess getPixelAtCursor(float r_color[3]) const override;

  GHOST_TSuccess getModifierKeys(GHOST_ModifierKeys &keys) const override;

  GHOST_TSuccess getButtons(GHOST_Buttons &buttons) const override;
 
  GHOST_TCapabilityFlag getCapabilities() const override;

 
  void addDirtyWindow(GHOST_WindowX11 *bad_wind);

 
  Display *getXDisplay()
  {
    return display_;
  }
 
#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
  XIM getX11_XIM()
  {
    return xim_;
  }
#endif

  uint64_t ms_from_input_time(const Time timestamp) const;

  void getClipboard_xcout(const XEvent *evt,
                          Atom sel,
                          Atom target,
                          unsigned char **txt,
                          unsigned long *len,
                          unsigned int *context) const;

  char *getClipboard(bool selection) const override;

  void putClipboard(const char *buffer, bool selection) const override;

  GHOST_TSuccess showMessageBox(const char *title,
                                const char *message,
                                const char *help_label,
                                const char *continue_label,
                                const char *link,
                                GHOST_DialogOptions dialog_options) const override;
#ifdef WITH_XDND
  static GHOST_TSuccess pushDragDropEvent(GHOST_TEventType eventType,
                                          GHOST_TDragnDropTypes draggedObjectType,
                                          GHOST_IWindow *window,
                                          int mouseX,
                                          int mouseY,
                                          void *data);
#endif

  bool setConsoleWindowState(GHOST_TConsoleWindowState /*action*/) override
  {
    return 0;
  }
 
#ifdef WITH_X11_XINPUT
  typedef struct GHOST_TabletX11 {
    GHOST_TTabletMode mode;
    XDevice *Device;
    XID ID;
 
    int MotionEvent;
    int ProxInEvent;
    int ProxOutEvent;
    int PressEvent;
 
    int PressureLevels;
    int XtiltLevels, YtiltLevels;
  } GHOST_TabletX11;
 
  std::vector<GHOST_TabletX11> &GetXTablets()
  {
    return xtablets_;
  }
#endif  // WITH_X11_XINPUT
 
  struct {
    Atom WM_STATE;
    Atom WM_CHANGE_STATE;
    Atom _NET_WM_STATE;
    Atom _NET_WM_STATE_MAXIMIZED_HORZ;
    Atom _NET_WM_STATE_MAXIMIZED_VERT;
    Atom _NET_WM_STATE_FULLSCREEN;
    Atom _MOTIF_WM_HINTS;
    Atom WM_TAKE_FOCUS;
    Atom WM_PROTOCOLS;
    Atom WM_DELETE_WINDOW;
 
    /* Atoms for Selection, copy & paste. */
    Atom TARGETS;
    Atom STRING;
    Atom C_STRING;
    Atom COMPOUND_TEXT;
    Atom TEXT;
    Atom CLIPBOARD;
    Atom PRIMARY;
    Atom XCLIP_OUT;
    Atom INCR;
    Atom UTF8_STRING;
#ifdef WITH_X11_XINPUT
    Atom TABLET;
#endif
  } atom_;
 
#ifdef WITH_X11_XINPUT
  XExtensionVersion xinput_version_;
#endif
 
 private:
  Display *display_;

  XkbDescRec *xkb_descr_;
 
#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
  XIM xim_;
#endif
 
#ifdef WITH_X11_XINPUT
  /* Tablet devices */
  std::vector<GHOST_TabletX11> xtablets_;
#endif

  std::vector<GHOST_WindowX11 *> dirty_windows_;

  char keyboard_vector_[32];

  Time last_warp_x_;
  Time last_warp_y_;
 
  /* Detect auto-repeat glitch. */
  unsigned int last_release_keycode_;
  Time last_release_time_;
 
#ifdef WITH_X11_XINPUT
  Time last_key_time_;
#endif
 
  uint keycode_last_repeat_key_;

 
#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
  bool openX11_IM();
#endif
 
#ifdef WITH_X11_XINPUT
  void clearXInputDevices();
  void refreshXInputDevices();
#endif
 
  GHOST_WindowX11 *findGhostWindow(Window xwind) const;
 
  void processEvent(XEvent *xe);
 
  Time lastEventTime(Time default_time);
 
  bool generateWindowExposeEvents();
};