GHOST_SystemWin32.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
 
#ifndef WIN32
#  error WIN32 only!
#endif /* WIN32 */
 
#ifndef NOMINMAX
#  define NOMINMAX
#endif
 
#define WIN32_LEAN_AND_MEAN
#include <ole2.h> /* For drag-n-drop. */
#include <windows.h>
 
#include "GHOST_System.hh"
 
class GHOST_EventButton;
class GHOST_EventCursor;
class GHOST_EventKey;
class GHOST_EventWheel;
class GHOST_EventWindow;
class GHOST_EventDragnDrop;
 
class GHOST_ContextD3D;
class GHOST_WindowWin32;

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

  ~GHOST_SystemWin32() override;
 
  /***************************************************************************************
   ** Time(r) functionality
   ***************************************************************************************/

  uint64_t performanceCounterToMillis(__int64 perf_ticks) const;

  uint64_t getMilliSeconds() const override;
 
  /***************************************************************************************
   ** Display/window management functionality
   ***************************************************************************************/

  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;

  static GHOST_ContextD3D *createOffscreenContextD3D();

  static GHOST_TSuccess disposeContextD3D(GHOST_ContextD3D *context);

  GHOST_IWindow *getWindowUnderCursor(int32_t /*x*/, int32_t /*y*/) override;
 
  /***************************************************************************************
   ** Event management functionality
   ***************************************************************************************/

  bool processEvents(bool waitForEvent) override;
 
  /***************************************************************************************
   ** Cursor management functionality
   ***************************************************************************************/

  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;
 
  uint32_t getCursorPreferredLogicalSize() const override;
 
  /***************************************************************************************
   ** Access to mouse button and keyboard states.
   ***************************************************************************************/

  GHOST_TSuccess getModifierKeys(GHOST_ModifierKeys &keys) const override;

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

  char *getClipboard(bool selection) const override;

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

  GHOST_TSuccess hasClipboardImage() const override;

  uint *getClipboardImage(int *r_width, int *r_height) const override;

  GHOST_TSuccess putClipboardImage(uint *rgba, int width, int height) 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;

  static GHOST_TSuccess pushDragDropEvent(GHOST_TEventType eventType,
                                          GHOST_TDragnDropTypes draggedObjectType,
                                          GHOST_WindowWin32 *window,
                                          int mouseX,
                                          int mouseY,
                                          void *data);
 
  /***************************************************************************************
   ** Modify tablet API
   ***************************************************************************************/

  void setTabletAPI(GHOST_TTabletAPI api) override;
 
  /***************************************************************************************
   ** Debug Info
   ***************************************************************************************/

  void initDebug(GHOST_Debug debug) override;
 
 protected:
  GHOST_TSuccess init() override;

  GHOST_TSuccess exit() override;

  GHOST_TKey convertKey(short vKey, short ScanCode, short extend) const;

  GHOST_TKey hardKey(RAWINPUT const &raw, bool *r_key_down);

  static GHOST_EventButton *processButtonEvent(GHOST_TEventType type,
                                               GHOST_WindowWin32 *window,
                                               GHOST_TButton mask);

  static void processWintabEvent(GHOST_WindowWin32 *window);

  static void processPointerEvent(
      UINT type, GHOST_WindowWin32 *window, WPARAM wParam, LPARAM lParam, bool &eventhandled);

  static GHOST_EventCursor *processCursorEvent(GHOST_WindowWin32 *window,
                                               const int32_t screen_co[2]);

  static void processWheelEventVertical(GHOST_WindowWin32 *window, WPARAM wParam, LPARAM lParam);

  static void processWheelEventHorizontal(GHOST_WindowWin32 *window, WPARAM wParam, LPARAM lParam);

  static GHOST_EventKey *processKeyEvent(GHOST_WindowWin32 *window, RAWINPUT const &raw);

  GHOST_TKey processSpecialKey(short vKey, short scanCode) const;

  static GHOST_Event *processWindowSizeEvent(GHOST_WindowWin32 *window);

  static GHOST_Event *processWindowEvent(GHOST_TEventType type, GHOST_WindowWin32 *window);
 
#ifdef WITH_INPUT_IME
  static GHOST_Event *processImeEvent(GHOST_TEventType type,
                                      GHOST_WindowWin32 *window,
                                      const GHOST_TEventImeData *data);
#endif /* WITH_INPUT_IME */

  static void processMinMaxInfo(MINMAXINFO *minmax);
 
#ifdef WITH_INPUT_NDOF
  bool processNDOF(RAWINPUT const &raw);
#endif

  void driveTrackpad();

  void processTrackpad();

  inline void handleKeyboardChange();

  static LRESULT WINAPI s_wndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);

  bool setConsoleWindowState(GHOST_TConsoleWindowState action) override;

  bool has_performance_counter_;
  __int64 freq_;
  bool has_alt_gr_;
  WORD lang_id_;
  HKL keylayout_;

  bool console_status_;

  int wheel_delta_accum_vertical_;
  int wheel_delta_accum_horizontal_;
};
 
inline void GHOST_SystemWin32::handleKeyboardChange()
{
  keylayout_ = GetKeyboardLayout(0); /* Get keylayout for current thread. */
  int i;
  SHORT s;
 
  /* Save the language identifier. */
  lang_id_ = LOWORD(keylayout_);
 
  for (has_alt_gr_ = false, i = 32; i < 256; ++i) {
    s = VkKeyScanEx((char)i, keylayout_);
    /* `s == -1` means no key that translates passed char code high byte contains shift state.
     * bit 2 Control pressed, bit 4 `Alt` pressed if both are pressed,
     * we have `AltGr` key-combination on key-layout. */
    if (s != -1 && (s & 0x600) == 0x600) {
      has_alt_gr_ = true;
      break;
    }
  }
}