/*

  Simple DirectMedia Layer

  Copyright (C) 1997-2013 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_config.h"

#if SDL_VIDEO_DRIVER_COCOA

#include "SDL_syswm.h"

#include "SDL_timer.h"  /* For SDL_GetTicks() */

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

#include "SDL_cocoashape.h"

#include "SDL_cocoamouse.h"

static Uint32 s_moveHack;

static __inline__ void ConvertNSRect(NSRect *r)

{

    r->origin.y = CGDisplayPixelsHigh(kCGDirectMainDisplay) - r->origin.y - r->size.height;

}

@implementation Cocoa_WindowListener

- (void)listen:(SDL_WindowData *)data

{

    NSNotificationCenter *center;

    NSWindow *window = data->nswindow;

    NSView *view = [window contentView];

    _data = data;

    observingVisible = YES;

    wasVisible = [window isVisible];

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

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

    }

}

- (void)close

{

    NSNotificationCenter *center;

    NSWindow *window = _data->nswindow;

    NSView *view = [window contentView];

    NSArray *windows = nil;

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

    } else {

        [window setDelegate:nil];

    }

    [window removeObserver:self

                forKeyPath:@"visible"];

    if ([window nextResponder] == self) {

        [window setNextResponder:nil];

    }

    if ([view nextResponder] == self) {

        [view setNextResponder:nil];

    }

    /* Make the next window in the z-order Key. If we weren't the foreground

       when closed, this is a no-op.

       !!! FIXME: Note that this is a hack, and there are corner cases where

       !!! FIXME:  this fails (such as the About box). The typical nib+RunLoop

       !!! FIXME:  handles this for Cocoa apps, but we bypass all that in SDL.

       !!! FIXME:  We should remove this code when we find a better way to

       !!! FIXME:  have the system do this for us. See discussion in

       !!! FIXME:   http://bugzilla.libsdl.org/show_bug.cgi?id=1825

    */

    windows = [NSApp orderedWindows];

    if ([windows count] > 0) {

        NSWindow *win = (NSWindow *) [windows objectAtIndex:0];

        [win makeKeyAndOrderFront:self];

    }

}

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

{

    int x, y;

    SDL_VideoDevice *device = SDL_GetVideoDevice();

    SDL_Window *window = _data->window;

    NSWindow *nswindow = _data->nswindow;

    NSRect rect = [nswindow contentRectForFrameRect:[nswindow frame]];

    ConvertNSRect(&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(&rect);

            [nswindow setFrameOrigin:rect.origin];

            return;

        }

    }

    x = (int)rect.origin.x;

    y = (int)rect.origin.y;

    if (window == device->current_glwin) {

        [((NSOpenGLContext *) device->current_glctx) update];

    }

    SDL_SendWindowEvent(window, SDL_WINDOWEVENT_MOVED, x, y);

}

- (void)windowDidResize:(NSNotification *)aNotification

{

    SDL_VideoDevice *device = SDL_GetVideoDevice();

    int x, y, w, h;

    NSRect rect = [_data->nswindow contentRectForFrameRect:[_data->nswindow frame]];

    ConvertNSRect(&rect);

    x = (int)rect.origin.x;

    y = (int)rect.origin.y;

    w = (int)rect.size.width;

    h = (int)rect.size.height;

    if (SDL_IsShapedWindow(_data->window))

        Cocoa_ResizeWindowShape(_data->window);

    if (_data->window == device->current_glwin) {

        [((NSOpenGLContext *) device->current_glctx) update];

    }

    /* The window can move during a resize event, such as when maximizing

       or resizing from a corner */

    SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_MOVED, x, y);

    SDL_SendWindowEvent(_data->window, SDL_WINDOWEVENT_RESIZED, w, h);

}

- (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. */

    SDL_SetKeyboardFocus(window);

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

}

- (void)windowDidResignKey:(NSNotification *)aNotification

{

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

    }

}

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

}

- (void)mouseDown:(NSEvent *)theEvent

{

    int button;

    switch ([theEvent buttonNumber]) {

    case 0:

        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;

    switch ([theEvent buttonNumber]) {

    case 0:

        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 (mouse->relative_mode) {

        return;

    }

    point = [theEvent locationInWindow];

    x = (int)point.x;

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

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

        if (window->flags & SDL_WINDOW_INPUT_GRABBED) {

            CGPoint cgpoint;

            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;

            }

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

        }

    }

    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

{

    [self handleTouches:COCOA_TOUCH_DOWN withEvent:theEvent];

}

- (void)touchesMovedWithEvent:(NSEvent *) theEvent

{

    [self handleTouches:COCOA_TOUCH_MOVE withEvent:theEvent];

}

- (void)touchesEndedWithEvent:(NSEvent *) theEvent

{

    [self handleTouches:COCOA_TOUCH_UP withEvent:theEvent];

}

- (void)touchesCancelledWithEvent:(NSEvent *) theEvent

{

    [self handleTouches:COCOA_TOUCH_CANCELLED withEvent:theEvent];

}

- (void)handleTouches:(cocoaTouchType)type withEvent:(NSEvent *)event

{

    NSSet *touches = 0;

    NSEnumerator *enumerator;

    NSTouch *touch;

    switch (type) {

        case COCOA_TOUCH_DOWN:

            touches = [event touchesMatchingPhase:NSTouchPhaseBegan inView:nil];

            break;

        case COCOA_TOUCH_UP:

        case COCOA_TOUCH_CANCELLED:

            touches = [event touchesMatchingPhase:NSTouchPhaseEnded inView:nil];

            break;

        case COCOA_TOUCH_MOVE:

            touches = [event touchesMatchingPhase:NSTouchPhaseMoved inView:nil];

            break;

    }

    enumerator = [touches objectEnumerator];

    touch = (NSTouch*)[enumerator nextObject];