/*

  Simple DirectMedia Layer

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

{

    return NSDragOperationGeneric;

}

- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender

{

    NSURL *fileURL = [NSURL URLFromPasteboard:[sender draggingPasteboard]];

    NSNumber *isAlias = nil;

    if (fileURL == nil) {

        return NO;

    }

    /* Functionality for resolving URL aliases was added with OS X 10.6. */

    if ([fileURL respondsToSelector:@selector(getResourceValue:forKey:error:)]) {

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

            }

        }

    }

    return (BOOL) SDL_SendDropFile([[fileURL path] UTF8String]);

}

- (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];

            }

        }

    }

}

static int

GetHintCtrlClickEmulateRightClick()

{

	const char *hint = SDL_GetHint( SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK );

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

}

static unsigned int

GetWindowStyle(SDL_Window * window)

{

    unsigned int style;

    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, unsigned int style)

{

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

    NSWindow *nswindow = data->nswindow;

    if (![nswindow respondsToSelector: @selector(setStyleMask:)]) {

        return SDL_FALSE;

    }

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

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

        [[nswindow contentView] setNextResponder:nil];

    }

    [nswindow performSelector: @selector(setStyleMask:) withObject: (id)(uintptr_t)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];

    } 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];

    if ([view respondsToSelector:@selector(setAcceptsTouchEvents:)]) {

        [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];

    } 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];

    }

}

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

    SetWindowStyle(window, GetWindowStyle(window));

    isFullscreenSpace = NO;

    inFullscreenTransition = YES;

}

- (void)windowDidExitFullScreen:(NSNotification *)aNotification

{

    SDL_Window *window = _data->window;

    NSWindow *nswindow = _data->nswindow;

    inFullscreenTransition = NO;

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

    if ([self processHitTest:theEvent]) {

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

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

        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;

            /* According to the docs, this was deprecated in 10.6, but it's still

             * around. The substitute requires a CGEventSource, but I'm not entirely

             * sure how we'd procure the right one for this event.

             */

            CGSetLocalEventsSuppressionInterval(0.0);

            CGDisplayMoveCursorToPoint(kCGDirectMainDisplay, cgpoint);

            CGSetLocalEventsSuppressionInterval(0.25);

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

        if ([touch phase] != NSTouchPhaseBegan) {

            existingTouchCount++;

        }

    }

    if (existingTouchCount == 0) {

        SDL_TouchID touchID = (SDL_TouchID)(intptr_t)[[touches anyObject] device];

        int numFingers = SDL_GetNumTouchFingers(touchID);

        DLog("Reset Lost Fingers: %d", numFingers);

        for (--numFingers; numFingers >= 0; --numFingers) {

            SDL_Finger* finger = SDL_GetTouchFinger(touchID, numFingers);

            SDL_SendTouch(touchID, finger->id, SDL_FALSE, 0, 0, 0);

        }

    }

    DLog("Began Fingers: %lu .. existing: %d", (unsigned long)[touches count], existingTouchCount);

    [self handleTouches:NSTouchPhaseBegan withEvent:theEvent];

}

- (void)touchesMovedWithEvent:(NSEvent *) theEvent

{

    [self handleTouches:NSTouchPhaseMoved withEvent:theEvent];

}

- (void)touchesEndedWithEvent:(NSEvent *) theEvent

{

    [self handleTouches:NSTouchPhaseEnded withEvent:theEvent];

}

- (void)touchesCancelledWithEvent:(NSEvent *) theEvent

{

    [self handleTouches:NSTouchPhaseCancelled withEvent:theEvent];

}

- (void)handleTouches:(NSTouchPhase) phase withEvent:(NSEvent *) theEvent

{

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

    for (NSTouch *touch in touches) {

        const SDL_TouchID touchId = (SDL_TouchID)(intptr_t)[touch device];

        if (SDL_AddTouch(touchId, "") < 0) {

            return;

        }

        const SDL_FingerID fingerId = (SDL_FingerID)(intptr_t)[touch identity];

        float x = [touch normalizedPosition].x;

        float y = [touch normalizedPosition].y;

        /* Make the origin the upper left instead of the lower left */

        y = 1.0f - y;

        switch (phase) {

        case NSTouchPhaseBegan:

            SDL_SendTouch(touchId, fingerId, SDL_TRUE, x, y, 1.0f);

            break;

        case NSTouchPhaseEnded:

        case NSTouchPhaseCancelled:

            SDL_SendTouch(touchId, fingerId, SDL_FALSE, x, y, 1.0f);

            break;

        case NSTouchPhaseMoved:

            SDL_SendTouchMotion(touchId, fingerId, x, y, 1.0f);

            break;

        default:

            break;

        }

    }

}

@end

@interface SDLView : NSView {

    SDL_Window *_sdlWindow;

}

- (void)setSDLWindow:(SDL_Window*)window;

/* The default implementation doesn't pass rightMouseDown to responder chain */

- (void)rightMouseDown:(NSEvent *)theEvent;

- (BOOL)mouseDownCanMoveWindow;

- (void)drawRect:(NSRect)dirtyRect;

@end