Remove Carbon from Mac Auto-Type (#3347)

* Fix #3310

src/autotype/mac/AutoTypeMac.cpp

@@ -17,47 +17,43 @@
  */
 
 #include "AutoTypeMac.h"
+#include "AutoTypeMacKeyCodes.h"
 #include "gui/macutils/MacUtils.h"
 
-#include <ApplicationServices/ApplicationServices.h>
-
-#define HOTKEY_ID 1
 #define MAX_WINDOW_TITLE_LENGTH 1024
 #define INVALID_KEYCODE 0xFFFF
 
 AutoTypePlatformMac::AutoTypePlatformMac()
-    : m_hotkeyRef(nullptr)
+    : m_globalMonitor(nullptr)
-    , m_hotkeyId({ 'kpx2', HOTKEY_ID })
 {
-    EventTypeSpec eventSpec;
-    eventSpec.eventClass = kEventClassKeyboard;
-    eventSpec.eventKind = kEventHotKeyPressed;
-
-    ::InstallApplicationEventHandler(AutoTypePlatformMac::hotkeyHandler, 1, &eventSpec, this, nullptr);
 }
 
-//
+/**
-// Keepassx requires mac os 10.7
+ * Request accessibility permissions required for keyboard control
-//
+ *
+ * @return true on success
+ */
 bool AutoTypePlatformMac::isAvailable()
 {
-    return true;
+    return macUtils()->enableAccessibility();
 }
 
-//
+/**
-// Get list of visible window titles
+ * Get a list of the currently open window titles
-// see: Quartz Window Services
+ *
-//
+ * @return list of window titles
+ */
 QStringList AutoTypePlatformMac::windowTitles()
 {
     QStringList list;
 
-    CFArrayRef windowList = ::CGWindowListCopyWindowInfo(kCGWindowListOptionOnScreenOnly | kCGWindowListExcludeDesktopElements, kCGNullWindowID);
+    auto windowList = ::CGWindowListCopyWindowInfo(
-    if (windowList != nullptr) {
+        kCGWindowListOptionOnScreenOnly | kCGWindowListExcludeDesktopElements, kCGNullWindowID);
-        CFIndex count = ::CFArrayGetCount(windowList);
+    if (windowList) {
+        auto count = ::CFArrayGetCount(windowList);
 
         for (CFIndex i = 0; i < count; i++) {
-            CFDictionaryRef window = static_cast<CFDictionaryRef>(::CFArrayGetValueAtIndex(windowList, i));
+            auto window = static_cast<CFDictionaryRef>(::CFArrayGetValueAtIndex(windowList, i));
             if (windowLayer(window) != 0) {
                 continue;
             }
@@ -74,24 +70,28 @@ QStringList AutoTypePlatformMac::windowTitles()
     return list;
 }
 
-//
+/**
-// Get active window process id
+ * Get active window ID
-//
+ *
+ * @return window ID
+ */
 WId AutoTypePlatformMac::activeWindow()
 {
     return macUtils()->activeWindow();
 }
 
-//
+/**
-// Get active window title
+ * Get active window title
-// see: Quartz Window Services
+ *
-//
+ * @return window title
+ */
 QString AutoTypePlatformMac::activeWindowTitle()
 {
     QString title;
 
-    CFArrayRef windowList = ::CGWindowListCopyWindowInfo(kCGWindowListOptionOnScreenOnly | kCGWindowListExcludeDesktopElements, kCGNullWindowID);
+    CFArrayRef windowList = ::CGWindowListCopyWindowInfo(
-    if (windowList != nullptr) {
+        kCGWindowListOptionOnScreenOnly | kCGWindowListExcludeDesktopElements, kCGNullWindowID);
+    if (windowList) {
         CFIndex count = ::CFArrayGetCount(windowList);
 
         for (CFIndex i = 0; i < count; i++) {
@@ -111,41 +111,62 @@ QString AutoTypePlatformMac::activeWindowTitle()
     return title;
 }
 
-//
+/**
-// Register global hotkey
+ * Register global hotkey using NS global event monitor.
-//
+ * Note that this hotkey is not trapped and may trigger
+ * actions in the local application where it is issued.
+ *
+ * @param key key used for hotkey
+ * @param modifiers modifiers required in addition to key
+ * @return true on success
+ */
 bool AutoTypePlatformMac::registerGlobalShortcut(Qt::Key key, Qt::KeyboardModifiers modifiers)
 {
-    uint16 nativeKeyCode = qtToNativeKeyCode(key);
+    auto nativeKeyCode = qtToNativeKeyCode(key);
     if (nativeKeyCode == INVALID_KEYCODE) {
         qWarning("Invalid key code");
         return false;
     }
-    CGEventFlags nativeModifiers = qtToNativeModifiers(modifiers, false);
+    auto nativeModifiers = qtToNativeModifiers(modifiers);
-    if (::RegisterEventHotKey(nativeKeyCode, nativeModifiers, m_hotkeyId, GetApplicationEventTarget(), 0, &m_hotkeyRef) != noErr) {
+    m_globalMonitor =
-        qWarning("Register hotkey failed");
+        macUtils()->addGlobalMonitor(nativeKeyCode, nativeModifiers, this, AutoTypePlatformMac::hotkeyHandler);
-        return false;
-    }
-
     return true;
 }
 
-//
+/**
-// Unregister global hotkey
+ * Handle global hotkey presses by emitting the trigger signal
-//
+ *
+ * @param userData pointer to AutoTypePlatform
+ */
+void AutoTypePlatformMac::hotkeyHandler(void* userData)
+{
+    auto* self = static_cast<AutoTypePlatformMac*>(userData);
+    emit self->globalShortcutTriggered();
+}
+
+/**
+ * Unregister a previously registered global hotkey
+ *
+ * @param key unused
+ * @param modifiers unused
+ */
 void AutoTypePlatformMac::unregisterGlobalShortcut(Qt::Key key, Qt::KeyboardModifiers modifiers)
 {
     Q_UNUSED(key);
     Q_UNUSED(modifiers);
-
+    if (m_globalMonitor) {
-    ::UnregisterEventHotKey(m_hotkeyRef);
+        macUtils()->removeGlobalMonitor(m_globalMonitor);
+        m_globalMonitor = nullptr;
+    }
 }
 
+/**
+ * Unused
+ */
 int AutoTypePlatformMac::platformEventFilter(void* event)
 {
     Q_UNUSED(event);
     Q_ASSERT(false);
-
     return -1;
 }
 
@@ -154,17 +175,21 @@ AutoTypeExecutor* AutoTypePlatformMac::createExecutor()
     return new AutoTypeExecutorMac(this);
 }
 
-//
+/**
-// Activate window by process id
+ * Raise the given window ID
-//
+ *
+ * @return true on success
+ */
 bool AutoTypePlatformMac::raiseWindow(WId pid)
 {
     return macUtils()->raiseWindow(pid);
 }
 
-//
+/**
-// Activate last active window
+ * Hide the KeePassXC window
-//
+ *
+ * @return true on success
+ */
 bool AutoTypePlatformMac::hideOwnWindow()
 {
     return macUtils()->hideOwnWindow();
@@ -178,46 +203,55 @@ bool AutoTypePlatformMac::raiseOwnWindow()
     return macUtils()->raiseOwnWindow();
 }
 
-//
+/**
-// Send unicode character to active window
+ * Send provided character as key event to the active window
-// see: Quartz Event Services
+ *
-//
+ * @param ch unicode character
+ * @param isKeyDown whether the key is pressed
+ */
 void AutoTypePlatformMac::sendChar(const QChar& ch, bool isKeyDown)
 {
-    CGEventRef keyEvent = ::CGEventCreateKeyboardEvent(nullptr, 0, isKeyDown);
+    auto keyEvent = ::CGEventCreateKeyboardEvent(nullptr, 0, isKeyDown);
-    if (keyEvent != nullptr) {
+    if (keyEvent) {
-        UniChar unicode = ch.unicode();
+        auto unicode = ch.unicode();
         ::CGEventKeyboardSetUnicodeString(keyEvent, 1, &unicode);
         ::CGEventPost(kCGSessionEventTap, keyEvent);
         ::CFRelease(keyEvent);
     }
 }
 
-//
+/**
-// Send key code to active window
+ * Send provided Qt key as key event to the active window
-// see: Quartz Event Services
+ *
-//
+ * @param key Qt key code
-void AutoTypePlatformMac::sendKey(Qt::Key key, bool isKeyDown, Qt::KeyboardModifiers modifiers = 0)
+ * @param isKeyDown whether the key is pressed
+ * @param modifiers any modifiers to apply to key
+ */
+void AutoTypePlatformMac::sendKey(Qt::Key key, bool isKeyDown, Qt::KeyboardModifiers modifiers)
 {
-    uint16 keyCode = qtToNativeKeyCode(key);
+    auto keyCode = qtToNativeKeyCode(key);
     if (keyCode == INVALID_KEYCODE) {
         return;
     }
 
-    CGEventRef keyEvent = ::CGEventCreateKeyboardEvent(nullptr, keyCode, isKeyDown);
+    auto keyEvent = ::CGEventCreateKeyboardEvent(nullptr, keyCode, isKeyDown);
-    CGEventFlags nativeModifiers = qtToNativeModifiers(modifiers, true);
+    auto nativeModifiers = qtToNativeModifiers(modifiers);
-    if (keyEvent != nullptr) {
+    if (keyEvent) {
         ::CGEventSetFlags(keyEvent, nativeModifiers);
         ::CGEventPost(kCGSessionEventTap, keyEvent);
         ::CFRelease(keyEvent);
     }
 }
 
-//
+/**
-// Translate qt key code to mac os key code
+ * Translate Qt key to macOS key code provided by
-// see: HIToolbox/Events.h
+ * AutoTypeMacKeyCodes.h which are derived from
-//
+ * legacy Carbon "HIToolbox/Events.h"
-uint16 AutoTypePlatformMac::qtToNativeKeyCode(Qt::Key key)
+ *
+ * @param key key to translate
+ * @returns macOS key code
+ */
+CGKeyCode AutoTypePlatformMac::qtToNativeKeyCode(Qt::Key key)
 {
     switch (key) {
     case Qt::Key_A:
@@ -388,99 +422,74 @@ uint16 AutoTypePlatformMac::qtToNativeKeyCode(Qt::Key key)
         return kVK_F16;
 
     default:
-            Q_ASSERT(false);
         return INVALID_KEYCODE;
     }
 }
 
-//
+/**
-// Translate qt key modifiers to mac os modifiers
+ * Translate Qt key modifiers to macOS key modifiers
-// see: https://doc.qt.io/qt-5/osx-issues.html#special-keys
+ * provided by the Core Graphics component
-//
+ *
-CGEventFlags AutoTypePlatformMac::qtToNativeModifiers(Qt::KeyboardModifiers modifiers, bool native)
+ * @param modifiers Qt keyboard modifier(s)
+ * @returns macOS key modifier(s)
+ */
+CGEventFlags AutoTypePlatformMac::qtToNativeModifiers(Qt::KeyboardModifiers modifiers)
 {
-    CGEventFlags nativeModifiers = CGEventFlags(0);
+    auto nativeModifiers = CGEventFlags(0);
-
-    CGEventFlags shiftMod = CGEventFlags(shiftKey);
-    CGEventFlags cmdMod = CGEventFlags(cmdKey);
-    CGEventFlags optionMod = CGEventFlags(optionKey);
-    CGEventFlags controlMod = CGEventFlags(controlKey);
-
-    if (native) {
-        shiftMod = kCGEventFlagMaskShift;
-        cmdMod = kCGEventFlagMaskCommand;
-        optionMod = kCGEventFlagMaskAlternate;
-        controlMod = kCGEventFlagMaskControl;
-    }
-
 
     if (modifiers & Qt::ShiftModifier) {
-        nativeModifiers = CGEventFlags(nativeModifiers | shiftMod);
+        nativeModifiers = CGEventFlags(nativeModifiers | kCGEventFlagMaskShift);
     }
     if (modifiers & Qt::ControlModifier) {
-        nativeModifiers = CGEventFlags(nativeModifiers | cmdMod);
+        nativeModifiers = CGEventFlags(nativeModifiers | kCGEventFlagMaskCommand);
     }
     if (modifiers & Qt::AltModifier) {
-        nativeModifiers = CGEventFlags(nativeModifiers | optionMod);
+        nativeModifiers = CGEventFlags(nativeModifiers | kCGEventFlagMaskAlternate);
     }
     if (modifiers & Qt::MetaModifier) {
-        nativeModifiers = CGEventFlags(nativeModifiers | controlMod);
+        nativeModifiers = CGEventFlags(nativeModifiers | kCGEventFlagMaskControl);
     }
 
     return nativeModifiers;
 }
 
-//
+/**
-// Get window layer/level
+ * Get window layer / level
-//
+ *
+ * @param window macOS window ref
+ * @returns layer number or -1 if window not found
+ */
 int AutoTypePlatformMac::windowLayer(CFDictionaryRef window)
 {
     int layer;
 
-    CFNumberRef layerRef = static_cast<CFNumberRef>(::CFDictionaryGetValue(window, kCGWindowLayer));
+    auto layerRef = static_cast<CFNumberRef>(::CFDictionaryGetValue(window, kCGWindowLayer));
-    if (layerRef != nullptr
+    if (layerRef && ::CFNumberGetValue(layerRef, kCFNumberIntType, &layer)) {
-            && ::CFNumberGetValue(layerRef, kCFNumberIntType, &layer)) {
         return layer;
     }
 
     return -1;
 }
 
-//
+/**
-// Get window title
+ * Get window title for macOS window ref
-//
+ *
+ * @param window macOS window ref
+ * @returns window title if found
+ */
 QString AutoTypePlatformMac::windowTitle(CFDictionaryRef window)
 {
     char buffer[MAX_WINDOW_TITLE_LENGTH];
     QString title;
 
-    CFStringRef titleRef = static_cast<CFStringRef>(::CFDictionaryGetValue(window, kCGWindowName));
+    auto titleRef = static_cast<CFStringRef>(::CFDictionaryGetValue(window, kCGWindowName));
-    if (titleRef != nullptr
+    if (titleRef && ::CFStringGetCString(titleRef, buffer, MAX_WINDOW_TITLE_LENGTH, kCFStringEncodingUTF8)) {
-            && ::CFStringGetCString(titleRef, buffer, MAX_WINDOW_TITLE_LENGTH, kCFStringEncodingUTF8)) {
         title = QString::fromUtf8(buffer);
     }
 
     return title;
 }
 
-//
-// Carbon hotkey handler
-//
-OSStatus AutoTypePlatformMac::hotkeyHandler(EventHandlerCallRef nextHandler, EventRef theEvent, void *userData)
-{
-    Q_UNUSED(nextHandler);
-
-    AutoTypePlatformMac *self = static_cast<AutoTypePlatformMac *>(userData);
-    EventHotKeyID hotkeyId;
-
-    if (::GetEventParameter(theEvent, kEventParamDirectObject, typeEventHotKeyID, nullptr, sizeof(hotkeyId), nullptr, &hotkeyId) == noErr
-            && hotkeyId.id == HOTKEY_ID) {
-        emit self->globalShortcutTriggered();
-    }
-
-    return noErr;
-}
-
 //
 // ------------------------------ AutoTypeExecutorMac ------------------------------
 //
@@ -502,7 +511,7 @@ void AutoTypeExecutorMac::execKey(AutoTypeKey* action)
     m_platform->sendKey(action->key, false);
 }
 
-void AutoTypeExecutorMac::execClearField(AutoTypeClearField* action = nullptr)
+void AutoTypeExecutorMac::execClearField(AutoTypeClearField* action)
 {
     Q_UNUSED(action);
 

src/autotype/mac/AutoTypeMac.h

@@ -19,12 +19,12 @@
 #ifndef KEEPASSX_AUTOTYPEMAC_H
 #define KEEPASSX_AUTOTYPEMAC_H
 
-#include <Carbon/Carbon.h>
+#include <ApplicationServices/ApplicationServices.h>
 #include <QtPlugin>
 #include <memory>
 
-#include "autotype/AutoTypePlatformPlugin.h"
 #include "autotype/AutoTypeAction.h"
+#include "autotype/AutoTypePlatformPlugin.h"
 
 class AutoTypePlatformMac : public QObject, public AutoTypePlatformInterface
 {
@@ -48,20 +48,19 @@ public:
     bool raiseOwnWindow() override;
 
     void sendChar(const QChar& ch, bool isKeyDown);
-    void sendKey(Qt::Key key, bool isKeyDown, Qt::KeyboardModifiers modifiers);
+    void sendKey(Qt::Key key, bool isKeyDown, Qt::KeyboardModifiers modifiers = 0);
 
 signals:
     void globalShortcutTriggered();
 
 private:
-    EventHotKeyRef m_hotkeyRef;
+    static void hotkeyHandler(void* userData);
-    EventHotKeyID m_hotkeyId;
+    static CGKeyCode qtToNativeKeyCode(Qt::Key key);
-
+    static CGEventFlags qtToNativeModifiers(Qt::KeyboardModifiers modifiers);
-    static uint16 qtToNativeKeyCode(Qt::Key key);
-    static CGEventFlags qtToNativeModifiers(Qt::KeyboardModifiers modifiers, bool native);
     static int windowLayer(CFDictionaryRef window);
     static QString windowTitle(CFDictionaryRef window);
-    static OSStatus hotkeyHandler(EventHandlerCallRef nextHandler, EventRef theEvent, void *userData);
+
+    void* m_globalMonitor;
 };
 
 class AutoTypeExecutorMac : public AutoTypeExecutor

src/autotype/mac/AutoTypeMacKeyCodes.h

@@ -0,0 +1,160 @@
+//
+// Taken from HIToolbox/Events.h
+//
+
+/*
+ *  Summary:
+ *    Virtual keycodes
+ *
+ *  Discussion:
+ *    These constants are the virtual keycodes defined originally in
+ *    Inside Mac Volume V, pg. V-191. They identify physical keys on a
+ *    keyboard. Those constants with "ANSI" in the name are labeled
+ *    according to the key position on an ANSI-standard US keyboard.
+ *    For example, kVK_ANSI_A indicates the virtual keycode for the key
+ *    with the letter 'A' in the US keyboard layout. Other keyboard
+ *    layouts may have the 'A' key label on a different physical key;
+ *    in this case, pressing 'A' will generate a different virtual
+ *    keycode.
+ */
+
+#ifndef KEEPASSXC_AUTOTYPEMAC_KEYCODES_H
+#define KEEPASSXC_AUTOTYPEMAC_KEYCODES_H
+
+// clang-format off
+enum {
+    kVK_ANSI_A                    = 0x00,
+    kVK_ANSI_S                    = 0x01,
+    kVK_ANSI_D                    = 0x02,
+    kVK_ANSI_F                    = 0x03,
+    kVK_ANSI_H                    = 0x04,
+    kVK_ANSI_G                    = 0x05,
+    kVK_ANSI_Z                    = 0x06,
+    kVK_ANSI_X                    = 0x07,
+    kVK_ANSI_C                    = 0x08,
+    kVK_ANSI_V                    = 0x09,
+    kVK_ANSI_B                    = 0x0B,
+    kVK_ANSI_Q                    = 0x0C,
+    kVK_ANSI_W                    = 0x0D,
+    kVK_ANSI_E                    = 0x0E,
+    kVK_ANSI_R                    = 0x0F,
+    kVK_ANSI_Y                    = 0x10,
+    kVK_ANSI_T                    = 0x11,
+    kVK_ANSI_1                    = 0x12,
+    kVK_ANSI_2                    = 0x13,
+    kVK_ANSI_3                    = 0x14,
+    kVK_ANSI_4                    = 0x15,
+    kVK_ANSI_6                    = 0x16,
+    kVK_ANSI_5                    = 0x17,
+    kVK_ANSI_Equal                = 0x18,
+    kVK_ANSI_9                    = 0x19,
+    kVK_ANSI_7                    = 0x1A,
+    kVK_ANSI_Minus                = 0x1B,
+    kVK_ANSI_8                    = 0x1C,
+    kVK_ANSI_0                    = 0x1D,
+    kVK_ANSI_RightBracket         = 0x1E,
+    kVK_ANSI_O                    = 0x1F,
+    kVK_ANSI_U                    = 0x20,
+    kVK_ANSI_LeftBracket          = 0x21,
+    kVK_ANSI_I                    = 0x22,
+    kVK_ANSI_P                    = 0x23,
+    kVK_ANSI_L                    = 0x25,
+    kVK_ANSI_J                    = 0x26,
+    kVK_ANSI_Quote                = 0x27,
+    kVK_ANSI_K                    = 0x28,
+    kVK_ANSI_Semicolon            = 0x29,
+    kVK_ANSI_Backslash            = 0x2A,
+    kVK_ANSI_Comma                = 0x2B,
+    kVK_ANSI_Slash                = 0x2C,
+    kVK_ANSI_N                    = 0x2D,
+    kVK_ANSI_M                    = 0x2E,
+    kVK_ANSI_Period               = 0x2F,
+    kVK_ANSI_Grave                = 0x32,
+    kVK_ANSI_KeypadDecimal        = 0x41,
+    kVK_ANSI_KeypadMultiply       = 0x43,
+    kVK_ANSI_KeypadPlus           = 0x45,
+    kVK_ANSI_KeypadClear          = 0x47,
+    kVK_ANSI_KeypadDivide         = 0x4B,
+    kVK_ANSI_KeypadEnter          = 0x4C,
+    kVK_ANSI_KeypadMinus          = 0x4E,
+    kVK_ANSI_KeypadEquals         = 0x51,
+    kVK_ANSI_Keypad0              = 0x52,
+    kVK_ANSI_Keypad1              = 0x53,
+    kVK_ANSI_Keypad2              = 0x54,
+    kVK_ANSI_Keypad3              = 0x55,
+    kVK_ANSI_Keypad4              = 0x56,
+    kVK_ANSI_Keypad5              = 0x57,
+    kVK_ANSI_Keypad6              = 0x58,
+    kVK_ANSI_Keypad7              = 0x59,
+    kVK_ANSI_Keypad8              = 0x5B,
+    kVK_ANSI_Keypad9              = 0x5C
+};
+
+/* keycodes for keys that are independent of keyboard layout*/
+enum {
+    kVK_Return                    = 0x24,
+    kVK_Tab                       = 0x30,
+    kVK_Space                     = 0x31,
+    kVK_Delete                    = 0x33,
+    kVK_Escape                    = 0x35,
+    kVK_Command                   = 0x37,
+    kVK_Shift                     = 0x38,
+    kVK_CapsLock                  = 0x39,
+    kVK_Option                    = 0x3A,
+    kVK_Control                   = 0x3B,
+    kVK_RightCommand              = 0x36,
+    kVK_RightShift                = 0x3C,
+    kVK_RightOption               = 0x3D,
+    kVK_RightControl              = 0x3E,
+    kVK_Function                  = 0x3F,
+    kVK_F17                       = 0x40,
+    kVK_VolumeUp                  = 0x48,
+    kVK_VolumeDown                = 0x49,
+    kVK_Mute                      = 0x4A,
+    kVK_F18                       = 0x4F,
+    kVK_F19                       = 0x50,
+    kVK_F20                       = 0x5A,
+    kVK_F5                        = 0x60,
+    kVK_F6                        = 0x61,
+    kVK_F7                        = 0x62,
+    kVK_F3                        = 0x63,
+    kVK_F8                        = 0x64,
+    kVK_F9                        = 0x65,
+    kVK_F11                       = 0x67,
+    kVK_F13                       = 0x69,
+    kVK_F16                       = 0x6A,
+    kVK_F14                       = 0x6B,
+    kVK_F10                       = 0x6D,
+    kVK_F12                       = 0x6F,
+    kVK_F15                       = 0x71,
+    kVK_Help                      = 0x72,
+    kVK_Home                      = 0x73,
+    kVK_PageUp                    = 0x74,
+    kVK_ForwardDelete             = 0x75,
+    kVK_F4                        = 0x76,
+    kVK_End                       = 0x77,
+    kVK_F2                        = 0x78,
+    kVK_PageDown                  = 0x79,
+    kVK_F1                        = 0x7A,
+    kVK_LeftArrow                 = 0x7B,
+    kVK_RightArrow                = 0x7C,
+    kVK_DownArrow                 = 0x7D,
+    kVK_UpArrow                   = 0x7E
+};
+
+/* ISO keyboards only*/
+enum {
+    kVK_ISO_Section               = 0x0A
+};
+
+/* JIS keyboards only*/
+enum {
+    kVK_JIS_Yen                   = 0x5D,
+    kVK_JIS_Underscore            = 0x5E,
+    kVK_JIS_KeypadComma           = 0x5F,
+    kVK_JIS_Eisu                  = 0x66,
+    kVK_JIS_Kana                  = 0x68
+};
+// clang-format on
+
+#endif

src/autotype/mac/CMakeLists.txt

@@ -1,7 +1,7 @@
 set(autotype_mac_SOURCES AutoTypeMac.cpp)
 
 add_library(keepassx-autotype-cocoa MODULE ${autotype_mac_SOURCES})
-set_target_properties(keepassx-autotype-cocoa PROPERTIES LINK_FLAGS "-framework Foundation -framework AppKit -framework Carbon")
+set_target_properties(keepassx-autotype-cocoa PROPERTIES LINK_FLAGS "-framework Foundation -framework AppKit")
 target_link_libraries(keepassx-autotype-cocoa ${PROGNAME} Qt5::Core Qt5::Widgets)
 
 if(WITH_APP_BUNDLE)

src/gui/macutils/AppKit.h

@@ -20,7 +20,7 @@
 #define KEEPASSX_APPKIT_H
 
 #include <QObject>
-#include <unistd.h>
+#include <CoreGraphics/CGEvent.h>
 
 class AppKit : public QObject
 {
@@ -37,12 +37,15 @@ public:
     bool hideProcess(pid_t pid);
     bool isHidden(pid_t pid);
     bool isDarkMode();
+    void* addGlobalMonitor(CGKeyCode keycode, CGEventFlags modifier, void* userData, void (*handler)(void*));
+    void removeGlobalMonitor(void* monitor);
+    bool enableAccessibility();
 
 signals:
     void lockDatabases();
 
 private:
-    void *self;
+    void* self;
 };
 
 #endif  // KEEPASSX_APPKIT_H

src/gui/macutils/AppKitImpl.h

@@ -19,13 +19,14 @@
 #import "AppKit.h"
 
 #import <Foundation/Foundation.h>
+#import <AppKit/NSEvent.h>
 #import <AppKit/NSRunningApplication.h>
 
 @interface AppKitImpl : NSObject
 {
-    AppKit *m_appkit;
+    AppKit* m_appkit;
 }
-- (id) initWithObject:(AppKit *)appkit;
+- (id) initWithObject:(AppKit*)appkit;
 
 @property (strong) NSRunningApplication *lastActiveApplication;
 
@@ -36,5 +37,8 @@
 - (bool) isHidden:(pid_t) pid;
 - (bool) isDarkMode;
 - (void) userSwitchHandler:(NSNotification*) notification;
+- (id) addGlobalMonitor:(NSEventMask) mask handler:(void (^)(NSEvent*)) handler;
+- (void) removeGlobalMonitor:(id) monitor;
+- (bool) enableAccessibility;
 
 @end

src/gui/macutils/AppKitImpl.mm

@@ -22,7 +22,7 @@
 
 @implementation AppKitImpl
 
-- (id) initWithObject:(AppKit *)appkit
+- (id) initWithObject:(AppKit*)appkit
 {
     self = [super init];
     if (self) {
@@ -43,10 +43,10 @@
 //
 // Update last active application property
 //
-- (void) didDeactivateApplicationObserver:(NSNotification *) notification
+- (void) didDeactivateApplicationObserver:(NSNotification*) notification
 {
-    NSDictionary *userInfo = notification.userInfo;
+    NSDictionary* userInfo = notification.userInfo;
-    NSRunningApplication *app = userInfo[NSWorkspaceApplicationKey];
+    NSRunningApplication* app = userInfo[NSWorkspaceApplicationKey];
 
     if (app.processIdentifier != [self ownProcessId]) {
         self.lastActiveApplication = app;
@@ -74,7 +74,7 @@
 //
 - (bool) activateProcess:(pid_t) pid
 {
-    NSRunningApplication *app = [NSRunningApplication runningApplicationWithProcessIdentifier:pid];
+    NSRunningApplication* app = [NSRunningApplication runningApplicationWithProcessIdentifier:pid];
     return [app activateWithOptions:NSApplicationActivateIgnoringOtherApps];
 }
 
@@ -83,7 +83,7 @@
 //
 - (bool) hideProcess:(pid_t) pid
 {
-    NSRunningApplication *app = [NSRunningApplication runningApplicationWithProcessIdentifier:pid];
+    NSRunningApplication* app = [NSRunningApplication runningApplicationWithProcessIdentifier:pid];
     return [app hide];
 }
 
@@ -92,7 +92,7 @@
 //
 - (bool) isHidden:(pid_t) pid
 {
-    NSRunningApplication *app = [NSRunningApplication runningApplicationWithProcessIdentifier:pid];
+    NSRunningApplication* app = [NSRunningApplication runningApplicationWithProcessIdentifier:pid];
     return [app isHidden];
 }
 
@@ -101,7 +101,7 @@
 //
 - (bool) isDarkMode
 {
-    NSDictionary *dict = [[NSUserDefaults standardUserDefaults] persistentDomainForName:NSGlobalDomain];
+    NSDictionary* dict = [[NSUserDefaults standardUserDefaults] persistentDomainForName:NSGlobalDomain];
     id style = [dict objectForKey:@"AppleInterfaceStyle"];
     return ( style && [style isKindOfClass:[NSString class]]
              && NSOrderedSame == [style caseInsensitiveCompare:@"dark"] );
@@ -118,6 +118,31 @@
     }
 }
 
+//
+// Add global event monitor
+//
+- (id) addGlobalMonitor:(NSEventMask) mask handler:(void (^)(NSEvent*)) handler
+{
+    return [NSEvent addGlobalMonitorForEventsMatchingMask:mask handler:handler];
+}
+
+//
+// Remove global event monitor
+//
+- (void) removeGlobalMonitor:(id) monitor
+{
+    [NSEvent removeMonitor:monitor];
+}
+
+//
+// Check if accessibility is enabled, may show an popup asking for permissions
+//
+- (bool) enableAccessibility
+{
+    NSDictionary* opts = @{static_cast<id>(kAXTrustedCheckOptionPrompt): @YES};
+    return AXIsProcessTrustedWithOptions(static_cast<CFDictionaryRef>(opts));
+}
+
 @end
 
 //
@@ -169,3 +194,22 @@ bool AppKit::isDarkMode()
 {
     return [static_cast<id>(self) isDarkMode];
 }
+
+void* AppKit::addGlobalMonitor(CGKeyCode keycode, CGEventFlags modifier, void* userData, void (*handler)(void*))
+{
+    return [static_cast<id>(self) addGlobalMonitor:NSEventMaskKeyDown handler:^(NSEvent* event) {
+        if (event.keyCode == keycode && (event.modifierFlags & modifier) == modifier) {
+            handler(userData);
+        }
+    }];
+}
+
+void AppKit::removeGlobalMonitor(void* monitor)
+{
+    [static_cast<id>(self) removeGlobalMonitor:static_cast<id>(monitor)];
+}
+
+bool AppKit::enableAccessibility()
+{
+    return [static_cast<id>(self) enableAccessibility];
+}

src/gui/macutils/MacUtils.cpp

@@ -75,3 +75,18 @@ bool MacUtils::isDarkMode()
 {
     return m_appkit->isDarkMode();
 }
+
+void* MacUtils::addGlobalMonitor(CGKeyCode keycode, CGEventFlags modifier, void* userData, void (*handler)(void*))
+{
+    return m_appkit->addGlobalMonitor(keycode, modifier, userData, handler);
+}
+
+void MacUtils::removeGlobalMonitor(void* monitor)
+{
+    m_appkit->removeGlobalMonitor(monitor);
+}
+
+bool MacUtils::enableAccessibility()
+{
+    return m_appkit->enableAccessibility();
+}

src/gui/macutils/MacUtils.h

@@ -38,6 +38,9 @@ public:
     bool hideOwnWindow();
     bool isHidden();
     bool isDarkMode();
+    void* addGlobalMonitor(CGKeyCode keycode, CGEventFlags modifier, void* userData, void (*handler)(void*));
+    void removeGlobalMonitor(void* monitor);
+    bool enableAccessibility();
 
 signals:
     void lockDatabases();