OSXKeyState.h

Go to the documentation of this file.

/*
 * Deskflow -- mouse and keyboard sharing utility
 * SPDX-FileCopyrightText: (C) 2012 - 2016 Symless Ltd.
 * SPDX-FileCopyrightText: (C) 2004 Chris Schoeneman
 * SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
 */
 
#pragma once
 
#include "OSXAutoTypes.h"
#include "deskflow/KeyState.h"
 
#include <Carbon/Carbon.h>
 
#include <map>
#include <set>
#include <vector>
 
class IOSXKeyResource;


class OSXKeyState : public KeyState
{
public:
  using KeyIDs = std::vector<KeyID>;
 
  OSXKeyState(IEventQueue *events, std::vector<std::string> layouts, bool isLangSyncEnabled);
  OSXKeyState(IEventQueue *events, deskflow::KeyMap &keyMap, std::vector<std::string> layouts, bool isLangSyncEnabled);
  ~OSXKeyState() override = default;




  void handleModifierKeys(void *target, KeyModifierMask oldMask, KeyModifierMask newMask);




  KeyModifierMask mapModifiersFromOSX(uint32_t mask) const;


  KeyModifierMask mapModifiersToCarbon(uint32_t mask) const;


  KeyButton mapKeyFromEvent(KeyIDs &ids, KeyModifierMask *maskOut, CGEventRef event) const;


  bool
  mapDeskflowHotKeyToMac(KeyID key, KeyModifierMask mask, uint32_t &macVirtualKey, uint32_t &macModifierMask) const;

 
  // IKeyState overrides
  bool fakeCtrlAltDel() override;
  bool fakeMediaKey(KeyID id) override;
  KeyModifierMask pollActiveModifiers() const override;
  int32_t pollActiveGroup() const override;
  void pollPressedKeys(KeyButtonSet &pressedKeys) const override;
 
  CGEventFlags getModifierStateAsOSXFlags() const;
 
protected:
  // KeyState overrides
  void getKeyMap(deskflow::KeyMap &keyMap) override;
  void fakeKey(const Keystroke &keystroke) override;
 
private:
  class KeyResource;
 
  // Add hard coded special keys to a deskflow::KeyMap.
  void getKeyMapForSpecialKeys(deskflow::KeyMap &keyMap, int32_t group) const;
 
  // Convert keyboard resource to a key map
  bool getKeyMap(deskflow::KeyMap &keyMap, int32_t group, const IOSXKeyResource &r) const;
 
  // Get the available keyboard groups
  bool getGroups(AutoCFArray &) const;
 
  // Change active keyboard group to group
  void setGroup(int32_t group);
 
  // Send an event for the given modifier key
  void handleModifierKey(void *target, uint32_t virtualKey, KeyID id, bool down, KeyModifierMask newMask);
 
  // Checks if any in \p ids is a glyph key and if \p isCommand is false.
  // If so it adds the AltGr modifier to \p mask.  This allows OS X
  // servers to use the option key both as AltGr and as a modifier.  If
  // option is acting as AltGr (i.e. it generates a glyph and there are
  // no command modifiers active) then we don't send the super modifier
  // to clients because they'd try to match it as a command modifier.
  void adjustAltGrModifier(const KeyIDs &ids, KeyModifierMask *mask, bool isCommand) const;
 
  // Maps an OS X virtual key id to a KeyButton.  This simply remaps
  // the ids so we don't use KeyButton 0.
  static KeyButton mapVirtualKeyToKeyButton(uint32_t keyCode);
 
  // Maps a KeyButton to an OS X key code.  This is the inverse of
  // mapVirtualKeyToKeyButton.
  static uint32_t mapKeyButtonToVirtualKey(KeyButton keyButton);
 
  void init();
 
  // Post a key event to HID manager. It posts an event to HID client, a
  // much lower level than window manager which's the target from carbon
  // CGEventPost
  kern_return_t postHIDVirtualKey(uint8_t virtualKeyCode, bool postDown);
 
  // Get keyboard event flags accorfing to keyboard modifiers
  CGEventFlags getKeyboardEventFlags() const;
  CGEventFlags getDeviceDependedFlags() const;
 
  void setKeyboardModifiers(CGKeyCode virtualKey, bool keyDown);
 
  void postKeyboardKey(CGKeyCode virtualKey, bool keyDown);
 
private:
  // OS X uses a physical key if 0 for the 'A' key.  deskflow reserves
  // KeyButton 0 so we offset all OS X physical key ids by this much
  // when used as a KeyButton and by minus this much to map a KeyButton
  // to a physical button.
  enum
  {
    KeyButtonOffset = 1
  };
 
  using GroupMap = std::map<CFDataRef, int32_t>;
  using VirtualKeyMap = std::map<uint32_t, KeyID>;
 
  VirtualKeyMap m_virtualKeyMap;
  mutable uint32_t m_deadKeyState;
  AutoCFArray m_groups{nullptr, CFRelease};
  GroupMap m_groupMap;
  bool m_shiftPressed;
  bool m_controlPressed;
  bool m_altPressed;
  bool m_superPressed;
  bool m_capsPressed;
};