GHOST_SystemWin32.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
 
#ifndef WIN32
#  error WIN32 only!
#endif  // WIN32
 
#define WIN32_LEAN_AND_MEAN
#include <ole2.h>  // for drag-n-drop
#include <windows.h>
 
#include "GHOST_System.h"
 
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();
 
  /***************************************************************************************
   ** Time(r) functionality
   ***************************************************************************************/
 
  GHOST_TUns64 performanceCounterToMillis(__int64 perf_ticks) const;
 
  GHOST_TUns64 tickCountToMillis(__int64 ticks) const;
 
  GHOST_TUns64 getMilliSeconds() const;
 
  /***************************************************************************************
   ** Display/window management functionality
   ***************************************************************************************/
 
  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);
 
  static GHOST_ContextD3D *createOffscreenContextD3D();
 
  static GHOST_TSuccess disposeContextD3D(GHOST_ContextD3D *context);
 
  /***************************************************************************************
   ** Event management functionality
   ***************************************************************************************/
 
  bool processEvents(bool waitForEvent);
 
  /***************************************************************************************
   ** Cursor management functionality
   ***************************************************************************************/
 
  GHOST_TSuccess getCursorPosition(GHOST_TInt32 &x, GHOST_TInt32 &y) const;
 
  GHOST_TSuccess setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y);
 
  /***************************************************************************************
   ** Access to mouse button and keyboard states.
   ***************************************************************************************/
 
  GHOST_TSuccess getModifierKeys(GHOST_ModifierKeys &keys) const;
 
  GHOST_TSuccess getButtons(GHOST_Buttons &buttons) 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;
 
  static GHOST_TSuccess pushDragDropEvent(GHOST_TEventType eventType,
                                          GHOST_TDragnDropTypes draggedObjectType,
                                          GHOST_WindowWin32 *window,
                                          int mouseX,
                                          int mouseY,
                                          void *data);
 
 protected:
  GHOST_TSuccess init();
 
  GHOST_TSuccess exit();
 
  GHOST_TKey convertKey(short vKey, short ScanCode, short extend) const;
 
  GHOST_TKey hardKey(RAWINPUT const &raw, bool *r_keyDown, bool *r_is_repeated_modifier);
 
  static GHOST_EventButton *processButtonEvent(GHOST_TEventType type,
                                               GHOST_WindowWin32 *window,
                                               GHOST_TButtonMask mask);
 
  static void processPointerEvent(
      UINT type, GHOST_WindowWin32 *window, WPARAM wParam, LPARAM lParam, bool &eventhandled);
 
  static GHOST_EventCursor *processCursorEvent(GHOST_WindowWin32 *window);
 
  static void processWheelEvent(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 *processWindowEvent(GHOST_TEventType type, GHOST_WindowWin32 *window);
 
#ifdef WITH_INPUT_IME
  static GHOST_Event *processImeEvent(GHOST_TEventType type,
                                      GHOST_WindowWin32 *window,
                                      GHOST_TEventImeData *data);
#endif  // WITH_INPUT_IME
 
  static void processMinMaxInfo(MINMAXINFO *minmax);
 
#ifdef WITH_INPUT_NDOF
  bool processNDOF(RAWINPUT const &raw);
#endif
 
  inline void retrieveModifierKeys(GHOST_ModifierKeys &keys) const;
 
  inline void storeModifierKeys(const GHOST_ModifierKeys &keys);
 
  inline void handleKeyboardChange(void);
 
  static LRESULT WINAPI s_wndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
 
  int toggleConsole(int action);
 
  GHOST_ModifierKeys m_modifierKeys;
  unsigned short m_keycode_last_repeat_key;
  bool m_hasPerformanceCounter;
  __int64 m_freq;
  __int64 m_start;
  __int64 m_lfstart;
  bool m_hasAltGr;
  WORD m_langId;
  HKL m_keylayout;
 
  int m_consoleStatus;
 
  int m_wheelDeltaAccum;
};
 
inline void GHOST_SystemWin32::retrieveModifierKeys(GHOST_ModifierKeys &keys) const
{
  keys = m_modifierKeys;
}
 
inline void GHOST_SystemWin32::storeModifierKeys(const GHOST_ModifierKeys &keys)
{
  m_modifierKeys = keys;
}
 
inline void GHOST_SystemWin32::handleKeyboardChange(void)
{
  m_keylayout = GetKeyboardLayout(0);  // get keylayout for current thread
  int i;
  SHORT s;
 
  // save the language identifier.
  m_langId = LOWORD(m_keylayout);
 
  for (m_hasAltGr = false, i = 32; i < 256; ++i) {
    s = VkKeyScanEx((char)i, m_keylayout);
    // s == -1 means no key that translates passed char code
    // high byte contains shift state. bit 2 ctrl pressed, bit 4 alt pressed
    // if both are pressed, we have AltGr keycombo on keylayout
    if (s != -1 && (s & 0x600) == 0x600) {
      m_hasAltGr = true;
      break;
    }
  }
}