GHOST_SystemX11.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 */
 
#pragma once
 
#include <X11/XKBlib.h> /* Allow detectable auto-repeat. */
#include <X11/Xlib.h>
 
#include "../GHOST_Types.h"
#include "GHOST_System.h"
 
// 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 T48901).
 * For now disable (see T50383). */
// #  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 *theEvent);
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();
 
  GHOST_TSuccess init();
 
  GHOST_TUns64 getMilliSeconds() const;
 
  GHOST_TUns8 getNumDisplays() const;
 
  void getMainDisplayDimensions(GHOST_TUns32 &width, GHOST_TUns32 &height) const;
 
  void getAllDisplayDimensions(GHOST_TUns32 &width, GHOST_TUns32 &height) const;
 
  GHOST_IWindow *createWindow(const char *title,
                              GHOST_TInt32 left,
                              GHOST_TInt32 top,
                              GHOST_TUns32 width,
                              GHOST_TUns32 height,
                              GHOST_TWindowState state,
                              GHOST_TDrawingContextType type,
                              GHOST_GLSettings glSettings,
                              const bool exclusive = false,
                              const bool is_dialog = false,
                              const GHOST_IWindow *parentWindow = 0);
 
  GHOST_IContext *createOffscreenContext(GHOST_GLSettings glSettings);
 
  GHOST_TSuccess disposeContext(GHOST_IContext *context);
 
  bool processEvents(bool waitForEvent);
 
  GHOST_TSuccess getCursorPosition(GHOST_TInt32 &x, GHOST_TInt32 &y) const;
 
  GHOST_TSuccess setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y);
 
  GHOST_TSuccess getModifierKeys(GHOST_ModifierKeys &keys) const;
 
  GHOST_TSuccess getButtons(GHOST_Buttons &buttons) const;
 
  void addDirtyWindow(GHOST_WindowX11 *bad_wind);
 
  Display *getXDisplay()
  {
    return m_display;
  }
 
#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
  XIM getX11_XIM()
  {
    return m_xim;
  }
#endif
 
  void getClipboard_xcout(const XEvent *evt,
                          Atom sel,
                          Atom target,
                          unsigned char **txt,
                          unsigned long *len,
                          unsigned int *context) const;
 
  GHOST_TUns8 *getClipboard(bool selection) const;
 
  void putClipboard(GHOST_TInt8 *buffer, bool selection) const;
 
  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;
#ifdef WITH_XDND
  static GHOST_TSuccess pushDragDropEvent(GHOST_TEventType eventType,
                                          GHOST_TDragnDropTypes draggedObjectType,
                                          GHOST_IWindow *window,
                                          int mouseX,
                                          int mouseY,
                                          void *data);
#endif
 
  int toggleConsole(int /*action*/)
  {
    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 m_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 COMPOUND_TEXT;
    Atom TEXT;
    Atom CLIPBOARD;
    Atom PRIMARY;
    Atom XCLIP_OUT;
    Atom INCR;
    Atom UTF8_STRING;
#ifdef WITH_X11_XINPUT
    Atom TABLET;
#endif
  } m_atom;
 
#ifdef WITH_X11_XINPUT
  XExtensionVersion m_xinput_version;
#endif
 
 private:
  Display *m_display;
 
  XkbDescRec *m_xkb_descr;
 
#if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
  XIM m_xim;
#endif
 
#ifdef WITH_X11_XINPUT
  /* Tablet devices */
  std::vector<GHOST_TabletX11> m_xtablets;
#endif
 
  std::vector<GHOST_WindowX11 *> m_dirty_windows;
 
  GHOST_TUns64 m_start_time;
 
  char m_keyboard_vector[32];
 
  Time m_last_warp_x;
  Time m_last_warp_y;
 
  /* Detect auto-repeat glitch. */
  unsigned int m_last_release_keycode;
  Time m_last_release_time;
 
  uint m_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();
};