From bfca616a16ec206a9622ac7e17a124cd9431d28d Mon Sep 17 00:00:00 2001 From: moparisthebest Date: Mon, 27 Apr 2020 23:44:54 -0400 Subject: [PATCH] Update mac keycodes --- Events.h | 909 +++++++++++++++++++++++++++++++++++++++++++++ keymap.toml | 14 +- src/macos/codes.rs | 491 ++++++++++++------------ 3 files changed, 1165 insertions(+), 249 deletions(-) create mode 100644 Events.h diff --git a/Events.h b/Events.h new file mode 100644 index 0000000..f465750 --- /dev/null +++ b/Events.h @@ -0,0 +1,909 @@ +/* + File: HIToolbox/Events.h + + Contains: Event Manager Interfaces. + + Copyright: © 1985-2008 by Apple Computer, Inc., all rights reserved + + Bugs?: For bug reports, consult the following page on + the World Wide Web: + + http://developer.apple.com/bugreporter/ + +*/ +#ifndef __EVENTS__ +#define __EVENTS__ + +#ifndef __APPLICATIONSERVICES__ +#include +#endif + + +#include + +#if PRAGMA_ONCE +#pragma once +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#pragma pack(push, 2) + +typedef UInt16 EventKind; +typedef UInt16 EventMask; +enum { + nullEvent = 0, + mouseDown = 1, + mouseUp = 2, + keyDown = 3, + keyUp = 4, + autoKey = 5, + updateEvt = 6, + diskEvt = 7, /* Not sent in Carbon. See kEventClassVolume in CarbonEvents.h*/ + activateEvt = 8, + osEvt = 15, + kHighLevelEvent = 23 +}; + +enum { + mDownMask = 1 << mouseDown, /* mouse button pressed*/ + mUpMask = 1 << mouseUp, /* mouse button released*/ + keyDownMask = 1 << keyDown, /* key pressed*/ + keyUpMask = 1 << keyUp, /* key released*/ + autoKeyMask = 1 << autoKey, /* key repeatedly held down*/ + updateMask = 1 << updateEvt, /* window needs updating*/ + diskMask = 1 << diskEvt, /* disk inserted*/ + activMask = 1 << activateEvt, /* activate/deactivate window*/ + highLevelEventMask = 0x0400, /* high-level events (includes AppleEvents)*/ + osMask = 1 << osEvt, /* operating system events (suspend, resume)*/ + everyEvent = 0xFFFF /* all of the above*/ +}; + +enum { + charCodeMask = 0x000000FF, + keyCodeMask = 0x0000FF00, + adbAddrMask = 0x00FF0000, + osEvtMessageMask = (UInt32)0xFF000000 +}; + +enum { + /* OS event messages. Event (sub)code is in the high byte of the message field.*/ + mouseMovedMessage = 0x00FA, + suspendResumeMessage = 0x0001 +}; + +enum { + resumeFlag = 1 /* Bit 0 of message indicates resume vs suspend*/ +}; + +#if CALL_NOT_IN_CARBON +/* convertClipboardFlag is not ever set under Carbon. This is because scrap conversion is */ +/* not tied to suspend/resume events any longer. Your application should instead use the */ +/* scrap promise mechanism and fulfill scrap requests only when your promise keeper proc */ +/* is called. If you need to know if the scrap has changed, you can cache the last */ +/* ScrapRef you received and compare it with the current ScrapRef */ +enum { + convertClipboardFlag = 2 /* Bit 1 in resume message indicates clipboard change*/ +}; + +#endif /* CALL_NOT_IN_CARBON */ + +/* + CARBON ALERT! BATTLESTATIONS! + + The EventModifiers bits defined here are also used in the newer Carbon Event + key modifiers parameters. There are two main differences: + + 1) The Carbon key modifiers parameter is a UInt32, not a UInt16. Never try to + extract the key modifiers parameter from a Carbon Event into an EventModifiers + type. You will probably get your stack trashed. + 2) The Carbon key modifiers is just that: key modifiers. That parameter will + never contain the button state bit. +*/ +typedef UInt16 EventModifiers; +enum { + /* modifiers */ + activeFlagBit = 0, /* activate? (activateEvt and mouseDown)*/ + btnStateBit = 7, /* state of button?*/ + cmdKeyBit = 8, /* command key down?*/ + shiftKeyBit = 9, /* shift key down?*/ + alphaLockBit = 10, /* alpha lock down?*/ + optionKeyBit = 11, /* option key down?*/ + controlKeyBit = 12, /* control key down?*/ + rightShiftKeyBit = 13, /* right shift key down? Not supported on Mac OS X.*/ + rightOptionKeyBit = 14, /* right Option key down? Not supported on Mac OS X.*/ + rightControlKeyBit = 15 /* right Control key down? Not supported on Mac OS X.*/ +}; + +enum { + activeFlag = 1 << activeFlagBit, + btnState = 1 << btnStateBit, + cmdKey = 1 << cmdKeyBit, + shiftKey = 1 << shiftKeyBit, + alphaLock = 1 << alphaLockBit, + optionKey = 1 << optionKeyBit, + controlKey = 1 << controlKeyBit, + rightShiftKey = 1 << rightShiftKeyBit, /* Not supported on Mac OS X.*/ + rightOptionKey = 1 << rightOptionKeyBit, /* Not supported on Mac OS X.*/ + rightControlKey = 1 << rightControlKeyBit /* Not supported on Mac OS X.*/ +}; + +/* MacRoman character codes*/ +enum { + kNullCharCode = 0, + kHomeCharCode = 1, + kEnterCharCode = 3, + kEndCharCode = 4, + kHelpCharCode = 5, + kBellCharCode = 7, + kBackspaceCharCode = 8, + kTabCharCode = 9, + kLineFeedCharCode = 10, + kVerticalTabCharCode = 11, + kPageUpCharCode = 11, + kFormFeedCharCode = 12, + kPageDownCharCode = 12, + kReturnCharCode = 13, + kFunctionKeyCharCode = 16, + kCommandCharCode = 17, /* glyph available only in system fonts*/ + kCheckCharCode = 18, /* glyph available only in system fonts*/ + kDiamondCharCode = 19, /* glyph available only in system fonts*/ + kAppleLogoCharCode = 20, /* glyph available only in system fonts*/ + kEscapeCharCode = 27, + kClearCharCode = 27, + kLeftArrowCharCode = 28, + kRightArrowCharCode = 29, + kUpArrowCharCode = 30, + kDownArrowCharCode = 31, + kSpaceCharCode = 32, + kDeleteCharCode = 127, + kBulletCharCode = 165, + kNonBreakingSpaceCharCode = 202 +}; + +/* useful Unicode code points*/ +enum { + kShiftUnicode = 0x21E7, /* Unicode UPWARDS WHITE ARROW*/ + kControlUnicode = 0x2303, /* Unicode UP ARROWHEAD*/ + kOptionUnicode = 0x2325, /* Unicode OPTION KEY*/ + kCommandUnicode = 0x2318, /* Unicode PLACE OF INTEREST SIGN*/ + kPencilUnicode = 0x270E, /* Unicode LOWER RIGHT PENCIL; actually pointed left until Mac OS X 10.3*/ + kPencilLeftUnicode = 0xF802, /* Unicode LOWER LEFT PENCIL; available in Mac OS X 10.3 and later*/ + kCheckUnicode = 0x2713, /* Unicode CHECK MARK*/ + kDiamondUnicode = 0x25C6, /* Unicode BLACK DIAMOND*/ + kBulletUnicode = 0x2022, /* Unicode BULLET*/ + kAppleLogoUnicode = 0xF8FF /* Unicode APPLE LOGO*/ +}; + + +/* + * 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. + */ +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 +}; + +struct EventRecord { + EventKind what; + unsigned long message; + UInt32 when; + Point where; + EventModifiers modifiers; +}; +typedef struct EventRecord EventRecord; +typedef CALLBACK_API( void , FKEYProcPtr )(void); +typedef STACK_UPP_TYPE(FKEYProcPtr) FKEYUPP; +/* + * NewFKEYUPP() + * + * Availability: + * Mac OS X: not available + * CarbonLib: not available + * Non-Carbon CFM: available as macro/inline + */ + +/* + * DisposeFKEYUPP() + * + * Availability: + * Mac OS X: not available + * CarbonLib: not available + * Non-Carbon CFM: available as macro/inline + */ + +/* + * InvokeFKEYUPP() + * + * Availability: + * Mac OS X: not available + * CarbonLib: not available + * Non-Carbon CFM: available as macro/inline + */ + +#if !__LP64__ +/* + * GetMouse() *** DEPRECATED *** + * + * Deprecated: + * Use HIGetMousePosition instead. + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] but deprecated in 10.5 + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern void +GetMouse(Point * mouseLoc) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5; + + +#endif /* !__LP64__ */ + +/* + * Button() *** DEPRECATED *** + * + * Deprecated: + * Use GetCurrentButtonState or GetCurrentEventButtonState instead. + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework but deprecated in 10.6 + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern Boolean +Button(void) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_6; + + +#if !__LP64__ +/* + * StillDown() + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern Boolean +StillDown(void) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER; + + +/* + * WaitMouseUp() + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern Boolean +WaitMouseUp(void) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER; + + +/* + * KeyTranslate() *** DEPRECATED *** + * + * Deprecated: + * Use UCKeyTranslate instead. + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] but deprecated in 10.6 + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern UInt32 +KeyTranslate( + const void * transData, + UInt16 keycode, + UInt32 * state) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_6; + + +/* + * GetCaretTime() + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern UInt32 +GetCaretTime(void) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER; + + + +#endif /* !__LP64__ */ + +/* + QuickTime 3.0 supports GetKeys() on unix and win32 + But, on little endian machines you will have to be + careful about bit numberings and/or use a KeyMapByteArray + instead. +*/ +#if TARGET_API_MAC_OS8 + +typedef UInt32 KeyMap[4]; +#else +typedef BigEndianUInt32 KeyMap[4]; +#endif /* TARGET_API_MAC_OS8 */ + +typedef UInt8 KeyMapByteArray[16]; +/* + * GetKeys() + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern void +GetKeys(KeyMap theKeys) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER; + + +/* Obsolete event types & masks */ +enum { + networkEvt = 10, + driverEvt = 11, + app1Evt = 12, + app2Evt = 13, + app3Evt = 14, + app4Evt = 15, + networkMask = 0x0400, + driverMask = 0x0800, + app1Mask = 0x1000, + app2Mask = 0x2000, + app3Mask = 0x4000, + app4Mask = 0x8000 +}; + +struct EvQEl { + QElemPtr qLink; + SInt16 qType; + EventKind evtQWhat; /* this part is identical to the EventRecord as defined above */ + unsigned long evtQMessage; + UInt32 evtQWhen; + Point evtQWhere; + EventModifiers evtQModifiers; +}; +typedef struct EvQEl EvQEl; +typedef EvQEl * EvQElPtr; +typedef CALLBACK_API( void , GetNextEventFilterProcPtr )(EventRecord *theEvent, Boolean *result); +typedef STACK_UPP_TYPE(GetNextEventFilterProcPtr) GetNextEventFilterUPP; +/* + * NewGetNextEventFilterUPP() + * + * Availability: + * Mac OS X: not available + * CarbonLib: not available + * Non-Carbon CFM: available as macro/inline + */ + +/* + * DisposeGetNextEventFilterUPP() + * + * Availability: + * Mac OS X: not available + * CarbonLib: not available + * Non-Carbon CFM: available as macro/inline + */ + +/* + * InvokeGetNextEventFilterUPP() + * + * Availability: + * Mac OS X: not available + * CarbonLib: not available + * Non-Carbon CFM: available as macro/inline + */ + +typedef GetNextEventFilterUPP GNEFilterUPP; +#if !__LP64__ +/* + * GetDblTime() + * + * Summary: + * Returns the maximum time (in units of 1/60th of a second) allowed + * between two consecutive mouse-down events in order for the second + * click to be considered a double-click. + * + * Discussion: + * In 64-bit applications, you may replace calls to this API with + * calls to NXClickTime (declared in + * ) or with +[NSEvent + * doubleClickInterval] (available in Mac OS X 10.6 and later). + * + * Mac OS X threading: + * Not thread safe + * + * Result: + * The maximum time between mouse-downs allowed for a double-click. + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern UInt32 +GetDblTime(void) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER; + + +/* + * SetEventMask() + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern void +SetEventMask(EventMask value) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER; + + +/* + * GetNextEvent() *** DEPRECATED *** + * + * Deprecated: + * Use ReceiveNextEvent instead. + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] but deprecated in 10.6 + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern Boolean +GetNextEvent( + EventMask eventMask, + EventRecord * theEvent) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_6; + + +/* + * WaitNextEvent() *** DEPRECATED *** + * + * Deprecated: + * Use ReceiveNextEvent instead. + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] but deprecated in 10.6 + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern Boolean +WaitNextEvent( + EventMask eventMask, + EventRecord * theEvent, + UInt32 sleep, + RgnHandle mouseRgn) /* can be NULL */ AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_6; + + +/* + * EventAvail() *** DEPRECATED *** + * + * Deprecated: + * Use FindSpecificEventInQueue instead. + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] but deprecated in 10.6 + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern Boolean +EventAvail( + EventMask eventMask, + EventRecord * theEvent) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_6; + + +/* + * PostEvent() *** DEPRECATED *** + * + * Deprecated: + * Use PostEventToQueue or CGEventPost instead. + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] but deprecated in 10.6 + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern OSErr +PostEvent( + EventKind eventNum, + UInt32 eventMsg) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_6; + + +#endif /* !__LP64__ */ + +/* + * FlushEvents() *** DEPRECATED *** + * + * Deprecated: + * Use FlushEventsMatchingListFromQueue, + * FlushSpecificEventsFromQueue, or FlushEventQueue instead. + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework but deprecated in 10.6 + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern void +FlushEvents( + EventMask whichMask, + EventMask stopMask) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_6; + + +#if OLDROUTINENAMES +#define KeyTrans(transData, keycode, state) KeyTranslate(transData, keycode, state) +#endif /* OLDROUTINENAMES */ + +#if !__LP64__ +/* + * KeyScript() *** DEPRECATED *** + * + * Deprecated: + * Use TISSelectInputSource API for positive verbs (ScriptCode). + * Use TSMDocument properties to restrict input sources: + * kTSMDocumentEnabledInputSourcesPropertyTag + * kTSMDocumentInputSourceOverridePropertyTag + * + * Summary: + * Switch to the specified script's default (last used) input source. + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] but deprecated in 10.5 + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern void +KeyScript(short code) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5; + + +#endif /* !__LP64__ */ + +/* + * IsCmdChar() *** DEPRECATED *** + * + * Deprecated: + * Use IsUserCancelEventRef or CheckEventQueueForUserCancel instead. + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework but deprecated in 10.6 + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern Boolean +IsCmdChar( + const EventRecord * event, + short test) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_6; + + + +/* + LowMem accessor functions previously in LowMem.h +*/ +/* + * LMGetKeyThresh() + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern SInt16 +LMGetKeyThresh(void) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER; + + +#if !__LP64__ +/* + * LMSetKeyThresh() + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern void +LMSetKeyThresh(SInt16 value) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER; + + + +#endif /* !__LP64__ */ + +/* + * LMGetKeyRepThresh() + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern SInt16 +LMGetKeyRepThresh(void) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER; + + +#if !__LP64__ +/* + * LMSetKeyRepThresh() + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern void +LMSetKeyRepThresh(SInt16 value) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER; + + +#endif /* !__LP64__ */ + +/* + * LMGetKbdLast() + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern UInt8 +LMGetKbdLast(void) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER; + + +#if !__LP64__ +/* + * LMSetKbdLast() + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern void +LMSetKbdLast(UInt8 value) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER; + + + +#endif /* !__LP64__ */ + +/* + * LMGetKbdType() + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern UInt8 +LMGetKbdType(void) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER; + + +#if !__LP64__ +/* + * LMSetKbdType() + * + * Mac OS X threading: + * Not thread safe + * + * Availability: + * Mac OS X: in version 10.0 and later in Carbon.framework [32-bit only] + * CarbonLib: in CarbonLib 1.0 and later + * Non-Carbon CFM: in InterfaceLib 7.1 and later + */ +extern void +LMSetKbdType(UInt8 value) AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER; + + +#endif /* !__LP64__ */ + + +#pragma pack(pop) + +#ifdef __cplusplus +} +#endif + +#endif /* __EVENTS__ */ + diff --git a/keymap.toml b/keymap.toml index 628ff4a..35ecaa8 100644 --- a/keymap.toml +++ b/keymap.toml @@ -10,38 +10,38 @@ revert_keymap_index = 0 # this is the default index to use when the program first starts # in this case, 2 means Unix Programmer Dvorak -default_keymap_index = 2 +default_keymap_index = 1 # these are the keymaps available, you can add as many as you want or re-order them, just be aware the mapping is # always done from the first one to all subsequent ones, so you probably want to leave QWERTY or similar up top keymaps = [ # default key layout, QWERTY in this case """ - ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,BRK, + ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,TAB, GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, INS, HOME,PGUP, NLCK,PSLS,PAST,PMNS, TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSLS, DEL, END, PGDN, P7, P8, P9, CAPS,A, S, D, F, G, H, J, K, L, SCLN,QUOT, ENT, P4, P5, P6, PPLS, LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH, RSFT, UP, P1, P2, P3, - LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, RCTL, LEFT,DOWN,RGHT, P0, PDOT,PENT + LCTL,TAB,LALT, SPC, RALT,RGUI,APP, RCTL, LEFT,DOWN,RGHT, P0, PDOT,PENT """, # Dvorak http://en.wikipedia.org/wiki/Dvorak_Simplified_Keyboard # https://www.moparisthebest.com/kbs/standard-dvorak-QwertySecondary.svg """ - ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,BRK, + ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,TAB, GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, LBRC,RBRC,BSPC, INS, HOME,PGUP, NLCK,PSLS,PAST,PMNS, TAB, QUOT,COMM,DOT, P, Y, F, G, C, R, L, SLSH,EQL, BSLS, DEL, END, PGDN, P7, P8, P9, CAPS,A, O, E, U, I, D, H, T, N, S, MINS, ENT, P4, P5, P6, PPLS, LSFT,SCLN,Q, J, K, X, B, M, W, V, Z, RSFT, UP, P1, P2, P3, - LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, RCTL, LEFT,DOWN,RGHT, P0, PDOT,PENT + LCTL,TAB,LALT, SPC, RALT,RGUI,APP, RCTL, LEFT,DOWN,RGHT, P0, PDOT,PENT """, # Unix Programmer Dvorak - for unix developers who are switching from dvorak # https://www.moparisthebest.com/kbs/programmer-dvorak-NoSecondary-NumpadStandard-NoSwap-StandardNums-SwapAt-SwapPipe.svg """ - ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,BRK, + ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, PSCR,SLCK,TAB, *^4:*^GRV, *^7:*1, *LBRC:*2, *^LBRC:*3, *^RBRC:*4, *^9:*5, *^2:*6, *^8:*7, *^0:*8, *^EQL:*9, *RBRC:*0, *^1:*^5, *^3:*GRV, BSPC, INS, HOME,PGUP, NLCK, *PSLS:*^9, *PAST:*^0, *PMNS:*^4, TAB, *QUOT, *COMM, *DOT, P, Y, F, G, C, R, L, *SLSH, *EQL:*^6, *^BSLS, DEL, END, PGDN, *P7:^A, *P8:^B, *P9:^C, CAPS, A, O, E, U, I, D, H, T, N, S, *MINS, ENT, *P4:^D, *P5:^E, *P6:^F, *PPLS:*COMM, LSFT, *SCLN, Q, J, K, X, B, M, W, V, Z, RSFT, UP, *P1:*EQL, *P2:X, *P3:*^SCLN, - LCTL, LGUI, LALT, SPC, RALT, RGUI, APP, RCTL, LEFT,DOWN,RGHT, *P0:*BSLS, *PDOT:*SCLN, PENT + LCTL, TAB, LALT, SPC, RALT, RGUI, APP, RCTL, LEFT,DOWN,RGHT, *P0:*BSLS, *PDOT:*SCLN, PENT """, ] diff --git a/src/macos/codes.rs b/src/macos/codes.rs index 9212ce2..9fd7f62 100644 --- a/src/macos/codes.rs +++ b/src/macos/codes.rs @@ -2,244 +2,253 @@ use std::collections::HashMap; use core_graphics::event::CGKeyCode; -// https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes - -pub const KEY_BACKSPACE: CGKeyCode = 0x08; -pub const KEY_TAB: CGKeyCode = 0x09; -pub const KEY_ENTER: CGKeyCode = 0x0D; -pub const KEY_KPENTER: CGKeyCode = 0x0D; // on windows, same as KEY_ENTER.. -pub const KEY_ESC: CGKeyCode = 0x1B; -pub const KEY_SPACE: CGKeyCode = 0x20; -pub const KEY_HOME: CGKeyCode = 0x24; -pub const KEY_LEFT: CGKeyCode = 0x25; -pub const KEY_UP: CGKeyCode = 0x26; -pub const KEY_RIGHT: CGKeyCode = 0x27; -pub const KEY_DOWN: CGKeyCode = 0x28; -pub const KEY_INSERT: CGKeyCode = 0x2D; -pub const KEY_DELETE: CGKeyCode = 0x2E; -pub const KEY_10: CGKeyCode = 0x30; // named 10 on linux, 0 on windows.. -pub const KEY_0: CGKeyCode = 0x30; -pub const KEY_1: CGKeyCode = 0x31; -pub const KEY_2: CGKeyCode = 0x32; -pub const KEY_3: CGKeyCode = 0x33; -pub const KEY_4: CGKeyCode = 0x34; -pub const KEY_5: CGKeyCode = 0x35; -pub const KEY_6: CGKeyCode = 0x36; -pub const KEY_7: CGKeyCode = 0x37; -pub const KEY_8: CGKeyCode = 0x38; -pub const KEY_9: CGKeyCode = 0x39; -pub const KEY_A: CGKeyCode = 0x41; -pub const KEY_B: CGKeyCode = 0x42; -pub const KEY_C: CGKeyCode = 0x43; -pub const KEY_D: CGKeyCode = 0x44; -pub const KEY_E: CGKeyCode = 0x45; -pub const KEY_F: CGKeyCode = 0x46; -pub const KEY_G: CGKeyCode = 0x47; -pub const KEY_H: CGKeyCode = 0x48; -pub const KEY_I: CGKeyCode = 0x49; -pub const KEY_J: CGKeyCode = 0x4A; -pub const KEY_K: CGKeyCode = 0x4B; -pub const KEY_L: CGKeyCode = 0x4C; -pub const KEY_M: CGKeyCode = 0x4D; -pub const KEY_N: CGKeyCode = 0x4E; -pub const KEY_O: CGKeyCode = 0x4F; -pub const KEY_P: CGKeyCode = 0x50; -pub const KEY_Q: CGKeyCode = 0x51; -pub const KEY_R: CGKeyCode = 0x52; -pub const KEY_S: CGKeyCode = 0x53; -pub const KEY_T: CGKeyCode = 0x54; -pub const KEY_U: CGKeyCode = 0x55; -pub const KEY_V: CGKeyCode = 0x56; -pub const KEY_W: CGKeyCode = 0x57; -pub const KEY_X: CGKeyCode = 0x58; -pub const KEY_Y: CGKeyCode = 0x59; -pub const KEY_Z: CGKeyCode = 0x5A; -pub const KEY_KP0: CGKeyCode = 0x60; -pub const KEY_KP1: CGKeyCode = 0x61; -pub const KEY_KP2: CGKeyCode = 0x62; -pub const KEY_KP3: CGKeyCode = 0x63; -pub const KEY_KP4: CGKeyCode = 0x64; -pub const KEY_KP5: CGKeyCode = 0x65; -pub const KEY_KP6: CGKeyCode = 0x66; -pub const KEY_KP7: CGKeyCode = 0x67; -pub const KEY_KP8: CGKeyCode = 0x68; -pub const KEY_KP9: CGKeyCode = 0x69; -pub const KEY_F1: CGKeyCode = 0x70; -pub const KEY_F2: CGKeyCode = 0x71; -pub const KEY_F3: CGKeyCode = 0x72; -pub const KEY_F4: CGKeyCode = 0x73; -pub const KEY_F5: CGKeyCode = 0x74; -pub const KEY_F6: CGKeyCode = 0x75; -pub const KEY_F7: CGKeyCode = 0x76; -pub const KEY_F8: CGKeyCode = 0x77; -pub const KEY_F9: CGKeyCode = 0x78; -pub const KEY_F10: CGKeyCode = 0x79; -pub const KEY_F11: CGKeyCode = 0x7A; -pub const KEY_F12: CGKeyCode = 0x7B; -pub const KEY_NUMLOCK: CGKeyCode = 0x90; -pub const KEY_SCROLLLOCK: CGKeyCode = 0x91; -pub const KEY_CAPSLOCK: CGKeyCode = 0x14; -pub const KEY_LEFTSHIFT: CGKeyCode = 0xA0; -pub const KEY_RIGHTSHIFT: CGKeyCode = 0xA1; -pub const KEY_LEFTCTRL: CGKeyCode = 0xA2; -pub const KEY_RIGHTCTRL: CGKeyCode = 0xA3; - -pub const KEY_LBUTTON: CGKeyCode = 0x01; -pub const KEY_RBUTTON: CGKeyCode = 0x02; -pub const KEY_CANCEL: CGKeyCode = 0x03; -pub const KEY_MBUTTON: CGKeyCode = 0x04; -pub const KEY_XBUTTON1: CGKeyCode = 0x05; -pub const KEY_XBUTTON2: CGKeyCode = 0x06; -pub const KEY_BACK: CGKeyCode = 0x08; -pub const KEY_CLEAR: CGKeyCode = 0x0C; -pub const KEY_RETURN: CGKeyCode = 0x0D; -pub const KEY_SHIFT: CGKeyCode = 0x10; -pub const KEY_CONTROL: CGKeyCode = 0x11; -pub const KEY_MENU: CGKeyCode = 0x12; -pub const KEY_PAUSE: CGKeyCode = 0x13; -pub const KEY_CAPITAL: CGKeyCode = 0x14; -pub const KEY_KANA: CGKeyCode = 0x15; -pub const KEY_HANGEUL: CGKeyCode = 0x15; -pub const KEY_HANGUL: CGKeyCode = 0x15; -pub const KEY_JUNJA: CGKeyCode = 0x17; -pub const KEY_FINAL: CGKeyCode = 0x18; -pub const KEY_HANJA: CGKeyCode = 0x19; -pub const KEY_KANJI: CGKeyCode = 0x19; -pub const KEY_ESCAPE: CGKeyCode = 0x1B; -pub const KEY_CONVERT: CGKeyCode = 0x1C; -pub const KEY_NONCONVERT: CGKeyCode = 0x1D; -pub const KEY_ACCEPT: CGKeyCode = 0x1E; -pub const KEY_MODECHANGE: CGKeyCode = 0x1F; -pub const KEY_PAGEUP: CGKeyCode = 0x21; -pub const KEY_PAGEDOWN: CGKeyCode = 0x22; -pub const KEY_END: CGKeyCode = 0x23; -pub const KEY_SELECT: CGKeyCode = 0x29; -pub const KEY_PRINT: CGKeyCode = 0x2A; -pub const KEY_EXECUTE: CGKeyCode = 0x2B; -pub const KEY_SYSRQ: CGKeyCode = 0x2C; -pub const KEY_HELP: CGKeyCode = 0x2F; -pub const KEY_LEFTMETA: CGKeyCode = 0x5B; -pub const KEY_RIGHTMETA: CGKeyCode = 0x5C; -pub const KEY_COMPOSE: CGKeyCode = 0x5D; -pub const KEY_SLEEP: CGKeyCode = 0x5F; -pub const KEY_KPASTERISK: CGKeyCode = 0x6A; -pub const KEY_KPPLUS: CGKeyCode = 0x6B; -pub const KEY_SEPARATOR: CGKeyCode = 0x6C; -pub const KEY_KPMINUS: CGKeyCode = 0x6D; -pub const KEY_KPDOT: CGKeyCode = 0x6E; -pub const KEY_KPSLASH: CGKeyCode = 0x6F; -pub const KEY_F13: CGKeyCode = 0x7C; -pub const KEY_F14: CGKeyCode = 0x7D; -pub const KEY_F15: CGKeyCode = 0x7E; -pub const KEY_F16: CGKeyCode = 0x7F; -pub const KEY_F17: CGKeyCode = 0x80; -pub const KEY_F18: CGKeyCode = 0x81; -pub const KEY_F19: CGKeyCode = 0x82; -pub const KEY_F20: CGKeyCode = 0x83; -pub const KEY_F21: CGKeyCode = 0x84; -pub const KEY_F22: CGKeyCode = 0x85; -pub const KEY_F23: CGKeyCode = 0x86; -pub const KEY_F24: CGKeyCode = 0x87; -pub const KEY_NAVIGATION_VIEW: CGKeyCode = 0x88; -pub const KEY_NAVIGATION_MENU: CGKeyCode = 0x89; -pub const KEY_NAVIGATION_UP: CGKeyCode = 0x8A; -pub const KEY_NAVIGATION_DOWN: CGKeyCode = 0x8B; -pub const KEY_NAVIGATION_LEFT: CGKeyCode = 0x8C; -pub const KEY_NAVIGATION_RIGHT: CGKeyCode = 0x8D; -pub const KEY_NAVIGATION_ACCEPT: CGKeyCode = 0x8E; -pub const KEY_NAVIGATION_CANCEL: CGKeyCode = 0x8F; -pub const KEY_SCROLL: CGKeyCode = 0x91; -pub const KEY_OEM_NEC_EQUAL: CGKeyCode = 0x92; -pub const KEY_OEM_FJ_JISHO: CGKeyCode = 0x92; -pub const KEY_OEM_FJ_MASSHOU: CGKeyCode = 0x93; -pub const KEY_OEM_FJ_TOUROKU: CGKeyCode = 0x94; -pub const KEY_OEM_FJ_LOYA: CGKeyCode = 0x95; -pub const KEY_OEM_FJ_ROYA: CGKeyCode = 0x96; -pub const KEY_LEFTALT: CGKeyCode = 0xA4; -pub const KEY_RIGHTALT: CGKeyCode = 0xA5; -pub const KEY_BROWSER_BACK: CGKeyCode = 0xA6; -pub const KEY_BROWSER_FORWARD: CGKeyCode = 0xA7; -pub const KEY_BROWSER_REFRESH: CGKeyCode = 0xA8; -pub const KEY_BROWSER_STOP: CGKeyCode = 0xA9; -pub const KEY_BROWSER_SEARCH: CGKeyCode = 0xAA; -pub const KEY_BROWSER_FAVORITES: CGKeyCode = 0xAB; -pub const KEY_BROWSER_HOME: CGKeyCode = 0xAC; -pub const KEY_VOLUME_MUTE: CGKeyCode = 0xAD; -pub const KEY_VOLUME_DOWN: CGKeyCode = 0xAE; -pub const KEY_VOLUME_UP: CGKeyCode = 0xAF; -pub const KEY_MEDIA_NEXT_TRACK: CGKeyCode = 0xB0; -pub const KEY_MEDIA_PREV_TRACK: CGKeyCode = 0xB1; -pub const KEY_MEDIA_STOP: CGKeyCode = 0xB2; -pub const KEY_MEDIA_PLAY_PAUSE: CGKeyCode = 0xB3; -pub const KEY_LAUNCH_MAIL: CGKeyCode = 0xB4; -pub const KEY_LAUNCH_MEDIA_SELECT: CGKeyCode = 0xB5; -pub const KEY_LAUNCH_APP1: CGKeyCode = 0xB6; -pub const KEY_LAUNCH_APP2: CGKeyCode = 0xB7; -pub const KEY_SEMICOLON: CGKeyCode = 0xBA; -pub const KEY_EQUAL: CGKeyCode = 0xBB; -pub const KEY_COMMA: CGKeyCode = 0xBC; -pub const KEY_MINUS: CGKeyCode = 0xBD; -pub const KEY_DOT: CGKeyCode = 0xBE; -pub const KEY_SLASH: CGKeyCode = 0xBF; -pub const KEY_GRAVE: CGKeyCode = 0xC0; -pub const KEY_GAMEPAD_A: CGKeyCode = 0xC3; -pub const KEY_GAMEPAD_B: CGKeyCode = 0xC4; -pub const KEY_GAMEPAD_X: CGKeyCode = 0xC5; -pub const KEY_GAMEPAD_Y: CGKeyCode = 0xC6; -pub const KEY_GAMEPAD_RIGHT_SHOULDER: CGKeyCode = 0xC7; -pub const KEY_GAMEPAD_LEFT_SHOULDER: CGKeyCode = 0xC8; -pub const KEY_GAMEPAD_LEFT_TRIGGER: CGKeyCode = 0xC9; -pub const KEY_GAMEPAD_RIGHT_TRIGGER: CGKeyCode = 0xCA; -pub const KEY_GAMEPAD_DPAD_UP: CGKeyCode = 0xCB; -pub const KEY_GAMEPAD_DPAD_DOWN: CGKeyCode = 0xCC; -pub const KEY_GAMEPAD_DPAD_LEFT: CGKeyCode = 0xCD; -pub const KEY_GAMEPAD_DPAD_RIGHT: CGKeyCode = 0xCE; -pub const KEY_GAMEPAD_MENU: CGKeyCode = 0xCF; -pub const KEY_GAMEPAD_VIEW: CGKeyCode = 0xD0; -pub const KEY_GAMEPAD_LEFT_THUMBSTICK_BUTTON: CGKeyCode = 0xD1; -pub const KEY_GAMEPAD_RIGHT_THUMBSTICK_BUTTON: CGKeyCode = 0xD2; -pub const KEY_GAMEPAD_LEFT_THUMBSTICK_UP: CGKeyCode = 0xD3; -pub const KEY_GAMEPAD_LEFT_THUMBSTICK_DOWN: CGKeyCode = 0xD4; -pub const KEY_GAMEPAD_LEFT_THUMBSTICK_RIGHT: CGKeyCode = 0xD5; -pub const KEY_GAMEPAD_LEFT_THUMBSTICK_LEFT: CGKeyCode = 0xD6; -pub const KEY_GAMEPAD_RIGHT_THUMBSTICK_UP: CGKeyCode = 0xD7; -pub const KEY_GAMEPAD_RIGHT_THUMBSTICK_DOWN: CGKeyCode = 0xD8; -pub const KEY_GAMEPAD_RIGHT_THUMBSTICK_RIGHT: CGKeyCode = 0xD9; -pub const KEY_GAMEPAD_RIGHT_THUMBSTICK_LEFT: CGKeyCode = 0xDA; -pub const KEY_LEFTBRACE: CGKeyCode = 0xDB; -pub const KEY_BACKSLASH: CGKeyCode = 0xDC; -pub const KEY_RIGHTBRACE: CGKeyCode = 0xDD; -pub const KEY_APOSTROPHE: CGKeyCode = 0xDE; -pub const KEY_OEM_8: CGKeyCode = 0xDF; -pub const KEY_OEM_AX: CGKeyCode = 0xE1; -pub const KEY_OEM_102: CGKeyCode = 0xE2; -pub const KEY_ICO_HELP: CGKeyCode = 0xE3; -pub const KEY_ICO_00: CGKeyCode = 0xE4; -pub const KEY_PROCESSKEY: CGKeyCode = 0xE5; -pub const KEY_ICO_CLEAR: CGKeyCode = 0xE6; -pub const KEY_PACKET: CGKeyCode = 0xE7; -pub const KEY_OEM_RESET: CGKeyCode = 0xE9; -pub const KEY_OEM_JUMP: CGKeyCode = 0xEA; -pub const KEY_OEM_PA1: CGKeyCode = 0xEB; -pub const KEY_OEM_PA2: CGKeyCode = 0xEC; -pub const KEY_OEM_PA3: CGKeyCode = 0xED; -pub const KEY_OEM_WSCTRL: CGKeyCode = 0xEE; -pub const KEY_OEM_CUSEL: CGKeyCode = 0xEF; -pub const KEY_OEM_ATTN: CGKeyCode = 0xF0; -pub const KEY_OEM_FINISH: CGKeyCode = 0xF1; -pub const KEY_OEM_COPY: CGKeyCode = 0xF2; -pub const KEY_OEM_AUTO: CGKeyCode = 0xF3; -pub const KEY_OEM_ENLW: CGKeyCode = 0xF4; -pub const KEY_OEM_BACKTAB: CGKeyCode = 0xF5; -pub const KEY_ATTN: CGKeyCode = 0xF6; -pub const KEY_CRSEL: CGKeyCode = 0xF7; -pub const KEY_EXSEL: CGKeyCode = 0xF8; -pub const KEY_EREOF: CGKeyCode = 0xF9; -pub const KEY_PLAY: CGKeyCode = 0xFA; -pub const KEY_ZOOM: CGKeyCode = 0xFB; -pub const KEY_NONAME: CGKeyCode = 0xFC; -pub const KEY_PA1: CGKeyCode = 0xFD; -pub const KEY_OEM_CLEAR: CGKeyCode = 0xFE; +pub const KEY_RESERVED: CGKeyCode = 0x31; +pub const KEY_ESC: CGKeyCode = 0x00; +pub const KEY_1: CGKeyCode = 0x0012; +pub const KEY_2: CGKeyCode = 0x0013; +pub const KEY_3: CGKeyCode = 0x0014; +pub const KEY_4: CGKeyCode = 0x0015; +pub const KEY_5: CGKeyCode = 0x0017; +pub const KEY_6: CGKeyCode = 0x0016; +pub const KEY_7: CGKeyCode = 0x001A; +pub const KEY_8: CGKeyCode = 0x001C; +pub const KEY_9: CGKeyCode = 0x0019; +pub const KEY_10: CGKeyCode = 0x001D; +pub const KEY_MINUS: CGKeyCode = 0x001B; +pub const KEY_EQUAL: CGKeyCode = 0x0018; +pub const KEY_BACKSPACE: CGKeyCode = 0x0033; +pub const KEY_TAB: CGKeyCode = 0x0030; +pub const KEY_Q: CGKeyCode = 0x000C; +pub const KEY_W: CGKeyCode = 0x000D; +pub const KEY_E: CGKeyCode = 0x000E; +pub const KEY_R: CGKeyCode = 0x000F; +pub const KEY_T: CGKeyCode = 0x0011; +pub const KEY_Y: CGKeyCode = 0x0010; +pub const KEY_U: CGKeyCode = 0x0020; +pub const KEY_I: CGKeyCode = 0x0022; +pub const KEY_O: CGKeyCode = 0x001F; +pub const KEY_P: CGKeyCode = 0x0023; +pub const KEY_LEFTBRACE: CGKeyCode = 0x0021; +pub const KEY_RIGHTBRACE: CGKeyCode = 0x001E; +pub const KEY_ENTER: CGKeyCode = 0x0024; +pub const KEY_LEFTCTRL: CGKeyCode = 0x003B; +pub const KEY_A: CGKeyCode = 0x0000; +pub const KEY_S: CGKeyCode = 0x0001; +pub const KEY_D: CGKeyCode = 0x0002; +pub const KEY_F: CGKeyCode = 0x0003; +pub const KEY_G: CGKeyCode = 0x0005; +pub const KEY_H: CGKeyCode = 0x0004; +pub const KEY_J: CGKeyCode = 0x0026; +pub const KEY_K: CGKeyCode = 0x0028; +pub const KEY_L: CGKeyCode = 0x0025; +pub const KEY_SEMICOLON: CGKeyCode = 0x0029; +pub const KEY_APOSTROPHE: CGKeyCode = 0x0027; +pub const KEY_GRAVE: CGKeyCode = 0x0032; +pub const KEY_LEFTSHIFT: CGKeyCode = 0x0038; +pub const KEY_BACKSLASH: CGKeyCode = 0x002A; +pub const KEY_Z: CGKeyCode = 0x0006; +pub const KEY_X: CGKeyCode = 0x0007; +pub const KEY_C: CGKeyCode = 0x0008; +pub const KEY_V: CGKeyCode = 0x0009; +pub const KEY_B: CGKeyCode = 0x000B; +pub const KEY_N: CGKeyCode = 0x002D; +pub const KEY_M: CGKeyCode = 0x002E; +pub const KEY_COMMA: CGKeyCode = 0x002B; +pub const KEY_DOT: CGKeyCode = 0x002F; +pub const KEY_SLASH: CGKeyCode = 0x002C; +pub const KEY_RIGHTSHIFT: CGKeyCode = 0x003C; +pub const KEY_KPASTERISK: CGKeyCode = 0x0043; +pub const KEY_LEFTALT: CGKeyCode = 0x003A; +pub const KEY_SPACE: CGKeyCode = 0x0031; +pub const KEY_CAPSLOCK: CGKeyCode = 0x0039; +pub const KEY_F1: CGKeyCode = 0x007A; +pub const KEY_F2: CGKeyCode = 0x0078; +pub const KEY_F3: CGKeyCode = 0x0063; +pub const KEY_F4: CGKeyCode = 0x0076; +pub const KEY_F5: CGKeyCode = 0x0060; +pub const KEY_F6: CGKeyCode = 0x0061; +pub const KEY_F7: CGKeyCode = 0x0062; +pub const KEY_F8: CGKeyCode = 0x0064; +pub const KEY_F9: CGKeyCode = 0x0065; +pub const KEY_F10: CGKeyCode = 0x006D; +pub const KEY_NUMLOCK: CGKeyCode = 0x0047; +pub const KEY_SCROLLLOCK: CGKeyCode = 0x006B; +pub const KEY_KP7: CGKeyCode = 0x0059; +pub const KEY_KP8: CGKeyCode = 0x005B; +pub const KEY_KP9: CGKeyCode = 0x005C; +pub const KEY_KPMINUS: CGKeyCode = 0x004E; +pub const KEY_KP4: CGKeyCode = 0x0056; +pub const KEY_KP5: CGKeyCode = 0x0057; +pub const KEY_KP6: CGKeyCode = 0x0058; +pub const KEY_KPPLUS: CGKeyCode = 0x0045; +pub const KEY_KP1: CGKeyCode = 0x0053; +pub const KEY_KP2: CGKeyCode = 0x0054; +pub const KEY_KP3: CGKeyCode = 0x0055; +pub const KEY_KP0: CGKeyCode = 0x0052; +pub const KEY_KPDOT: CGKeyCode = 0x0041; +// pub const KEY_ZENKAKUHANKAKU: CGKeyCode = NOT_FOUND; +pub const KEY_102ND: CGKeyCode = 0x000A; +pub const KEY_F11: CGKeyCode = 0x0067; +pub const KEY_F12: CGKeyCode = 0x006F; +// pub const KEY_RO: CGKeyCode = NOT_FOUND; +// pub const KEY_KATAKANA: CGKeyCode = NOT_FOUND; +// pub const KEY_HIRAGANA: CGKeyCode = NOT_FOUND; +// pub const KEY_HENKAN: CGKeyCode = NOT_FOUND; +// pub const KEY_KATAKANAHIRAGANA: CGKeyCode = NOT_FOUND; +// pub const KEY_MUHENKAN: CGKeyCode = NOT_FOUND; +// pub const KEY_KPJPCOMMA: CGKeyCode = NOT_FOUND; +pub const KEY_KPENTER: CGKeyCode = 0x004C; +pub const KEY_RIGHTCTRL: CGKeyCode = 0x003E; +pub const KEY_KPSLASH: CGKeyCode = 0x004B; +pub const KEY_SYSRQ: CGKeyCode = 0x0069; +pub const KEY_RIGHTALT: CGKeyCode = 0x003D; +pub const KEY_LINEFEED: CGKeyCode = 0x0071; +pub const KEY_HOME: CGKeyCode = 0x0073; +pub const KEY_UP: CGKeyCode = 0x007E; +pub const KEY_PAGEUP: CGKeyCode = 0x0074; +pub const KEY_LEFT: CGKeyCode = 0x007B; +pub const KEY_RIGHT: CGKeyCode = 0x007C; +pub const KEY_END: CGKeyCode = 0x0077; +pub const KEY_DOWN: CGKeyCode = 0x007D; +pub const KEY_PAGEDOWN: CGKeyCode = 0x0079; +pub const KEY_INSERT: CGKeyCode = 0x0072; +pub const KEY_DELETE: CGKeyCode = 0x0075; +// pub const KEY_MACRO: CGKeyCode = NOT_FOUND; +// pub const KEY_MUTE: CGKeyCode = NOT_FOUND; +// pub const KEY_VOLUMEDOWN: CGKeyCode = NOT_FOUND; +// pub const KEY_VOLUMEUP: CGKeyCode = NOT_FOUND; +// pub const KEY_POWER: CGKeyCode = NOT_FOUND; +pub const KEY_KPEQUAL: CGKeyCode = 0x0069; +// pub const KEY_KPPLUSMINUS: CGKeyCode = NOT_FOUND; +// pub const KEY_PAUSE: CGKeyCode = NOT_FOUND; +pub const KEY_SCALE: CGKeyCode = 0x0047; +pub const KEY_KPCOMMA: CGKeyCode = 0x0036; +// pub const KEY_HANGEUL: CGKeyCode = NOT_FOUND; +// pub const KEY_HANGUEL: CGKeyCode = NOT_FOUND; +// pub const KEY_HANGEUL: CGKeyCode = NOT_FOUND; +// pub const KEY_HANJA: CGKeyCode = NOT_FOUND; +pub const KEY_YEN: CGKeyCode = 0x0037; +// pub const KEY_LEFTMETA: CGKeyCode = NOT_FOUND; +pub const KEY_RIGHTMETA: CGKeyCode = 0x0036; +pub const KEY_COMPOSE: CGKeyCode = 0x006E; +// pub const KEY_STOP: CGKeyCode = NOT_FOUND; +// pub const KEY_AGAIN: CGKeyCode = NOT_FOUND; +// pub const KEY_PROPS: CGKeyCode = NOT_FOUND; +// pub const KEY_UNDO: CGKeyCode = NOT_FOUND; +// pub const KEY_FRONT: CGKeyCode = NOT_FOUND; +// pub const KEY_COPY: CGKeyCode = NOT_FOUND; +// pub const KEY_OPEN: CGKeyCode = NOT_FOUND; +// pub const KEY_PASTE: CGKeyCode = NOT_FOUND; +// pub const KEY_FIND: CGKeyCode = NOT_FOUND; +// pub const KEY_CUT: CGKeyCode = NOT_FOUND; +// pub const KEY_HELP: CGKeyCode = NOT_FOUND; +// pub const KEY_MENU: CGKeyCode = NOT_FOUND; +// pub const KEY_CALC: CGKeyCode = NOT_FOUND; +// pub const KEY_SETUP: CGKeyCode = NOT_FOUND; +// pub const KEY_SLEEP: CGKeyCode = NOT_FOUND; +// pub const KEY_WAKEUP: CGKeyCode = NOT_FOUND; +// pub const KEY_FILE: CGKeyCode = NOT_FOUND; +// pub const KEY_SENDFILE: CGKeyCode = NOT_FOUND; +// pub const KEY_DELETEFILE: CGKeyCode = NOT_FOUND; +// pub const KEY_XFER: CGKeyCode = NOT_FOUND; +// pub const KEY_PROG1: CGKeyCode = NOT_FOUND; +// pub const KEY_PROG2: CGKeyCode = NOT_FOUND; +// pub const KEY_WWW: CGKeyCode = NOT_FOUND; +// pub const KEY_MSDOS: CGKeyCode = NOT_FOUND; +// pub const KEY_COFFEE: CGKeyCode = NOT_FOUND; +// pub const KEY_SCREENLOCK: CGKeyCode = NOT_FOUND; +// pub const KEY_COFFEE: CGKeyCode = NOT_FOUND; +// pub const KEY_ROTATE_DISPLAY: CGKeyCode = NOT_FOUND; +// pub const KEY_DIRECTION: CGKeyCode = NOT_FOUND; +// pub const KEY_ROTATE_DISPLAY: CGKeyCode = NOT_FOUND; +// pub const KEY_CYCLEWINDOWS: CGKeyCode = NOT_FOUND; +// pub const KEY_MAIL: CGKeyCode = NOT_FOUND; +// pub const KEY_BOOKMARKS: CGKeyCode = NOT_FOUND; +// pub const KEY_COMPUTER: CGKeyCode = NOT_FOUND; +// pub const KEY_BACK: CGKeyCode = NOT_FOUND; +// pub const KEY_FORWARD: CGKeyCode = NOT_FOUND; +// pub const KEY_CLOSECD: CGKeyCode = NOT_FOUND; +// pub const KEY_EJECTCD: CGKeyCode = NOT_FOUND; +// pub const KEY_EJECTCLOSECD: CGKeyCode = NOT_FOUND; +// pub const KEY_NEXTSONG: CGKeyCode = NOT_FOUND; +// pub const KEY_PLAYPAUSE: CGKeyCode = NOT_FOUND; +// pub const KEY_PREVIOUSSONG: CGKeyCode = NOT_FOUND; +// pub const KEY_STOPCD: CGKeyCode = NOT_FOUND; +// pub const KEY_RECORD: CGKeyCode = NOT_FOUND; +// pub const KEY_REWIND: CGKeyCode = NOT_FOUND; +// pub const KEY_PHONE: CGKeyCode = NOT_FOUND; +// pub const KEY_ISO: CGKeyCode = NOT_FOUND; +// pub const KEY_CONFIG: CGKeyCode = NOT_FOUND; +// pub const KEY_HOMEPAGE: CGKeyCode = NOT_FOUND; +// pub const KEY_REFRESH: CGKeyCode = NOT_FOUND; +// pub const KEY_EXIT: CGKeyCode = NOT_FOUND; +// pub const KEY_MOVE: CGKeyCode = NOT_FOUND; +// pub const KEY_EDIT: CGKeyCode = NOT_FOUND; +// pub const KEY_SCROLLUP: CGKeyCode = NOT_FOUND; +// pub const KEY_SCROLLDOWN: CGKeyCode = NOT_FOUND; +// pub const KEY_KPLEFTPAREN: CGKeyCode = NOT_FOUND; +// pub const KEY_KPRIGHTPAREN: CGKeyCode = NOT_FOUND; +// pub const KEY_NEW: CGKeyCode = NOT_FOUND; +// pub const KEY_REDO: CGKeyCode = NOT_FOUND; +// pub const KEY_F13: CGKeyCode = NOT_FOUND; +// pub const KEY_F14: CGKeyCode = NOT_FOUND; +// pub const KEY_F15: CGKeyCode = NOT_FOUND; +// pub const KEY_F16: CGKeyCode = NOT_FOUND; +// pub const KEY_F17: CGKeyCode = NOT_FOUND; +// pub const KEY_F18: CGKeyCode = NOT_FOUND; +// pub const KEY_F19: CGKeyCode = NOT_FOUND; +// pub const KEY_F20: CGKeyCode = NOT_FOUND; +// pub const KEY_F21: CGKeyCode = NOT_FOUND; +// pub const KEY_F22: CGKeyCode = NOT_FOUND; +// pub const KEY_F23: CGKeyCode = NOT_FOUND; +// pub const KEY_F24: CGKeyCode = NOT_FOUND; +// pub const KEY_PLAYCD: CGKeyCode = NOT_FOUND; +// pub const KEY_PAUSECD: CGKeyCode = NOT_FOUND; +// pub const KEY_PROG3: CGKeyCode = NOT_FOUND; +// pub const KEY_PROG4: CGKeyCode = NOT_FOUND; +// pub const KEY_DASHBOARD: CGKeyCode = NOT_FOUND; +// pub const KEY_SUSPEND: CGKeyCode = NOT_FOUND; +// pub const KEY_CLOSE: CGKeyCode = NOT_FOUND; +// pub const KEY_PLAY: CGKeyCode = NOT_FOUND; +// pub const KEY_FASTFORWARD: CGKeyCode = NOT_FOUND; +// pub const KEY_BASSBOOST: CGKeyCode = NOT_FOUND; +// pub const KEY_PRINT: CGKeyCode = NOT_FOUND; +// pub const KEY_HP: CGKeyCode = NOT_FOUND; +// pub const KEY_CAMERA: CGKeyCode = NOT_FOUND; +// pub const KEY_SOUND: CGKeyCode = NOT_FOUND; +// pub const KEY_QUESTION: CGKeyCode = NOT_FOUND; +// pub const KEY_EMAIL: CGKeyCode = NOT_FOUND; +// pub const KEY_CHAT: CGKeyCode = NOT_FOUND; +// pub const KEY_SEARCH: CGKeyCode = NOT_FOUND; +// pub const KEY_CONNECT: CGKeyCode = NOT_FOUND; +// pub const KEY_FINANCE: CGKeyCode = NOT_FOUND; +// pub const KEY_SPORT: CGKeyCode = NOT_FOUND; +//pub const KEY_SHOP: CGKeyCode = NOT_FOUND; +pub const KEY_ALTERASE: CGKeyCode = 0x0047; +// pub const KEY_CANCEL: CGKeyCode = NOT_FOUND; +// pub const KEY_BRIGHTNESSDOWN: CGKeyCode = NOT_FOUND; +// pub const KEY_BRIGHTNESSUP: CGKeyCode = NOT_FOUND; +// pub const KEY_MEDIA: CGKeyCode = NOT_FOUND; +// pub const KEY_SWITCHVIDEOMODE: CGKeyCode = NOT_FOUND; +// pub const KEY_KBDILLUMTOGGLE: CGKeyCode = NOT_FOUND; +// pub const KEY_KBDILLUMDOWN: CGKeyCode = NOT_FOUND; +// pub const KEY_KBDILLUMUP: CGKeyCode = NOT_FOUND; +// pub const KEY_SEND: CGKeyCode = NOT_FOUND; +// pub const KEY_REPLY: CGKeyCode = NOT_FOUND; +// pub const KEY_FORWARDMAIL: CGKeyCode = NOT_FOUND; +// pub const KEY_SAVE: CGKeyCode = NOT_FOUND; +// pub const KEY_DOCUMENTS: CGKeyCode = NOT_FOUND; +// pub const KEY_BATTERY: CGKeyCode = NOT_FOUND; +// pub const KEY_BLUETOOTH: CGKeyCode = NOT_FOUND; +// pub const KEY_UWB: CGKeyCode = NOT_FOUND; +// pub const KEY_UNKNOWN: CGKeyCode = NOT_FOUND; +// pub const KEY_VIDEO_NEXT: CGKeyCode = NOT_FOUND; +// pub const KEY_VIDEO_PREV: CGKeyCode = NOT_FOUND; +// pub const KEY_BRIGHTNESS_CYCLE: CGKeyCode = NOT_FOUND; +// pub const KEY_BRIGHTNESS_AUTO: CGKeyCode = NOT_FOUND; +// pub const KEY_BRIGHTNESS_ZERO: CGKeyCode = NOT_FOUND; +// pub const KEY_BRIGHTNESS_AUTO: CGKeyCode = NOT_FOUND; +// pub const KEY_DISPLAY_OFF: CGKeyCode = NOT_FOUND; pub fn key_map() -> HashMap<&'static str, CGKeyCode> { [ @@ -438,7 +447,6 @@ pub fn key_map() -> HashMap<&'static str, CGKeyCode> { ("KPRIGHTPAREN", KEY_KPRIGHTPAREN), ("NEW", KEY_NEW), ("REDO", KEY_REDO), - */ ("F13", KEY_F13), ("F14", KEY_F14), ("F15", KEY_F15), @@ -451,7 +459,6 @@ pub fn key_map() -> HashMap<&'static str, CGKeyCode> { ("F22", KEY_F22), ("F23", KEY_F23), ("F24", KEY_F24), - /* ("PLAYCD", KEY_PLAYCD), ("PAUSECD", KEY_PAUSECD), ("PROG3", KEY_PROG3), @@ -509,7 +516,7 @@ pub fn key_map() -> HashMap<&'static str, CGKeyCode> { // below manual shortcuts ("PSCR", KEY_SYSRQ), ("SLCK", KEY_SCROLLLOCK), - ("BRK", KEY_PAUSE), + //("BRK", KEY_PAUSE), ("GRV", KEY_GRAVE), ("0", KEY_10), // dumb or named wrong? ("MINS", KEY_MINUS), @@ -533,7 +540,7 @@ pub fn key_map() -> HashMap<&'static str, CGKeyCode> { ("RCTL", KEY_RIGHTCTRL), ("LALT", KEY_LEFTALT), ("RALT", KEY_RIGHTALT), - ("LGUI", KEY_LEFTMETA), + //("LGUI", KEY_LEFTMETA), ("RGUI", KEY_RIGHTMETA), ("INS", KEY_INSERT), ("PGUP", KEY_PAGEUP),