/*

  Simple DirectMedia Layer

  Copyright (C) 1997-2016 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"

#if 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_assert.h"

/* #define DEBUG_COCOAWINDOW */

#ifdef DEBUG_COCOAWINDOW

#define DLog(fmt, ...) printf("%s: " fmt "\n", __func__, ##__VA_ARGS__)

#else

#define DLog(...) do { } while (0)

#endif

#define FULLSCREEN_MASK (SDL_WINDOW_FULLSCREEN_DESKTOP | SDL_WINDOW_FULLSCREEN)

@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;

@end

@implementation SDLWindow

- (BOOL)canBecomeKeyWindow

{

    return YES;

}

- (BOOL)canBecomeMainWindow

{

    return YES;

}

- (void)sendEvent:(NSEvent *)event

{

    [super sendEvent:event];

    if ([event type] != NSLeftMouseUp) {

        return;

    }

    id 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

{

    SDL_VideoDevice *_this = SDL_GetVideoDevice();

    NSPasteboard *pasteboard = [sender draggingPasteboard];

    NSArray *types = [NSArray arrayWithObject:NSFilenamesPboardType];

    NSString *desiredType = [pasteboard availableTypeFromArray:types];

    SDL_Window *sdlwindow = nil;

    if (desiredType == nil) {

        return NO;  /* can't accept anything that's being dropped here. */

    }

    NSData *data = [pasteboard dataForType:desiredType];

    if (data == nil) {

        return NO;

    }

    SDL_assert([desiredType isEqualToString:NSFilenamesPboardType]);

    NSArray *array = [pasteboard propertyListForType:@"NSFilenamesPboardType"];

    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

                                                               options:opts

                                                         relativeToURL:nil

                                                   bookmarkDataIsStale:nil

                                                                 error:nil];

                if (resolvedURL != nil) {

                    fileURL = resolvedURL;

                }

            }

        }

        /* !!! FIXME: is there a better way to do this? */

        if (_this) {

            for (sdlwindow = _this->windows; sdlwindow; sdlwindow = sdlwindow->next) {

                NSWindow *nswindow = ((SDL_WindowData *) sdlwindow->driverdata)->nswindow;

                if (nswindow == self) {

                    break;

                }

            }

        }

        if (!SDL_SendDropFile(sdlwindow, [[fileURL path] UTF8String])) {

            return NO;

        }

    }

    SDL_SendDropComplete(sdlwindow);

    return YES;

}}

- (BOOL)wantsPeriodicDraggingUpdates

{

    return NO;

}

@end

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)

{

    NSOpenGLContext *currentContext = [NSOpenGLContext currentContext];

    NSMutableArray *contexts = data->nscontexts;

    @synchronized (contexts) {

        for (SDLOpenGLContext *context in contexts) {

            if (context == currentContext) {

                [context update];

            } else {

                [context scheduleUpdate];

            }

        }

    }

}

/* !!! FIXME: this should use a hint callback. */

static int

GetHintCtrlClickEmulateRightClick()

{

	const char *hint = SDL_GetHint( SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK );

	return hint != NULL && *hint != '0';

}

static NSUInteger

GetWindowStyle(SDL_Window * window)

{

    NSUInteger style = 0;

    if (window->flags & SDL_WINDOW_FULLSCREEN) {

        style = NSBorderlessWindowMask;

    } else {

        if (window->flags & SDL_WINDOW_BORDERLESS) {

            style = NSBorderlessWindowMask;

        } else {

            style = (NSTitledWindowMask|NSClosableWindowMask|NSMiniaturizableWindowMask);

        }

        if (window->flags & SDL_WINDOW_RESIZABLE) {

            style |= NSResizableWindowMask;

        }

    }

    return style;

}

static SDL_bool

SetWindowStyle(SDL_Window * window, NSUInteger style)

{

    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;

    NSWindow *nswindow = data->nswindow;

    /* The view responder chain gets messed with during setStyleMask */

    if ([[nswindow contentView] nextResponder] == data->listener) {

        [[nswindow contentView] setNextResponder:nil];

    }

    [nswindow setStyleMask:style];

    /* The view responder chain gets messed with during setStyleMask */

    if ([[nswindow contentView] nextResponder] != data->listener) {

        [[nswindow contentView] setNextResponder:data->listener];

    }

    return SDL_TRUE;

}

