| // dear imgui: Platform Backend for OSX / Cocoa |
| // This needs to be used along with a Renderer (e.g. OpenGL2, OpenGL3, Vulkan, Metal..) |
| // [ALPHA] Early backend, not well tested. If you want a portable application, prefer using the GLFW or SDL platform Backends on Mac. |
| |
| // Implemented features: |
| // [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'. |
| // [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy kVK_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set] |
| // [X] Platform: OSX clipboard is supported within core Dear ImGui (no specific code in this backend). |
| // [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'. |
| // [X] Platform: IME support. |
| |
| // You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this. |
| // Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need. |
| // If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp. |
| // Read online: https://github.com/ocornut/imgui/tree/master/docs |
| |
| #import "imgui.h" |
| #import "imgui_impl_osx.h" |
| #import <Cocoa/Cocoa.h> |
| #import <mach/mach_time.h> |
| #import <Carbon/Carbon.h> |
| #import <GameController/GameController.h> |
| |
| // CHANGELOG |
| // (minor and older changes stripped away, please see git history for details) |
| // 2022-01-XX: Inputs: calling new io.AddMousePosEvent(), io.AddMouseButtonEvent(), io.AddMouseWheelEvent() API (1.87+). |
| // 2022-01-12: Inputs: Added basic Platform IME support, hooking the io.SetPlatformImeDataFn() function. |
| // 2022-01-10: Inputs: calling new io.AddKeyEvent(), io.AddKeyModsEvent() + io.SetKeyEventNativeData() API (1.87+). Support for full ImGuiKey range. |
| // 2021-12-13: *BREAKING CHANGE* Add NSView parameter to ImGui_ImplOSX_Init(). Generally fix keyboard support. Using kVK_* codes for keyboard keys. |
| // 2021-12-13: Add game controller support. |
| // 2021-09-21: Use mach_absolute_time as CFAbsoluteTimeGetCurrent can jump backwards. |
| // 2021-08-17: Calling io.AddFocusEvent() on NSApplicationDidBecomeActiveNotification/NSApplicationDidResignActiveNotification events. |
| // 2021-06-23: Inputs: Added a fix for shortcuts using CTRL key instead of CMD key. |
| // 2021-04-19: Inputs: Added a fix for keys remaining stuck in pressed state when CMD-tabbing into different application. |
| // 2021-01-27: Inputs: Added a fix for mouse position not being reported when mouse buttons other than left one are down. |
| // 2020-10-28: Inputs: Added a fix for handling keypad-enter key. |
| // 2020-05-25: Inputs: Added a fix for missing trackpad clicks when done with "soft tap". |
| // 2019-12-05: Inputs: Added support for ImGuiMouseCursor_NotAllowed mouse cursor. |
| // 2019-10-11: Inputs: Fix using Backspace key. |
| // 2019-07-21: Re-added clipboard handlers as they are not enabled by default in core imgui.cpp (reverted 2019-05-18 change). |
| // 2019-05-28: Inputs: Added mouse cursor shape and visibility support. |
| // 2019-05-18: Misc: Removed clipboard handlers as they are now supported by core imgui.cpp. |
| // 2019-05-11: Inputs: Don't filter character values before calling AddInputCharacter() apart from 0xF700..0xFFFF range. |
| // 2018-11-30: Misc: Setting up io.BackendPlatformName so it can be displayed in the About Window. |
| // 2018-07-07: Initial version. |
| |
| @class ImFocusObserver; |
| @class KeyEventResponder; |
| |
| // Data |
| static double g_HostClockPeriod = 0.0; |
| static double g_Time = 0.0; |
| static NSCursor* g_MouseCursors[ImGuiMouseCursor_COUNT] = {}; |
| static bool g_MouseCursorHidden = false; |
| static ImGuiKeyModFlags g_KeyModifiers = ImGuiKeyModFlags_None; |
| static ImFocusObserver* g_FocusObserver = nil; |
| static KeyEventResponder* g_KeyEventResponder = nil; |
| static NSTextInputContext* g_InputContext = nil; |
| |
| // Undocumented methods for creating cursors. |
| @interface NSCursor() |
| + (id)_windowResizeNorthWestSouthEastCursor; |
| + (id)_windowResizeNorthEastSouthWestCursor; |
| + (id)_windowResizeNorthSouthCursor; |
| + (id)_windowResizeEastWestCursor; |
| @end |
| |
| static void InitHostClockPeriod() |
| { |
| struct mach_timebase_info info; |
| mach_timebase_info(&info); |
| g_HostClockPeriod = 1e-9 * ((double)info.denom / (double)info.numer); // Period is the reciprocal of frequency. |
| } |
| |
| static double GetMachAbsoluteTimeInSeconds() |
| { |
| return (double)mach_absolute_time() * g_HostClockPeriod; |
| } |
| |
| /** |
| KeyEventResponder implements the NSTextInputClient protocol as is required by the macOS text input manager. |
| |
| The macOS text input manager is invoked by calling the interpretKeyEvents method from the keyDown method. |
| Keyboard events are then evaluated by the macOS input manager and valid text input is passed back via the |
| insertText:replacementRange method. |
| |
| This is the same approach employed by other cross-platform libraries such as SDL2: |
| https://github.com/spurious/SDL-mirror/blob/e17aacbd09e65a4fd1e166621e011e581fb017a8/src/video/cocoa/SDL_cocoakeyboard.m#L53 |
| and GLFW: |
| https://github.com/glfw/glfw/blob/b55a517ae0c7b5127dffa79a64f5406021bf9076/src/cocoa_window.m#L722-L723 |
| */ |
| @interface KeyEventResponder: NSView<NSTextInputClient> |
| @end |
| |
| @implementation KeyEventResponder |
| { |
| float _posX; |
| float _posY; |
| NSRect _imeRect; |
| } |
| |
| #pragma mark - Public |
| |
| - (void)setImePosX:(float)posX imePosY:(float)posY |
| { |
| _posX = posX; |
| _posY = posY; |
| } |
| |
| - (void)updateImePosWithView:(NSView *)view |
| { |
| NSWindow *window = view.window; |
| if (!window) |
| return; |
| NSRect contentRect = [window contentRectForFrameRect:window.frame]; |
| NSRect rect = NSMakeRect(_posX, contentRect.size.height - _posY, 0, 0); |
| _imeRect = [window convertRectToScreen:rect]; |
| } |
| |
| - (void)viewDidMoveToWindow |
| { |
| // Ensure self is a first responder to receive the input events. |
| [self.window makeFirstResponder:self]; |
| } |
| |
| - (void)keyDown:(NSEvent*)event |
| { |
| ImGui_ImplOSX_HandleEvent(event, self); |
| |
| // Call to the macOS input manager system. |
| [self interpretKeyEvents:@[event]]; |
| } |
| |
| - (void)keyUp:(NSEvent*)event |
| { |
| ImGui_ImplOSX_HandleEvent(event, self); |
| } |
| |
| - (void)insertText:(id)aString replacementRange:(NSRange)replacementRange |
| { |
| ImGuiIO& io = ImGui::GetIO(); |
| |
| NSString* characters; |
| if ([aString isKindOfClass:[NSAttributedString class]]) |
| characters = [aString string]; |
| else |
| characters = (NSString*)aString; |
| |
| io.AddInputCharactersUTF8(characters.UTF8String); |
| } |
| |
| - (BOOL)acceptsFirstResponder |
| { |
| return YES; |
| } |
| |
| - (void)doCommandBySelector:(SEL)myselector |
| { |
| } |
| |
| - (nullable NSAttributedString*)attributedSubstringForProposedRange:(NSRange)range actualRange:(nullable NSRangePointer)actualRange |
| { |
| return nil; |
| } |
| |
| - (NSUInteger)characterIndexForPoint:(NSPoint)point |
| { |
| return 0; |
| } |
| |
| - (NSRect)firstRectForCharacterRange:(NSRange)range actualRange:(nullable NSRangePointer)actualRange |
| { |
| return _imeRect; |
| } |
| |
| - (BOOL)hasMarkedText |
| { |
| return NO; |
| } |
| |
| - (NSRange)markedRange |
| { |
| return NSMakeRange(NSNotFound, 0); |
| } |
| |
| - (NSRange)selectedRange |
| { |
| return NSMakeRange(NSNotFound, 0); |
| } |
| |
| - (void)setMarkedText:(nonnull id)string selectedRange:(NSRange)selectedRange replacementRange:(NSRange)replacementRange |
| { |
| } |
| |
| - (void)unmarkText |
| { |
| } |
| |
| - (nonnull NSArray<NSAttributedStringKey>*)validAttributesForMarkedText |
| { |
| return @[]; |
| } |
| |
| @end |
| |
| @interface ImFocusObserver : NSObject |
| |
| - (void)onApplicationBecomeActive:(NSNotification*)aNotification; |
| - (void)onApplicationBecomeInactive:(NSNotification*)aNotification; |
| |
| @end |
| |
| @implementation ImFocusObserver |
| |
| - (void)onApplicationBecomeActive:(NSNotification*)aNotification |
| { |
| ImGuiIO& io = ImGui::GetIO(); |
| io.AddFocusEvent(true); |
| } |
| |
| - (void)onApplicationBecomeInactive:(NSNotification*)aNotification |
| { |
| ImGuiIO& io = ImGui::GetIO(); |
| io.AddFocusEvent(false); |
| } |
| |
| @end |
| |
| // Functions |
| static ImGuiKey ImGui_ImplOSX_KeyCodeToImGuiKey(int key_code) |
| { |
| switch (key_code) |
| { |
| case kVK_ANSI_A: return ImGuiKey_A; |
| case kVK_ANSI_S: return ImGuiKey_S; |
| case kVK_ANSI_D: return ImGuiKey_D; |
| case kVK_ANSI_F: return ImGuiKey_F; |
| case kVK_ANSI_H: return ImGuiKey_H; |
| case kVK_ANSI_G: return ImGuiKey_G; |
| case kVK_ANSI_Z: return ImGuiKey_Z; |
| case kVK_ANSI_X: return ImGuiKey_X; |
| case kVK_ANSI_C: return ImGuiKey_C; |
| case kVK_ANSI_V: return ImGuiKey_V; |
| case kVK_ANSI_B: return ImGuiKey_B; |
| case kVK_ANSI_Q: return ImGuiKey_Q; |
| case kVK_ANSI_W: return ImGuiKey_W; |
| case kVK_ANSI_E: return ImGuiKey_E; |
| case kVK_ANSI_R: return ImGuiKey_R; |
| case kVK_ANSI_Y: return ImGuiKey_Y; |
| case kVK_ANSI_T: return ImGuiKey_T; |
| case kVK_ANSI_1: return ImGuiKey_1; |
| case kVK_ANSI_2: return ImGuiKey_2; |
| case kVK_ANSI_3: return ImGuiKey_3; |
| case kVK_ANSI_4: return ImGuiKey_4; |
| case kVK_ANSI_6: return ImGuiKey_6; |
| case kVK_ANSI_5: return ImGuiKey_5; |
| case kVK_ANSI_Equal: return ImGuiKey_Equal; |
| case kVK_ANSI_9: return ImGuiKey_9; |
| case kVK_ANSI_7: return ImGuiKey_7; |
| case kVK_ANSI_Minus: return ImGuiKey_Minus; |
| case kVK_ANSI_8: return ImGuiKey_8; |
| case kVK_ANSI_0: return ImGuiKey_0; |
| case kVK_ANSI_RightBracket: return ImGuiKey_RightBracket; |
| case kVK_ANSI_O: return ImGuiKey_O; |
| case kVK_ANSI_U: return ImGuiKey_U; |
| case kVK_ANSI_LeftBracket: return ImGuiKey_LeftBracket; |
| case kVK_ANSI_I: return ImGuiKey_I; |
| case kVK_ANSI_P: return ImGuiKey_P; |
| case kVK_ANSI_L: return ImGuiKey_L; |
| case kVK_ANSI_J: return ImGuiKey_J; |
| case kVK_ANSI_Quote: return ImGuiKey_Apostrophe; |
| case kVK_ANSI_K: return ImGuiKey_K; |
| case kVK_ANSI_Semicolon: return ImGuiKey_Semicolon; |
| case kVK_ANSI_Backslash: return ImGuiKey_Backslash; |
| case kVK_ANSI_Comma: return ImGuiKey_Comma; |
| case kVK_ANSI_Slash: return ImGuiKey_Slash; |
| case kVK_ANSI_N: return ImGuiKey_N; |
| case kVK_ANSI_M: return ImGuiKey_M; |
| case kVK_ANSI_Period: return ImGuiKey_Period; |
| case kVK_ANSI_Grave: return ImGuiKey_GraveAccent; |
| case kVK_ANSI_KeypadDecimal: return ImGuiKey_KeypadDecimal; |
| case kVK_ANSI_KeypadMultiply: return ImGuiKey_KeypadMultiply; |
| case kVK_ANSI_KeypadPlus: return ImGuiKey_KeypadAdd; |
| case kVK_ANSI_KeypadClear: return ImGuiKey_NumLock; |
| case kVK_ANSI_KeypadDivide: return ImGuiKey_KeypadDivide; |
| case kVK_ANSI_KeypadEnter: return ImGuiKey_KeypadEnter; |
| case kVK_ANSI_KeypadMinus: return ImGuiKey_KeypadSubtract; |
| case kVK_ANSI_KeypadEquals: return ImGuiKey_KeypadEqual; |
| case kVK_ANSI_Keypad0: return ImGuiKey_Keypad0; |
| case kVK_ANSI_Keypad1: return ImGuiKey_Keypad1; |
| case kVK_ANSI_Keypad2: return ImGuiKey_Keypad2; |
| case kVK_ANSI_Keypad3: return ImGuiKey_Keypad3; |
| case kVK_ANSI_Keypad4: return ImGuiKey_Keypad4; |
| case kVK_ANSI_Keypad5: return ImGuiKey_Keypad5; |
| case kVK_ANSI_Keypad6: return ImGuiKey_Keypad6; |
| case kVK_ANSI_Keypad7: return ImGuiKey_Keypad7; |
| case kVK_ANSI_Keypad8: return ImGuiKey_Keypad8; |
| case kVK_ANSI_Keypad9: return ImGuiKey_Keypad9; |
| case kVK_Return: return ImGuiKey_Enter; |
| case kVK_Tab: return ImGuiKey_Tab; |
| case kVK_Space: return ImGuiKey_Space; |
| case kVK_Delete: return ImGuiKey_Backspace; |
| case kVK_Escape: return ImGuiKey_Escape; |
| case kVK_Command: return ImGuiKey_LeftSuper; |
| case kVK_Shift: return ImGuiKey_LeftShift; |
| case kVK_CapsLock: return ImGuiKey_CapsLock; |
| case kVK_Option: return ImGuiKey_LeftAlt; |
| case kVK_Control: return ImGuiKey_LeftControl; |
| case kVK_RightCommand: return ImGuiKey_RightSuper; |
| case kVK_RightShift: return ImGuiKey_RightShift; |
| case kVK_RightOption: return ImGuiKey_RightAlt; |
| case kVK_RightControl: return ImGuiKey_RightControl; |
| // case kVK_Function: return ImGuiKey_; |
| // case kVK_F17: return ImGuiKey_; |
| // case kVK_VolumeUp: return ImGuiKey_; |
| // case kVK_VolumeDown: return ImGuiKey_; |
| // case kVK_Mute: return ImGuiKey_; |
| // case kVK_F18: return ImGuiKey_; |
| // case kVK_F19: return ImGuiKey_; |
| // case kVK_F20: return ImGuiKey_; |
| case kVK_F5: return ImGuiKey_F5; |
| case kVK_F6: return ImGuiKey_F6; |
| case kVK_F7: return ImGuiKey_F7; |
| case kVK_F3: return ImGuiKey_F3; |
| case kVK_F8: return ImGuiKey_F8; |
| case kVK_F9: return ImGuiKey_F9; |
| case kVK_F11: return ImGuiKey_F11; |
| case kVK_F13: return ImGuiKey_PrintScreen; |
| // case kVK_F16: return ImGuiKey_; |
| // case kVK_F14: return ImGuiKey_; |
| case kVK_F10: return ImGuiKey_F10; |
| case 0x6E: return ImGuiKey_Menu; |
| case kVK_F12: return ImGuiKey_F12; |
| // case kVK_F15: return ImGuiKey_; |
| case kVK_Help: return ImGuiKey_Insert; |
| case kVK_Home: return ImGuiKey_Home; |
| case kVK_PageUp: return ImGuiKey_PageUp; |
| case kVK_ForwardDelete: return ImGuiKey_Delete; |
| case kVK_F4: return ImGuiKey_F4; |
| case kVK_End: return ImGuiKey_End; |
| case kVK_F2: return ImGuiKey_F2; |
| case kVK_PageDown: return ImGuiKey_PageDown; |
| case kVK_F1: return ImGuiKey_F1; |
| case kVK_LeftArrow: return ImGuiKey_LeftArrow; |
| case kVK_RightArrow: return ImGuiKey_RightArrow; |
| case kVK_DownArrow: return ImGuiKey_DownArrow; |
| case kVK_UpArrow: return ImGuiKey_UpArrow; |
| default: return ImGuiKey_None; |
| } |
| } |
| |
| |
| bool ImGui_ImplOSX_Init(NSView* view) |
| { |
| ImGuiIO& io = ImGui::GetIO(); |
| |
| // Setup backend capabilities flags |
| io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional) |
| //io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used) |
| //io.BackendFlags |= ImGuiBackendFlags_PlatformHasViewports; // We can create multi-viewports on the Platform side (optional) |
| //io.BackendFlags |= ImGuiBackendFlags_HasMouseHoveredViewport; // We can set io.MouseHoveredViewport correctly (optional, not easy) |
| io.BackendPlatformName = "imgui_impl_osx"; |
| |
| // Load cursors. Some of them are undocumented. |
| g_MouseCursorHidden = false; |
| g_MouseCursors[ImGuiMouseCursor_Arrow] = [NSCursor arrowCursor]; |
| g_MouseCursors[ImGuiMouseCursor_TextInput] = [NSCursor IBeamCursor]; |
| g_MouseCursors[ImGuiMouseCursor_ResizeAll] = [NSCursor closedHandCursor]; |
| g_MouseCursors[ImGuiMouseCursor_Hand] = [NSCursor pointingHandCursor]; |
| g_MouseCursors[ImGuiMouseCursor_NotAllowed] = [NSCursor operationNotAllowedCursor]; |
| g_MouseCursors[ImGuiMouseCursor_ResizeNS] = [NSCursor respondsToSelector:@selector(_windowResizeNorthSouthCursor)] ? [NSCursor _windowResizeNorthSouthCursor] : [NSCursor resizeUpDownCursor]; |
| g_MouseCursors[ImGuiMouseCursor_ResizeEW] = [NSCursor respondsToSelector:@selector(_windowResizeEastWestCursor)] ? [NSCursor _windowResizeEastWestCursor] : [NSCursor resizeLeftRightCursor]; |
| g_MouseCursors[ImGuiMouseCursor_ResizeNESW] = [NSCursor respondsToSelector:@selector(_windowResizeNorthEastSouthWestCursor)] ? [NSCursor _windowResizeNorthEastSouthWestCursor] : [NSCursor closedHandCursor]; |
| g_MouseCursors[ImGuiMouseCursor_ResizeNWSE] = [NSCursor respondsToSelector:@selector(_windowResizeNorthWestSouthEastCursor)] ? [NSCursor _windowResizeNorthWestSouthEastCursor] : [NSCursor closedHandCursor]; |
| |
| // Note that imgui.cpp also include default OSX clipboard handlers which can be enabled |
| // by adding '#define IMGUI_ENABLE_OSX_DEFAULT_CLIPBOARD_FUNCTIONS' in imconfig.h and adding '-framework ApplicationServices' to your linker command-line. |
| // Since we are already in ObjC land here, it is easy for us to add a clipboard handler using the NSPasteboard api. |
| io.SetClipboardTextFn = [](void*, const char* str) -> void |
| { |
| NSPasteboard* pasteboard = [NSPasteboard generalPasteboard]; |
| [pasteboard declareTypes:[NSArray arrayWithObject:NSPasteboardTypeString] owner:nil]; |
| [pasteboard setString:[NSString stringWithUTF8String:str] forType:NSPasteboardTypeString]; |
| }; |
| |
| io.GetClipboardTextFn = [](void*) -> const char* |
| { |
| NSPasteboard* pasteboard = [NSPasteboard generalPasteboard]; |
| NSString* available = [pasteboard availableTypeFromArray: [NSArray arrayWithObject:NSPasteboardTypeString]]; |
| if (![available isEqualToString:NSPasteboardTypeString]) |
| return NULL; |
| |
| NSString* string = [pasteboard stringForType:NSPasteboardTypeString]; |
| if (string == nil) |
| return NULL; |
| |
| const char* string_c = (const char*)[string UTF8String]; |
| size_t string_len = strlen(string_c); |
| static ImVector<char> s_clipboard; |
| s_clipboard.resize((int)string_len + 1); |
| strcpy(s_clipboard.Data, string_c); |
| return s_clipboard.Data; |
| }; |
| |
| g_FocusObserver = [[ImFocusObserver alloc] init]; |
| [[NSNotificationCenter defaultCenter] addObserver:g_FocusObserver |
| selector:@selector(onApplicationBecomeActive:) |
| name:NSApplicationDidBecomeActiveNotification |
| object:nil]; |
| [[NSNotificationCenter defaultCenter] addObserver:g_FocusObserver |
| selector:@selector(onApplicationBecomeInactive:) |
| name:NSApplicationDidResignActiveNotification |
| object:nil]; |
| |
| // Add the NSTextInputClient to the view hierarchy, |
| // to receive keyboard events and translate them to input text. |
| g_KeyEventResponder = [[KeyEventResponder alloc] initWithFrame:NSZeroRect]; |
| g_InputContext = [[NSTextInputContext alloc] initWithClient:g_KeyEventResponder]; |
| [view addSubview:g_KeyEventResponder]; |
| |
| // Some events do not raise callbacks of AppView in some circumstances (for example when CMD key is held down). |
| // This monitor taps into global event stream and captures these events. |
| NSEventMask eventMask = NSEventMaskFlagsChanged; |
| [NSEvent addLocalMonitorForEventsMatchingMask:eventMask handler:^NSEvent * _Nullable(NSEvent *event) |
| { |
| ImGui_ImplOSX_HandleEvent(event, g_KeyEventResponder); |
| return event; |
| }]; |
| |
| io.SetPlatformImeDataFn = [](ImGuiViewport* viewport, ImGuiPlatformImeData* data) -> void |
| { |
| if (data->WantVisible) |
| { |
| [g_InputContext activate]; |
| } |
| else |
| { |
| [g_InputContext discardMarkedText]; |
| [g_InputContext invalidateCharacterCoordinates]; |
| [g_InputContext deactivate]; |
| } |
| [g_KeyEventResponder setImePosX:data->InputPos.x imePosY:data->InputPos.y + data->InputLineHeight]; |
| }; |
| |
| return true; |
| } |
| |
| void ImGui_ImplOSX_Shutdown() |
| { |
| g_FocusObserver = NULL; |
| } |
| |
| static void ImGui_ImplOSX_UpdateMouseCursor() |
| { |
| ImGuiIO& io = ImGui::GetIO(); |
| if (io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange) |
| return; |
| |
| ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor(); |
| if (io.MouseDrawCursor || imgui_cursor == ImGuiMouseCursor_None) |
| { |
| // Hide OS mouse cursor if imgui is drawing it or if it wants no cursor |
| if (!g_MouseCursorHidden) |
| { |
| g_MouseCursorHidden = true; |
| [NSCursor hide]; |
| } |
| } |
| else |
| { |
| NSCursor* desired = g_MouseCursors[imgui_cursor] ?: g_MouseCursors[ImGuiMouseCursor_Arrow]; |
| // -[NSCursor set] generates measureable overhead if called unconditionally. |
| if (desired != NSCursor.currentCursor) |
| { |
| [desired set]; |
| } |
| if (g_MouseCursorHidden) |
| { |
| g_MouseCursorHidden = false; |
| [NSCursor unhide]; |
| } |
| } |
| } |
| |
| static void ImGui_ImplOSX_UpdateGamepads() |
| { |
| ImGuiIO& io = ImGui::GetIO(); |
| memset(io.NavInputs, 0, sizeof(io.NavInputs)); |
| if ((io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) == 0) |
| return; |
| |
| GCController* controller; |
| if (@available(macOS 11.0, *)) |
| controller = GCController.current; |
| else |
| controller = GCController.controllers.firstObject; |
| |
| if (controller == nil || controller.extendedGamepad == nil) |
| { |
| io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad; |
| return; |
| } |
| |
| GCExtendedGamepad* gp = controller.extendedGamepad; |
| |
| #define MAP_BUTTON(NAV_NO, NAME) { io.NavInputs[NAV_NO] = gp.NAME.isPressed ? 1.0 : 0.0; } |
| MAP_BUTTON(ImGuiNavInput_Activate, buttonA); |
| MAP_BUTTON(ImGuiNavInput_Cancel, buttonB); |
| MAP_BUTTON(ImGuiNavInput_Menu, buttonX); |
| MAP_BUTTON(ImGuiNavInput_Input, buttonY); |
| MAP_BUTTON(ImGuiNavInput_DpadLeft, dpad.left); |
| MAP_BUTTON(ImGuiNavInput_DpadRight, dpad.right); |
| MAP_BUTTON(ImGuiNavInput_DpadUp, dpad.up); |
| MAP_BUTTON(ImGuiNavInput_DpadDown, dpad.down); |
| MAP_BUTTON(ImGuiNavInput_FocusPrev, leftShoulder); |
| MAP_BUTTON(ImGuiNavInput_FocusNext, rightShoulder); |
| MAP_BUTTON(ImGuiNavInput_TweakSlow, leftTrigger); |
| MAP_BUTTON(ImGuiNavInput_TweakFast, rightTrigger); |
| #undef MAP_BUTTON |
| |
| io.NavInputs[ImGuiNavInput_LStickLeft] = gp.leftThumbstick.left.value; |
| io.NavInputs[ImGuiNavInput_LStickRight] = gp.leftThumbstick.right.value; |
| io.NavInputs[ImGuiNavInput_LStickUp] = gp.leftThumbstick.up.value; |
| io.NavInputs[ImGuiNavInput_LStickDown] = gp.leftThumbstick.down.value; |
| |
| io.BackendFlags |= ImGuiBackendFlags_HasGamepad; |
| } |
| |
| static void ImGui_ImplOSX_UpdateKeyModifiers() |
| { |
| ImGuiIO& io = ImGui::GetIO(); |
| io.AddKeyModsEvent(g_KeyModifiers); |
| } |
| |
| static void ImGui_ImplOSX_UpdateImePosWithView(NSView* view) |
| { |
| ImGuiIO& io = ImGui::GetIO(); |
| if (io.WantTextInput) |
| [g_KeyEventResponder updateImePosWithView:view]; |
| } |
| |
| void ImGui_ImplOSX_NewFrame(NSView* view) |
| { |
| // Setup display size |
| ImGuiIO& io = ImGui::GetIO(); |
| if (view) |
| { |
| const float dpi = (float)[view.window backingScaleFactor]; |
| io.DisplaySize = ImVec2((float)view.bounds.size.width, (float)view.bounds.size.height); |
| io.DisplayFramebufferScale = ImVec2(dpi, dpi); |
| } |
| |
| // Setup time step |
| if (g_Time == 0.0) |
| { |
| InitHostClockPeriod(); |
| g_Time = GetMachAbsoluteTimeInSeconds(); |
| } |
| double current_time = GetMachAbsoluteTimeInSeconds(); |
| io.DeltaTime = (float)(current_time - g_Time); |
| g_Time = current_time; |
| |
| ImGui_ImplOSX_UpdateKeyModifiers(); |
| ImGui_ImplOSX_UpdateMouseCursor(); |
| ImGui_ImplOSX_UpdateGamepads(); |
| ImGui_ImplOSX_UpdateImePosWithView(view); |
| } |
| |
| bool ImGui_ImplOSX_HandleEvent(NSEvent* event, NSView* view) |
| { |
| ImGuiIO& io = ImGui::GetIO(); |
| |
| if (event.type == NSEventTypeLeftMouseDown || event.type == NSEventTypeRightMouseDown || event.type == NSEventTypeOtherMouseDown) |
| { |
| int button = (int)[event buttonNumber]; |
| if (button >= 0 && button < ImGuiMouseButton_COUNT) |
| io.AddMouseButtonEvent(button, true); |
| return io.WantCaptureMouse; |
| } |
| |
| if (event.type == NSEventTypeLeftMouseUp || event.type == NSEventTypeRightMouseUp || event.type == NSEventTypeOtherMouseUp) |
| { |
| int button = (int)[event buttonNumber]; |
| if (button >= 0 && button < ImGuiMouseButton_COUNT) |
| io.AddMouseButtonEvent(button, false); |
| return io.WantCaptureMouse; |
| } |
| |
| if (event.type == NSEventTypeMouseMoved || event.type == NSEventTypeLeftMouseDragged || event.type == NSEventTypeRightMouseDragged || event.type == NSEventTypeOtherMouseDragged) |
| { |
| NSPoint mousePoint = event.locationInWindow; |
| mousePoint = [view convertPoint:mousePoint fromView:nil]; |
| mousePoint = NSMakePoint(mousePoint.x, view.bounds.size.height - mousePoint.y); |
| io.AddMousePosEvent((float)mousePoint.x, (float)mousePoint.y); |
| } |
| |
| if (event.type == NSEventTypeScrollWheel) |
| { |
| // Ignore canceled events. |
| // |
| // From macOS 12.1, scrolling with two fingers and then decelerating |
| // by tapping two fingers results in two events appearing: |
| // |
| // 1. A scroll wheel NSEvent, with a phase == NSEventPhaseMayBegin, when the user taps |
| // two fingers to decelerate or stop the scroll events. |
| // |
| // 2. A scroll wheel NSEvent, with a phase == NSEventPhaseCancelled, when the user releases the |
| // two-finger tap. It is this event that sometimes contains large values for scrollingDeltaX and |
| // scrollingDeltaY. When these are added to the current x and y positions of the scrolling view, |
| // it appears to jump up or down. It can be observed in Preview, various JetBrains IDEs and here. |
| if (event.phase == NSEventPhaseCancelled) |
| return false; |
| |
| double wheel_dx = 0.0; |
| double wheel_dy = 0.0; |
| |
| #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070 |
| if (floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_6) |
| { |
| wheel_dx = [event scrollingDeltaX]; |
| wheel_dy = [event scrollingDeltaY]; |
| if ([event hasPreciseScrollingDeltas]) |
| { |
| wheel_dx *= 0.1; |
| wheel_dy *= 0.1; |
| } |
| } |
| else |
| #endif // MAC_OS_X_VERSION_MAX_ALLOWED |
| { |
| wheel_dx = [event deltaX]; |
| wheel_dy = [event deltaY]; |
| } |
| if (wheel_dx != 0.0 || wheel_dx != 0.0) |
| io.AddMouseWheelEvent((float)wheel_dx * 0.1f, (float)wheel_dy * 0.1f); |
| |
| return io.WantCaptureMouse; |
| } |
| |
| if (event.type == NSEventTypeKeyDown || event.type == NSEventTypeKeyUp) |
| { |
| if ([event isARepeat]) |
| return io.WantCaptureKeyboard; |
| |
| int key_code = (int)[event keyCode]; |
| ImGuiKey key = ImGui_ImplOSX_KeyCodeToImGuiKey(key_code); |
| io.AddKeyEvent(key, event.type == NSEventTypeKeyDown); |
| io.SetKeyEventNativeData(key, key_code, -1); // To support legacy indexing (<1.87 user code) |
| |
| return io.WantCaptureKeyboard; |
| } |
| |
| if (event.type == NSEventTypeFlagsChanged) |
| { |
| unsigned short key_code = [event keyCode]; |
| unsigned int flags = [event modifierFlags] & NSEventModifierFlagDeviceIndependentFlagsMask; |
| |
| ImGuiKeyModFlags imgui_flags = ImGuiKeyModFlags_None; |
| if (flags & NSEventModifierFlagShift) |
| imgui_flags |= ImGuiKeyModFlags_Shift; |
| if (flags & NSEventModifierFlagControl) |
| imgui_flags |= ImGuiKeyModFlags_Ctrl; |
| if (flags & NSEventModifierFlagOption) |
| imgui_flags |= ImGuiKeyModFlags_Alt; |
| if (flags & NSEventModifierFlagCommand) |
| imgui_flags |= ImGuiKeyModFlags_Super; |
| |
| g_KeyModifiers = imgui_flags; |
| |
| ImGuiKey key = ImGui_ImplOSX_KeyCodeToImGuiKey(key_code); |
| if (key != ImGuiKey_None) |
| { |
| // macOS does not generate down/up event for modifiers. We're trying |
| // to use hardware dependent masks to extract that information. |
| // 'imgui_mask' is left as a fallback. |
| NSEventModifierFlags mask = 0; |
| ImGuiKeyModFlags imgui_mask = ImGuiKeyModFlags_None; |
| switch (key_code) |
| { |
| case kVK_Control: mask = 0x0001; imgui_mask = ImGuiKeyModFlags_Ctrl; break; |
| case kVK_RightControl: mask = 0x2000; imgui_mask = ImGuiKeyModFlags_Ctrl; break; |
| case kVK_Shift: mask = 0x0002; imgui_mask = ImGuiKeyModFlags_Shift; break; |
| case kVK_RightShift: mask = 0x0004; imgui_mask = ImGuiKeyModFlags_Shift; break; |
| case kVK_Command: mask = 0x0008; imgui_mask = ImGuiKeyModFlags_Super; break; |
| case kVK_RightCommand: mask = 0x0010; imgui_mask = ImGuiKeyModFlags_Super; break; |
| case kVK_Option: mask = 0x0020; imgui_mask = ImGuiKeyModFlags_Alt; break; |
| case kVK_RightOption: mask = 0x0040; imgui_mask = ImGuiKeyModFlags_Alt; break; |
| } |
| |
| if (mask) |
| { |
| NSEventModifierFlags modifier_flags = [event modifierFlags]; |
| io.AddKeyEvent(key, (modifier_flags & mask) != 0); |
| } |
| else if (imgui_mask) |
| { |
| io.AddKeyEvent(key, (imgui_flags & imgui_mask) != 0); |
| } |
| io.SetKeyEventNativeData(key, key_code, -1); // To support legacy indexing (<1.87 user code) |
| } |
| |
| return io.WantCaptureKeyboard; |
| } |
| |
| return false; |
| } |
