SDL/src/video/cocoa/SDL_cocoawindow.m at SDL2 · kyuur/SDL

Repository navigation

  Simple DirectMedia Layer
  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.
  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:
  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
#include "../../SDL_internal.h"
#ifdef SDL_VIDEO_DRIVER_COCOA
#if MAC_OS_X_VERSION_MAX_ALLOWED < 1070
# error SDL for Mac OS X must be built with a 10.7 SDK or above.
#endif /* MAC_OS_X_VERSION_MAX_ALLOWED < 1070 */
#include "SDL_syswm.h"
#include "SDL_timer.h"  /* For SDL_GetTicks() */
#include "SDL_hints.h"
#include "../SDL_sysvideo.h"
#include "../../events/SDL_keyboard_c.h"
#include "../../events/SDL_mouse_c.h"
#include "../../events/SDL_touch_c.h"
#include "../../events/SDL_windowevents_c.h"
#include "../../events/SDL_dropevents_c.h"
#include "SDL_cocoavideo.h"
#include "SDL_cocoashape.h"
#include "SDL_cocoamouse.h"
#include "SDL_cocoaopengl.h"
#include "SDL_cocoaopengles.h"
/* #define DEBUG_COCOAWINDOW */
#ifdef DEBUG_COCOAWINDOW
#define DLog(fmt, ...) printf("%s: " fmt "\n", __func__, ##__VA_ARGS__)
#define DLog(...) do { } while (0)
#define FULLSCREEN_MASK (SDL_WINDOW_FULLSCREEN_DESKTOP | SDL_WINDOW_FULLSCREEN)
#ifndef MAC_OS_X_VERSION_10_12
#define NSEventModifierFlagCapsLock NSAlphaShiftKeyMask
#ifndef NSAppKitVersionNumber10_13_2
#define NSAppKitVersionNumber10_13_2    1561.2
#ifndef NSAppKitVersionNumber10_14
#define NSAppKitVersionNumber10_14      1671
@implementation SDL_WindowData
@interface NSWindow (SDL)
#if MAC_OS_X_VERSION_MAX_ALLOWED < 101000 /* Added in the 10.10 SDK */
@property (readonly) NSRect contentLayoutRect;
/* This is available as of 10.13.2, but isn't in public headers */
@property (nonatomic) NSRect mouseConfinementRect;
@interface SDLWindow : NSWindow <NSDraggingDestination>
/* These are needed for borderless/fullscreen windows */
- (BOOL)canBecomeKeyWindow;
- (BOOL)canBecomeMainWindow;
- (void)sendEvent:(NSEvent *)event;
- (void)doCommandBySelector:(SEL)aSelector;
/* Handle drag-and-drop of files onto the SDL window. */
- (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender;
- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender;
- (BOOL)wantsPeriodicDraggingUpdates;
- (BOOL)validateMenuItem:(NSMenuItem *)menuItem;
- (SDL_Window*)findSDLWindow;
@implementation SDLWindow
- (BOOL)validateMenuItem:(NSMenuItem *)menuItem
    /* Only allow using the macOS native fullscreen toggle menubar item if the
     * window is resizable and not in a SDL fullscreen mode.
    if ([menuItem action] == @selector(toggleFullScreen:)) {
        SDL_Window *window = [self findSDLWindow];
        if (window == NULL) {
            return NO;
        } else if (window->flags & (SDL_WINDOW_FULLSCREEN|SDL_WINDOW_FULLSCREEN_DESKTOP)) {
            return NO;
        } else if ((window->flags & SDL_WINDOW_RESIZABLE) == 0) {
            return NO;
    return [super validateMenuItem:menuItem];
- (BOOL)canBecomeKeyWindow
    return YES;
- (BOOL)canBecomeMainWindow
    return YES;
- (void)sendEvent:(NSEvent *)event
    id delegate;
    [super sendEvent:event];
    if ([event type] != NSEventTypeLeftMouseUp) {
        return;
    delegate = [self delegate];
    if (![delegate isKindOfClass:[Cocoa_WindowListener class]]) {
        return;
    if ([delegate isMoving]) {
        [delegate windowDidFinishMoving];
/* We'll respond to selectors by doing nothing so we don't beep.
 * The escape key gets converted to a "cancel" selector, etc.
- (void)doCommandBySelector:(SEL)aSelector
    /*NSLog(@"doCommandBySelector: %@\n", NSStringFromSelector(aSelector));*/
- (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
    if (([sender draggingSourceOperationMask] & NSDragOperationGeneric) == NSDragOperationGeneric) {
        return NSDragOperationGeneric;
    return NSDragOperationNone; /* no idea what to do with this, reject it. */
- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
{ @autoreleasepool
    NSPasteboard *pasteboard = [sender draggingPasteboard];
    NSArray *types = [NSArray arrayWithObject:NSFilenamesPboardType];
    NSString *desiredType = [pasteboard availableTypeFromArray:types];
    SDL_Window *sdlwindow = [self findSDLWindow];
    NSData *data;
    NSArray *array;
    NSPoint point;
    SDL_Mouse *mouse;
    int x, y;
    if (desiredType == nil) {
        return NO;  /* can't accept anything that's being dropped here. */
    data = [pasteboard dataForType:desiredType];
    if (data == nil) {
        return NO;
    SDL_assert([desiredType isEqualToString:NSFilenamesPboardType]);
    array = [pasteboard propertyListForType:@"NSFilenamesPboardType"];
    /* Code addon to update the mouse location */
    point = [sender draggingLocation];
    mouse = SDL_GetMouse();
    x = (int)point.x;
    y = (int)(sdlwindow->h - point.y);
    if (x >= 0 && x < sdlwindow->w && y >= 0 && y < sdlwindow->h) {
        SDL_SendMouseMotion(sdlwindow, mouse->mouseID, 0, x, y);
    /* Code addon to update the mouse location */
    for (NSString *path in array) {
        NSURL *fileURL = [NSURL fileURLWithPath:path];
        NSNumber *isAlias = nil;
        [fileURL getResourceValue:&isAlias forKey:NSURLIsAliasFileKey error:nil];
        /* If the URL is an alias, resolve it. */
        if ([isAlias boolValue]) {
            NSURLBookmarkResolutionOptions opts = NSURLBookmarkResolutionWithoutMounting | NSURLBookmarkResolutionWithoutUI;
            NSData *bookmark = [NSURL bookmarkDataWithContentsOfURL:fileURL error:nil];
            if (bookmark != nil) {
                NSURL *resolvedURL = [NSURL URLByResolvingBookmarkData:bookmark
                                                         relativeToURL:nil
                                                   bookmarkDataIsStale:nil
                if (resolvedURL != nil) {
                    fileURL = resolvedURL;
        if (!SDL_SendDropFile(sdlwindow, [[fileURL path] UTF8String])) {
            return NO;
    SDL_SendDropComplete(sdlwindow);
    return YES;
- (BOOL)wantsPeriodicDraggingUpdates
    return NO;
- (SDL_Window*)findSDLWindow
    SDL_Window *sdlwindow = NULL;
    SDL_VideoDevice *_this = SDL_GetVideoDevice();
    /* !!! FIXME: is there a better way to do this? */
    if (_this) {
        for (sdlwindow = _this->windows; sdlwindow; sdlwindow = sdlwindow->next) {
            NSWindow *nswindow = ((__bridge SDL_WindowData *) sdlwindow->driverdata).nswindow;
            if (nswindow == self) {
                break;
    return sdlwindow;
static Uint32 s_moveHack;
static void ConvertNSRect(NSScreen *screen, BOOL fullscreen, NSRect *r)
    r->origin.y = CGDisplayPixelsHigh(kCGDirectMainDisplay) - r->origin.y - r->size.height;
static void ScheduleContextUpdates(SDL_WindowData *data)
    /* We still support OpenGL as long as Apple offers it, deprecated or not, so disable deprecation warnings about it. */
    #ifdef SDL_VIDEO_OPENGL

10BC8
    #ifdef __clang__
    #pragma clang diagnostic push
    #pragma clang diagnostic ignored "-Wdeprecated-declarations"
    NSOpenGLContext *currentContext;
    NSMutableArray *contexts;
    if (!data || !data.nscontexts) {
        return;
    currentContext = [NSOpenGLContext currentContext];
    contexts = data.nscontexts;
    @synchronized (contexts) {
        for (SDLOpenGLContext *context in contexts) {
            if (context == currentContext) {
                [context update];
            } else {
                [context scheduleUpdate];
    #ifdef __clang__
    #pragma clang diagnostic pop
    #endif /* SDL_VIDEO_OPENGL */
/* !!! FIXME: this should use a hint callback. */
static int GetHintCtrlClickEmulateRightClick()
    return SDL_GetHintBoolean(SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK, SDL_FALSE);
static NSUInteger GetWindowWindowedStyle(SDL_Window * window)
    /* IF YOU CHANGE ANY FLAGS IN HERE, PLEASE READ
       the NSWindowStyleMaskBorderless comments in SetupWindowData()! */
    /* always allow miniaturization, otherwise you can't programatically
       minimize the window, whether there's a title bar or not */
    NSUInteger style = NSWindowStyleMaskMiniaturizable;
    if (window->flags & SDL_WINDOW_BORDERLESS) {
        style |= NSWindowStyleMaskBorderless;
    } else {
        style |= (NSWindowStyleMaskTitled|NSWindowStyleMaskClosable);
    if (window->flags & SDL_WINDOW_RESIZABLE) {
        style |= NSWindowStyleMaskResizable;
    return style;
static NSUInteger GetWindowStyle(SDL_Window * window)
    NSUInteger style = 0;
    if (window->flags & SDL_WINDOW_FULLSCREEN) {
        style = NSWindowStyleMaskBorderless;
    } else {
        style = GetWindowWindowedStyle(window);
    return style;
static SDL_bool SetWindowStyle(SDL_Window * window, NSUInteger style)
    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
    NSWindow *nswindow = data.nswindow;
    /* The view responder chain gets messed with during setStyleMask */
    if ([data.sdlContentView nextResponder] == data.listener) {
        [data.sdlContentView setNextResponder:nil];
    [nswindow setStyleMask:style];
    /* The view responder chain gets messed with during setStyleMask */
    if ([data.sdlContentView nextResponder] != data.listener) {
        [data.sdlContentView setNextResponder:data.listener];
    return SDL_TRUE;
static SDL_bool ShouldAdjustCoordinatesForGrab(SDL_Window * window)
    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
    if (!data || [data.listener isMovingOrFocusClickPending]) {
        return SDL_FALSE;
    if (!(window->flags & SDL_WINDOW_INPUT_FOCUS)) {
        return SDL_FALSE;
    if ((window->flags & SDL_WINDOW_MOUSE_GRABBED) || (window->mouse_rect.w > 0 && window->mouse_rect.h > 0)) {
        return SDL_TRUE;
    return SDL_FALSE;
static SDL_bool AdjustCoordinatesForGrab(SDL_Window * window, int x, int y, CGPoint *adjusted)
    if (window->mouse_rect.w > 0 && window->mouse_rect.h > 0) {
        SDL_Rect window_rect;
        SDL_Rect mouse_rect;
        window_rect.x = 0;
        window_rect.y = 0;
        window_rect.w = window->w;
        window_rect.h = window->h;
        if (SDL_IntersectRect(&window->mouse_rect, &window_rect, &mouse_rect)) {
            int left = window->x + mouse_rect.x;
            int right = left + mouse_rect.w - 1;
            int top = window->y + mouse_rect.y;
            int bottom = top + mouse_rect.h - 1;
            if (x < left || x > right || y < top || y > bottom) {
                adjusted->x = SDL_clamp(x, left, right);
                adjusted->y = SDL_clamp(y, top, bottom);
                return SDL_TRUE;
            return SDL_FALSE;
    if (window->flags & SDL_WINDOW_MOUSE_GRABBED) {
        int left = window->x;
        int right = left + window->w - 1;
        int top = window->y;
        int bottom = top + window->h - 1;
        if (x < left || x > right || y < top || y > bottom) {
            adjusted->x = SDL_clamp(x, left, right);
            adjusted->y = SDL_clamp(y, top, bottom);
            return SDL_TRUE;
    return SDL_FALSE;
static void Cocoa_UpdateClipCursor(SDL_Window * window)
    SDL_WindowData *data = (__bridge SDL_WindowData *) window->driverdata;
    if (NSAppKitVersionNumber >= NSAppKitVersionNumber10_13_2) {
        NSWindow *nswindow = data.nswindow;
        SDL_Rect mouse_rect;
        SDL_zero(mouse_rect);
        if (ShouldAdjustCoordinatesForGrab(window)) {
            SDL_Rect window_rect;
            window_rect.x = 0;
            window_rect.y = 0;
            window_rect.w = window->w;
            window_rect.h = window->h;
            if (window->mouse_rect.w > 0 && window->mouse_rect.h > 0) {
                SDL_IntersectRect(&window->mouse_rect, &window_rect, &mouse_rect);
            if ((window->flags & SDL_WINDOW_MOUSE_GRABBED) != 0 &&
                SDL_RectEmpty(&mouse_rect)) {
                SDL_memcpy(&mouse_rect, &window_rect, sizeof(mouse_rect));
        if (SDL_RectEmpty(&mouse_rect)) {
            nswindow.mouseConfinementRect = NSZeroRect;
        } else {
            NSRect rect;
            rect.origin.x = mouse_rect.x;
            rect.origin.y = [nswindow contentLayoutRect].size.height - mouse_rect.y - mouse_rect.h;
            rect.size.width = mouse_rect.w;
            rect.size.height = mouse_rect.h;
            nswindow.mouseConfinementRect = rect;
    } else {
        /* Move the cursor to the nearest point in the window */
        if (ShouldAdjustCoordinatesForGrab(window)) {
            int x, y;
            CGPoint cgpoint;
            SDL_GetGlobalMouseState(&x, &y);
            if (AdjustCoordinatesForGrab(window, x, y, &cgpoint)) {
                Cocoa_HandleMouseWarp(cgpoint.x, cgpoint.y);
                CGDisplayMoveCursorToPoint(kCGDirectMainDisplay, cgpoint);
static NSCursor *Cocoa_GetDesiredCursor(void)
    SDL_Mouse *mouse = SDL_GetMouse();
    if (mouse->cursor_shown && mouse->cur_cursor && !mouse->relative_mode) {
        return (__bridge NSCursor *)mouse->cur_cursor->driverdata;
    return [NSCursor invisibleCursor];
@implementation Cocoa_WindowListener
- (void)listen:(SDL_WindowData *)data
    NSNotificationCenter *center;
    NSWindow *window = data.nswindow;
    NSView *view = data.sdlContentView;
    _data = data;
    observingVisible = YES;
    wasCtrlLeft = NO;
    wasVisible = [window isVisible];
    isFullscreenSpace = NO;
    inFullscreenTransition = NO;
    pendingWindowOperation = PENDING_OPERATION_NONE;
    isMoving = NO;
    isDragAreaRunning = NO;
    pendingWindowWarpX = pendingWindowWarpY = INT_MAX;
    liveResizeTimer = nil;
    center = [NSNotificationCenter defaultCenter];
    if ([window delegate] != nil) {
        [center addObserver:self selector:@selector(windowDidExpose:) name:NSWindowDidExposeNotification object:window];
        [center addObserver:self selector:@selector(windowWillStartLiveResize:) name:NSWindowWillStartLiveResizeNotification object:window];
        [center addObserver:self selector:@selector(windowDidEndLiveResize:) name:NSWindowDidEndLiveResizeNotification object:window];
        [center addObserver:self selector:@selector(windowDidMove:) name:NSWindowDidMoveNotification object:window];
        [center addObserver:self selector:@selector(windowDidResize:) name:NSWindowDidResizeNotification object:window];
        [center addObserver:self selector:@selector(windowDidMiniaturize:) name:NSWindowDidMiniaturizeNotification object:window];
        [center addObserver:self selector:@selector(windowDidDeminiaturize:) name:NSWindowDidDeminiaturizeNotification object:window];
        [center addObserver:self selector:@selector(windowDidBecomeKey:) name:NSWindowDidBecomeKeyNotification object:window];
        [center addObserver:self selector:@selector(windowDidResignKey:) name:NSWindowDidResignKeyNotification object:window];
        [center addObserver:self selector:@selector(windowDidChangeBackingProperties:) name:NSWindowDidChangeBackingPropertiesNotification object:window];
        [center addObserver:self selector:@selector(windowDidChangeScreenProfile:) name:NSWindowDidChangeScreenProfileNotification object:window];
        [center addObserver:self selector:@selector(windowDidChangeScreen:) name:NSWindowDidChangeScreenNotification object:window];
        [center addObserver:self selector:@selector(windowWillEnterFullScreen:) name:NSWindowWillEnterFullScreenNotification object:window];
        [center addObserver:self selector:@selector(windowDidEnterFullScreen:) name:NSWindowDidEnterFullScreenNotification object:window];
        [center addObserver:self selector:@selector(windowWillExitFullScreen:) name:NSWindowWillExitFullScreenNotification object:window];
        [center addObserver:self selector:@selector(windowDidExitFullScreen:) name:NSWindowDidExitFullScreenNotification object:window];
        [center addObserver:self selector:@selector(windowDidFailToEnterFullScreen:) name:@"NSWindowDidFailToEnterFullScreenNotification" object:window];
        [center addObserver:self selector:@selector(windowDidFailToExitFullScreen:) name:@"NSWindowDidFailToExitFullScreenNotification" object:window];
    } else {
        [window setDelegate:self];
    /* Haven't found a delegate / notification that triggers when the window is
     * ordered out (is not visible any more). You can be ordered out without
     * minimizing, so DidMiniaturize doesn't work. (e.g. -[NSWindow orderOut:])
    [window addObserver:self
             forKeyPath:@"visible"
                options:NSKeyValueObservingOptionNew
                context:NULL];
    [window setNextResponder:self];
    [window setAcceptsMouseMovedEvents:YES];
    [view setNextResponder:self];
    [view setAcceptsTouchEvents:YES];
- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary *)change
                       context:(void *)context
    if (!observingVisible) {
        return;
    if (object == _data.nswindow && [keyPath isEqualToString:@"visible"]) {
        int newVisibility = [[change objectForKey:@"new"] intValue];
        if (newVisibility) {
            SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_SHOWN, 0, 0);
        } else {
            SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_HIDDEN, 0, 0);
-(void) pauseVisibleObservation
    observingVisible = NO;
    wasVisible = [_data.nswindow isVisible];
-(void) resumeVisibleObservation
    BOOL isVisible = [_data.nswindow isVisible];
    observingVisible = YES;
    if (wasVisible != isVisible) {
        if (isVisible) {
            SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_SHOWN, 0, 0);
        } else {
            SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_HIDDEN, 0, 0);
        wasVisible = isVisible;
-(BOOL) setFullscreenSpace:(BOOL) state
    SDL_Window *window = _data.window;
    NSWindow *nswindow = _data.nswindow;
    SDL_VideoData *videodata = ((__bridge SDL_WindowData *) window->driverdata).videodata;
    if (!videodata.allow_spaces) {
        return NO;  /* Spaces are forcibly disabled. */
    } else if (state && ((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != SDL_WINDOW_FULLSCREEN_DESKTOP)) {
        return NO;  /* we only allow you to make a Space on FULLSCREEN_DESKTOP windows. */
    } else if (!state && ((window->last_fullscreen_flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != SDL_WINDOW_FULLSCREEN_DESKTOP)) {
        return NO;  /* we only handle leaving the Space on windows that were previously FULLSCREEN_DESKTOP. */
    } else if (state == isFullscreenSpace) {
        return YES;  /* already there. */
    if (inFullscreenTransition) {
        if (state) {
            [self addPendingWindowOperation:PENDING_OPERATION_ENTER_FULLSCREEN];
        } else {
            [self addPendingWindowOperation:PENDING_OPERATION_LEAVE_FULLSCREEN];
        return YES;
    inFullscreenTransition = YES;
    /* you need to be FullScreenPrimary, or toggleFullScreen doesn't work. Unset it again in windowDidExitFullScreen. */
    [nswindow setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
    [nswindow performSelectorOnMainThread: @selector(toggleFullScreen:) withObject:nswindow waitUntilDone:NO];
    return YES;
-(BOOL) isInFullscreenSpace
    return isFullscreenSpace;
-(BOOL) isInFullscreenSpaceTransition
    return inFullscreenTransition;
-(void) addPendingWindowOperation:(PendingWindowOperation) operation
    pendingWindowOperation = operation;
- (void)close
    NSNotificationCenter *center;
    NSWindow *window = _data.nswindow;
    NSView *view = [window contentView];
    center = [NSNotificationCenter defaultCenter];
    if ([window delegate] != self) {
        [center removeObserver:self name:NSWindowDidExposeNotification object:window];
        [center removeObserver:self name:NSWindowWillStartLiveResizeNotification object:window];
        [center removeObserver:self name:NSWindowDidEndLiveResizeNotification object:window];
        [center removeObserver:self name:NSWindowDidMoveNotification object:window];
        [center removeObserver:self name:NSWindowDidResizeNotification object:window];
        [center removeObserver:self name:NSWindowDidMiniaturizeNotification object:window];
        [center removeObserver:self name:NSWindowDidDeminiaturizeNotification object:window];
        [center removeObserver:self name:NSWindowDidBecomeKeyNotification object:window];
        [center removeObserver:self name:NSWindowDidResignKeyNotification object:window];
        [center removeObserver:self name:NSWindowDidChangeBackingPropertiesNotification object:window];
        [center removeObserver:self name:NSWindowDidChangeScreenProfileNotification object:window];
        [center removeObserver:self name:NSWindowDidChangeScreenNotification object:window];
        [center removeObserver:self name:NSWindowWillEnterFullScreenNotification object:window];
        [center removeObserver:self name:NSWindowDidEnterFullScreenNotification object:window];
        [center removeObserver:self name:NSWindowWillExitFullScreenNotification object:window];
        [center removeObserver:self name:NSWindowDidExitFullScreenNotification object:window];
        [center removeObserver:self name:@"NSWindowDidFailToEnterFullScreenNotification" object:window];
        [center removeObserver:self name:@"NSWindowDidFailToExitFullScreenNotification" object:window];
    } else {
        [window setDelegate:nil];
    [window removeObserver:self forKeyPath:@"visible"];
    if ([window nextResponder] == self) {
        [window setNextResponder:nil];
    if ([view nextResponder] == self) {
        [view setNextResponder:nil];
- (BOOL)isMoving
    return isMoving;
- (BOOL)isMovingOrFocusClickPending
    return isMoving || (focusClickPending != 0);
-(void) setFocusClickPending:(NSInteger) button
    focusClickPending |= (1 << button);
-(void) clearFocusClickPending:(NSInteger) button
    if (focusClickPending & (1 << button)) {
        focusClickPending &= ~(1 << button);
        if (focusClickPending == 0) {
            [self onMovingOrFocusClickPendingStateCleared];
-(void) setPendingMoveX:(int)x Y:(int)y
    pendingWindowWarpX = x;
    pendingWindowWarpY = y;
- (void)windowDidFinishMoving
    if (isMoving) {
        isMoving = NO;
        [self onMovingOrFocusClickPendingStateCleared];
- (void)onMovingOrFocusClickPendingStateCleared
    if (![self isMovingOrFocusClickPending]) {
        SDL_Mouse *mouse = SDL_GetMouse();
        if (pendingWindowWarpX != INT_MAX && pendingWindowWarpY != INT_MAX) {
            mouse->WarpMouseGlobal(pendingWindowWarpX, pendingWindowWarpY);
            pendingWindowWarpX = pendingWindowWarpY = INT_MAX;
        if (mouse->relative_mode && !mouse->relative_mode_warp && mouse->focus == _data.window) {
            /* Move the cursor to the nearest point in the window */
                int x, y;
                CGPoint cgpoint;
                SDL_GetMouseState(&x, &y);
                cgpoint.x = _data.window->x + x;
                cgpoint.y = _data.window->y + y;
                Cocoa_HandleMouseWarp(cgpoint.x, cgpoint.y);
                DLog("Returning cursor to (%g, %g)", cgpoint.x, cgpoint.y);
                CGDisplayMoveCursorToPoint(kCGDirectMainDisplay, cgpoint);
            mouse->SetRelativeMouseMode(SDL_TRUE);
        } else {
            Cocoa_UpdateClipCursor(_data.window);
- (BOOL)windowShouldClose:(id)sender
    SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_CLOSE, 0, 0);
    return NO;
- (void)windowDidExpose:(NSNotification *)aNotification
    SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_EXPOSED, 0, 0);
- (void)onLiveResizeTimerFire:(id)sender
    SDL_OnWindowLiveResizeUpdate(_data.window);
- (void)windowWillStartLiveResize:(NSNotification *)aNotification
    // We'll try to maintain 60 FPS during live resizing
    const NSTimeInterval interval = 1.0 / 60.0;
    NSMethodSignature *invocationSig = [Cocoa_WindowListener
        instanceMethodSignatureForSelector:@selector(onLiveResizeTimerFire:)];
    NSInvocation *invocation = [NSInvocation
        invocationWithMethodSignature:invocationSig];
    [invocation setTarget:self];
    [invocation setSelector:@selector(onLiveResizeTimerFire:)];
    liveResizeTimer = [NSTimer scheduledTimerWithTimeInterval:interval
                                                      invocation:invocation
                                                      repeats:TRUE];
    [[NSRunLoop currentRunLoop] addTimer:liveResizeTimer forMode:NSRunLoopCommonModes];
- (void)windowDidEndLiveResize:(NSNotification *)aNotification
    [liveResizeTimer invalidate];
    liveResizeTimer = nil;
- (void)windowWillMove:(NSNotification *)aNotification
    if ([_data.nswindow isKindOfClass:[SDLWindow class]]) {
        pendingWindowWarpX = pendingWindowWarpY = INT_MAX;
        isMoving = YES;
- (void)windowDidMove:(NSNotification *)aNotification
    int x, y;
    SDL_Window *window = _data.window;
    NSWindow *nswindow = _data.nswindow;
    BOOL fullscreen = window->flags & FULLSCREEN_MASK;
    NSRect rect = [nswindow contentRectForFrameRect:[nswindow frame]];
    ConvertNSRect([nswindow screen], fullscreen, &rect);
    if (inFullscreenTransition) {
        /* We'll take care of this at the end of the transition */
        return;
    if (s_moveHack) {
        SDL_bool blockMove = ((SDL_GetTicks() - s_moveHack) < 500);
        s_moveHack = 0;
        if (blockMove) {
            /* Cocoa is adjusting the window in response to a mode change */
            rect.origin.x = window->x;
            rect.origin.y = window->y;
            ConvertNSRect([nswindow screen], fullscreen, &rect);
            [nswindow setFrameOrigin:rect.origin];
            return;
    x = (int)rect.origin.x;
    y = (int)rect.origin.y;
    ScheduleContextUpdates(_data);
    SDL_SendWindowEvent(window, SDL_WINDOWEVENT_MOVED, x, y);
- (void)windowDidResize:(NSNotification *)aNotification
    SDL_Window *window;
    NSWindow *nswindow;
    NSRect rect;
    int x, y, w, h;
    BOOL zoomed;
    if (inFullscreenTransition) {
        /* We'll take care of this at the end of the transition */
        return;
    if (focusClickPending) {
        focusClickPending = 0;
        [self onMovingOrFocusClickPendingStateCleared];
    window = _data.window;
    nswindow = _data.nswindow;
    rect = [nswindow contentRectForFrameRect:[nswindow frame]];
    ConvertNSRect([nswindow screen], (window->flags & FULLSCREEN_MASK), &rect);
    x = (int)rect.origin.x;
    y = (int)rect.origin.y;
    w = (int)rect.size.width;
    h = (int)rect.size.height;
    if (SDL_IsShapedWindow(window)) {
        Cocoa_ResizeWindowShape(window);
    ScheduleContextUpdates(_data);
    /* The window can move during a resize event, such as when maximizing
       or resizing from a corner */
    SDL_SendWindowEvent(window, SDL_WINDOWEVENT_MOVED, x, y);
    SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED, w, h);
    /* The OS can resize the window automatically if the display density
       changes while the window is miniaturized or hidden */
    if (![nswindow isVisible])
        return;
    /* isZoomed always returns true if the window is not resizable */
    if ((window->flags & SDL_WINDOW_RESIZABLE) && [nswindow isZoomed]) {
        zoomed = YES;
    } else {
        zoomed = NO;
    if (!zoomed) {
        SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESTORED, 0, 0);
    } else if (zoomed) {
        SDL_SendWindowEvent(window, SDL_WINDOWEVENT_MAXIMIZED, 0, 0);
- (void)windowDidMiniaturize:(NSNotification *)aNotification
    if (focusClickPending) {
        focusClickPending = 0;
        [self onMovingOrFocusClickPendingStateCleared];
    SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
- (void)windowDidDeminiaturize:(NSNotification *)aNotification
    SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_RESTORED, 0, 0);
- (void)windowDidBecomeKey:(NSNotification *)aNotification
    SDL_Window *window = _data.window;
    SDL_Mouse *mouse = SDL_GetMouse();
    /* We're going to get keyboard events, since we're key. */
    /* This needs to be done before restoring the relative mouse mode. */
    SDL_SetKeyboardFocus(window);
    if (mouse->relative_mode && !mouse->relative_mode_warp && ![self isMovingOrFocusClickPending]) {
        mouse->SetRelativeMouseMode(SDL_TRUE);
    /* If we just gained focus we need the updated mouse position */
    if (!mouse->relative_mode) {
        NSPoint point;
        int x, y;
        point = [_data.nswindow mouseLocationOutsideOfEventStream];
        x = (int)point.x;
        y = (int)(window->h - point.y);
        if (x >= 0 && x < window->w && y >= 0 && y < window->h) {
            SDL_SendMouseMotion(window, mouse->mouseID, 0, x, y);
    /* Check to see if someone updated the clipboard */
    Cocoa_CheckClipboardUpdate(_data.videodata);
    if ((isFullscreenSpace) && ((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP)) {
        [NSMenu setMenuBarVisible:NO];
        const unsigned int newflags = [NSEvent modifierFlags] & NSEventModifierFlagCapsLock;
        _data.videodata.modifierFlags = (_data.videodata.modifierFlags & ~NSEventModifierFlagCapsLock) | newflags;
        SDL_ToggleModState(KMOD_CAPS, newflags ? SDL_TRUE : SDL_FALSE);
- (void)windowDidResignKey:(NSNotification *)aNotification
    SDL_Mouse *mouse = SDL_GetMouse();
    if (mouse->relative_mode && !mouse->relative_mode_warp) {
        mouse->SetRelativeMouseMode(SDL_FALSE);
    /* Some other window will get mouse events, since we're not key. */
    if (SDL_GetMouseFocus() == _data.window) {
        SDL_SetMouseFocus(NULL);
    /* Some other window will get keyboard events, since we're not key. */
    if (SDL_GetKeyboardFocus() == _data.window) {
        SDL_SetKeyboardFocus(NULL);
    if (isFullscreenSpace) {
        [NSMenu setMenuBarVisible:YES];
- (void)windowDidChangeBackingProperties:(NSNotification *)aNotification
    NSNumber *oldscale = [[aNotification userInfo] objectForKey:NSBackingPropertyOldScaleFactorKey];
    if (inFullscreenTransition) {
        return;
    if ([oldscale doubleValue] != [_data.nswindow backingScaleFactor]) {
        /* Force a resize event when the backing scale factor changes. */
        _data.window->w = 0;
        _data.window->h = 0;
        [self windowDidResize:aNotification];
- (void)windowDidChangeScreenProfile:(NSNotification *)aNotification
    SDL_SendWindowEvent(_data.window, SDL_WINDOWEVENT_ICCPROF_CHANGED, 0, 0);
- (void)windowDidChangeScreen:(NSNotification *)aNotification
    /*printf("WINDOWDIDCHANGESCREEN\n");*/
#ifdef SDL_VIDEO_OPENGL
    if (_data && _data.nscontexts) {
        for (SDLOpenGLContext *context in _data.nscontexts) {
            [context movedToNewScreen];
#endif /* SDL_VIDEO_OPENGL */
- (void)windowWillEnterFullScreen:(NSNotification *)aNotification
    SDL_Window *window = _data.window;
    SetWindowStyle(window, (NSWindowStyleMaskTitled|NSWindowStyleMaskClosable|NSWindowStyleMaskMiniaturizable|NSWindowStyleMaskResizable));
    isFullscreenSpace = YES;
    inFullscreenTransition = YES;
- (void)windowDidFailToEnterFullScreen:(NSNotification *)aNotification
    SDL_Window *window = _data.window;
    if (window->is_destroying) {
        return;
View remainder of file in raw view
FilesExpand file tree

SDL_cocoawindow.m

Latest commit

History

SDL_cocoawindow.m

File metadata and controls