@implementation Cocoa_WindowListener

- (void)listen:(SDL_WindowData *)data

{

    NSNotificationCenter *center;

    NSWindow *window = data->nswindow;

    NSView *view = [window contentView];

    _data = data;

    observingVisible = YES;

    wasCtrlLeft = NO;

    wasVisible = [window isVisible];

    isFullscreenSpace = NO;

    inFullscreenTransition = NO;

    pendingWindowOperation = PENDING_OPERATION_NONE;

    isMoving = NO;

    isDragAreaRunning = NO;

    center = [NSNotificationCenter defaultCenter];

    if ([window delegate] != nil) {

        [center addObserver:self selector:@selector(windowDidExpose:) name:NSWindowDidExposeNotification 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(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 = ((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: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: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;

}

-(void) setPendingMoveX:(int)x Y:(int)y

{

    pendingWindowWarpX = x;

    pendingWindowWarpY = y;

}

- (void)windowDidFinishMoving

{

    if ([self isMoving]) {

        isMoving = NO;

        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) {

            mouse->SetRelativeMouseMode(SDL_TRUE);

        }

    }

}

- (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)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 (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

{

    if (inFullscreenTransition) {

        /* We'll take care of this at the end of the transition */

        return;

    }

    SDL_Window *window = _data->window;

    NSWindow *nswindow = _data->nswindow;

    int x, y, w, h;

    NSRect 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);

    const BOOL zoomed = [nswindow isZoomed];

    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

{

    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 isMoving]) {

        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, 0, 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] & NSAlphaShiftKeyMask;

    _data->videodata->modifierFlags = (_data->videodata->modifierFlags & ~NSAlphaShiftKeyMask) | newflags;

    SDL_ToggleModState(KMOD_CAPS, newflags != 0);

}

- (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)windowWillEnterFullScreen:(NSNotification *)aNotification

{

    SDL_Window *window = _data->window;

    SetWindowStyle(window, (NSTitledWindowMask|NSClosableWindowMask|NSMiniaturizableWindowMask|NSResizableWindowMask));

    isFullscreenSpace = YES;

    inFullscreenTransition = YES;

}

- (void)windowDidFailToEnterFullScreen:(NSNotification *)aNotification

{

    SDL_Window *window = _data->window;

    if (window->is_destroying) {

        return;

    }

    SetWindowStyle(window, GetWindowStyle(window));

    isFullscreenSpace = NO;

    inFullscreenTransition = NO;

    [self windowDidExitFullScreen:nil];

}

- (void)windowDidEnterFullScreen:(NSNotification *)aNotification

{

    SDL_Window *window = _data->window;

    inFullscreenTransition = NO;

    if (pendingWindowOperation == PENDING_OPERATION_LEAVE_FULLSCREEN) {

        pendingWindowOperation = PENDING_OPERATION_NONE;

        [self setFullscreenSpace:NO];

    } else {

        if ((window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP) {

            [NSMenu setMenuBarVisible:NO];

        }

        pendingWindowOperation = PENDING_OPERATION_NONE;

        /* Force the size change event in case it was delivered earlier

           while the window was still animating into place.

         */

        window->w = 0;

        window->h = 0;

        [self windowDidResize:aNotification];

    }

}

- (void)windowWillExitFullScreen:(NSNotification *)aNotification

{

    SDL_Window *window = _data->window;

    /* As of OS X 10.11, the window seems to need to be resizable when exiting

       a Space, in order for it to resize back to its windowed-mode size.

     */

    SetWindowStyle(window, GetWindowStyle(window) | NSResizableWindowMask);

    isFullscreenSpace = NO;

    inFullscreenTransition = YES;

}

- (void)windowDidFailToExitFullScreen:(NSNotification *)aNotification

{

    SDL_Window *window = _data->window;

    if (window->is_destroying) {

        return;

    }

    SetWindowStyle(window, (NSTitledWindowMask|NSClosableWindowMask|NSMiniaturizableWindowMask|NSResizableWindowMask));

    isFullscreenSpace = YES;

    inFullscreenTransition = NO;

    [self windowDidEnterFullScreen:nil];

}

- (void)windowDidExitFullScreen:(NSNotification *)aNotification

{

    SDL_Window *window = _data->window;

    NSWindow *nswindow = _data->nswindow;

    inFullscreenTransition = NO;

    SetWindowStyle(window, GetWindowStyle(window));

    [nswindow setLevel:kCGNormalWindowLevel];

    if (pendingWindowOperation == PENDING_OPERATION_ENTER_FULLSCREEN) {

        pendingWindowOperation = PENDING_OPERATION_NONE;

        [self setFullscreenSpace:YES];

    } else if (pendingWindowOperation == PENDING_OPERATION_MINIMIZE) {

        pendingWindowOperation = PENDING_OPERATION_NONE;

        [nswindow miniaturize:nil];

    } else {

        /* Adjust the fullscreen toggle button and readd menu now that we're here. */

        if (window->flags & SDL_WINDOW_RESIZABLE) {

            /* resizable windows are Spaces-friendly: they get the "go fullscreen" toggle button on their titlebar. */

            [nswindow setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];

        } else {

            [nswindow setCollectionBehavior:NSWindowCollectionBehaviorManaged];

        }

        [NSMenu setMenuBarVisible:YES];

        pendingWindowOperation = PENDING_OPERATION_NONE;

        /* Force the size change event in case it was delivered earlier

           while the window was still animating into place.

         */

        window->w = 0;

        window->h = 0;

        [self windowDidResize:aNotification];

        /* FIXME: Why does the window get hidden? */

        if (window->flags & SDL_WINDOW_SHOWN) {

            Cocoa_ShowWindow(SDL_GetVideoDevice(), window);

        }

    }

}

-(NSApplicationPresentationOptions)window:(NSWindow *)window willUseFullScreenPresentationOptions:(NSApplicationPresentationOptions)proposedOptions

{

    if ((_data->window->flags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP) {

        return NSApplicationPresentationFullScreen | NSApplicationPresentationHideDock | NSApplicationPresentationHideMenuBar;

    } else {

        return proposedOptions;

    }

}

/* We'll respond to key events by doing nothing so we don't beep.

 * We could handle key messages here, but we lose some in the NSApp dispatch,

 * where they get converted to action messages, etc.

 */

- (void)flagsChanged:(NSEvent *)theEvent

{

    /*Cocoa_HandleKeyEvent(SDL_GetVideoDevice(), theEvent);*/

}

- (void)keyDown:(NSEvent *)theEvent

{

    /*Cocoa_HandleKeyEvent(SDL_GetVideoDevice(), theEvent);*/

}

- (void)keyUp:(NSEvent *)theEvent

{

    /*Cocoa_HandleKeyEvent(SDL_GetVideoDevice(), theEvent);*/

}

/* 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));*/

}

- (BOOL)processHitTest:(NSEvent *)theEvent

{

    SDL_assert(isDragAreaRunning == [_data->nswindow isMovableByWindowBackground]);

    if (_data->window->hit_test) {  /* if no hit-test, skip this. */

        const NSPoint location = [theEvent locationInWindow];

        const SDL_Point point = { (int) location.x, _data->window->h - (((int) location.y)-1) };

        const SDL_HitTestResult rc = _data->window->hit_test(_data->window, &point, _data->window->hit_test_data);

        if (rc == SDL_HITTEST_DRAGGABLE) {

            if (!isDragAreaRunning) {

                isDragAreaRunning = YES;

                [_data->nswindow setMovableByWindowBackground:YES];

            }

            return YES;  /* dragging! */

        }

    }

    if (isDragAreaRunning) {

        isDragAreaRunning = NO;

        [_data->nswindow setMovableByWindowBackground:NO];

        return YES;  /* was dragging, drop event. */

    }

    return NO;  /* not a special area, carry on. */

}

- (void)mouseDown:(NSEvent *)theEvent

{

    int button;

    /* Ignore events that aren't inside the client area (i.e. title bar.) */

    if ([theEvent window]) {

        NSRect windowRect = [[[theEvent window] contentView] frame];

        if (!NSMouseInRect([theEvent locationInWindow], windowRect, NO)) {

            return;

        }

    }

    if ([self processHitTest:theEvent]) {

        SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_HIT_TEST, 0, 0);

        return;  /* dragging, drop event. */

    }

    switch ([theEvent buttonNumber]) {

    case 0:

        if (([theEvent modifierFlags] & NSControlKeyMask) &&

		    GetHintCtrlClickEmulateRightClick()) {

            wasCtrlLeft = YES;

            button = SDL_BUTTON_RIGHT;

        } else {

            wasCtrlLeft = NO;

            button = SDL_BUTTON_LEFT;

        }

        break;

    case 1:

        button = SDL_BUTTON_RIGHT;

        break;

    case 2:

        button = SDL_BUTTON_MIDDLE;

        break;

    default:

        button = [theEvent buttonNumber] + 1;

        break;

    }

    SDL_SendMouseButton(_data->window, 0, SDL_PRESSED, button);

}

- (void)rightMouseDown:(NSEvent *)theEvent

{

    [self mouseDown:theEvent];

}

- (void)otherMouseDown:(NSEvent *)theEvent

{

    [self mouseDown:theEvent];

}

- (void)mouseUp:(NSEvent *)theEvent

{

    int button;

    if ([self processHitTest:theEvent]) {

        SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_HIT_TEST, 0, 0);

        return;  /* stopped dragging, drop event. */

    }

    switch ([theEvent buttonNumber]) {

    case 0:

        if (wasCtrlLeft) {

            button = SDL_BUTTON_RIGHT;

            wasCtrlLeft = NO;

        } else {

            button = SDL_BUTTON_LEFT;

        }

        break;

    case 1:

        button = SDL_BUTTON_RIGHT;

        break;

    case 2:

        button = SDL_BUTTON_MIDDLE;

        break;

    default:

        button = [theEvent buttonNumber] + 1;

        break;

    }

    SDL_SendMouseButton(_data->window, 0, SDL_RELEASED, button);

}

- (void)rightMouseUp:(NSEvent *)theEvent

{

    [self mouseUp:theEvent];

}

- (void)otherMouseUp:(NSEvent *)theEvent

{

    [self mouseUp:theEvent];

}

- (void)mouseMoved:(NSEvent *)theEvent

{

    SDL_Mouse *mouse = SDL_GetMouse();

    SDL_Window *window = _data->window;

    NSPoint point;

    int x, y;

    if ([self processHitTest:theEvent]) {

        SDL_SendWindowEvent(window, SDL_WINDOWEVENT_HIT_TEST, 0, 0);

        return;  /* dragging, drop event. */

    }

    if (mouse->relative_mode) {

        return;

    }

    point = [theEvent locationInWindow];

    x = (int)point.x;

    y = (int)(window->h - point.y);

    if (window->flags & SDL_WINDOW_INPUT_GRABBED) {

        if (x < 0 || x >= window->w || y < 0 || y >= window->h) {

            if (x < 0) {

                x = 0;

            } else if (x >= window->w) {

                x = window->w - 1;

            }

            if (y < 0) {

                y = 0;

            } else if (y >= window->h) {

                y = window->h - 1;

            }

#if !SDL_MAC_NO_SANDBOX

            CGPoint cgpoint;

            /* When SDL_MAC_NO_SANDBOX is set, this is handled by

             * SDL_cocoamousetap.m.

             */

            cgpoint.x = window->x + x;

            cgpoint.y = window->y + y;

            CGDisplayMoveCursorToPoint(kCGDirectMainDisplay, cgpoint);

            CGAssociateMouseAndMouseCursorPosition(YES);

            Cocoa_HandleMouseWarp(cgpoint.x, cgpoint.y);

#endif

        }

    }

    SDL_SendMouseMotion(window, 0, 0, x, y);

}

- (void)mouseDragged:(NSEvent *)theEvent

{

    [self mouseMoved:theEvent];

}

- (void)rightMouseDragged:(NSEvent *)theEvent

{

    [self mouseMoved:theEvent];

}

- (void)otherMouseDragged:(NSEvent *)theEvent

{

    [self mouseMoved:theEvent];

}

- (void)scrollWheel:(NSEvent *)theEvent

{

    Cocoa_HandleMouseWheel(_data->window, theEvent);

}

- (void)touchesBeganWithEvent:(NSEvent *) theEvent

{

    NSSet *touches = [theEvent touchesMatchingPhase:NSTouchPhaseAny inView:nil];

    int existingTouchCount = 0;

    for (NSTouch* touch in touches) {