/*
 * Copyright 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
 * Copyright 1998-2002 Tor Lillqvist
 * Copyright 2005-2008 Imendio AB
 * Copyright 2020 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */

#include "config.h"

#import "GdkMacosWindow.h"
#import "GdkMacosBaseView.h"

#include "gdkmacosdevice-private.h"
#include "gdkmacosdisplay-private.h"
#include "gdkmacoskeymap-private.h"
#include "gdkmacossurface-private.h"
#include "gdkmacosseat-private.h"
#include "gdkmacosutils-private.h"

#include "gdk/gdkeventsprivate.h"

#define GRIP_WIDTH 15
#define GRIP_HEIGHT 15
#define GDK_LION_RESIZE 5

#define BUTTON_MASK (GDK_BUTTON1_MASK | \
                     GDK_BUTTON2_MASK | \
                     GDK_BUTTON3_MASK | \
                     GDK_BUTTON4_MASK | \
                     GDK_BUTTON5_MASK)

static gboolean
test_resize (NSEvent         *event,
             GdkMacosSurface *surface,
             int              x,
             int              y)
{
  g_assert (event != NULL);
  g_assert (GDK_IS_MACOS_SURFACE (surface));

  /* If we're on Lion and within 5 pixels of an edge, then assume that the
   * user wants to resize, and return NULL to let Quartz get on with it.
   *
   * We perform this check for a button press of all buttons, because we
   * do receive, for instance, a right mouse down event for a GDK surface
   * for x-coordinate range [-3, 0], but we do not want to forward this
   * into GDK. Forwarding such events into GDK will confuse the pointer
   * window finding code, because there are no GdkSurfaces present in
   * the range [-3, 0].
   */
  if (([event type] == NSEventTypeLeftMouseDown ||
       [event type] == NSEventTypeRightMouseDown ||
       [event type] == NSEventTypeOtherMouseDown))
    {
      if (x < GDK_LION_RESIZE ||
          x > GDK_SURFACE (surface)->width - GDK_LION_RESIZE ||
          y > GDK_SURFACE (surface)->height - GDK_LION_RESIZE)
        return TRUE;
    }

  return FALSE;
}

static guint32
get_time_from_ns_event (NSEvent *event)
{
  double time = [event timestamp];
  /* cast via double->uint64 conversion to make sure that it is
   * wrapped on 32-bit machines when it overflows
   */
  return (guint32) (guint64) (time * 1000.0);
}

static int
get_mouse_button_from_ns_event (NSEvent *event)
{
  NSInteger button = [event buttonNumber];

  switch (button)
    {
    case 0:
      return 1;
    case 1:
      return 3;
    case 2:
      return 2;
    default:
      return button + 1;
    }
}

static GdkModifierType
get_mouse_button_modifiers_from_ns_buttons (NSUInteger nsbuttons)
{
  GdkModifierType modifiers = 0;

  if (nsbuttons & (1 << 0))
    modifiers |= GDK_BUTTON1_MASK;
  if (nsbuttons & (1 << 1))
    modifiers |= GDK_BUTTON3_MASK;
  if (nsbuttons & (1 << 2))
    modifiers |= GDK_BUTTON2_MASK;
  if (nsbuttons & (1 << 3))
    modifiers |= GDK_BUTTON4_MASK;
  if (nsbuttons & (1 << 4))
    modifiers |= GDK_BUTTON5_MASK;

  return modifiers;
}

static GdkModifierType
get_mouse_button_modifiers_from_ns_event (NSEvent *event)
{
  GdkModifierType state = 0;
  int button;

  /* This maps buttons 1 to 5 to GDK_BUTTON[1-5]_MASK */
  button = get_mouse_button_from_ns_event (event);
  if (button >= 1 && button <= 5)
    state = (1 << (button + 7));

  return state;
}

static GdkModifierType
get_keyboard_modifiers_from_ns_flags (NSUInteger nsflags)
{
  GdkModifierType modifiers = 0;

  if (nsflags & NSEventModifierFlagCapsLock)
    modifiers |= GDK_LOCK_MASK;
  if (nsflags & NSEventModifierFlagShift)
    modifiers |= GDK_SHIFT_MASK;
  if (nsflags & NSEventModifierFlagControl)
    modifiers |= GDK_CONTROL_MASK;
  if (nsflags & NSEventModifierFlagOption)
    modifiers |= GDK_ALT_MASK;
  if (nsflags & NSEventModifierFlagCommand)
    modifiers |= GDK_META_MASK;

  return modifiers;
}

static GdkModifierType
get_keyboard_modifiers_from_ns_event (NSEvent *nsevent)
{
  return get_keyboard_modifiers_from_ns_flags ([nsevent modifierFlags]);
}

GdkModifierType
_gdk_macos_display_get_current_mouse_modifiers (GdkMacosDisplay *self)
{
  return get_mouse_button_modifiers_from_ns_buttons ([NSEvent pressedMouseButtons]);
}

GdkModifierType
_gdk_macos_display_get_current_keyboard_modifiers (GdkMacosDisplay *self)
{
  return get_keyboard_modifiers_from_ns_flags ([NSEvent modifierFlags]);
}

static gboolean
over_native_window_buttons (NSEvent *nsevent)
{
  NSWindow *window = [nsevent window];

  if (!GDK_IS_MACOS_WINDOW (window) || ![(GdkMacosWindow*)window showStandardWindowButtons])
    return FALSE;

  NSPoint win_pos = [nsevent locationInWindow];
  NSButton *buttons[] = {
    [window standardWindowButton:NSWindowCloseButton],
    [window standardWindowButton:NSWindowMiniaturizeButton],
    [window standardWindowButton:NSWindowZoomButton]
  };

  for (int i = 0; i < G_N_ELEMENTS (buttons); i++)
    {
      NSPoint view_pos = [[buttons[i] superview] convertPoint:win_pos fromView:nil];
      if ([buttons[i] hitTest:view_pos])
        return TRUE;
    }

  return FALSE;
}

static GdkEvent *
fill_button_event (GdkMacosDisplay *display,
                   GdkMacosSurface *surface,
                   NSEvent         *nsevent,
                   int              x,
                   int              y)
{
  GdkSeat *seat;
  GdkEventType type;
  GdkModifierType state;
  GdkDevice *pointer = NULL;
  GdkDeviceTool *tool = NULL;
  double *axes = NULL;
  cairo_region_t *input_region;
  unsigned int n_button;

  g_assert (GDK_IS_MACOS_DISPLAY (display));
  g_assert (GDK_IS_MACOS_SURFACE (surface));

  seat = gdk_display_get_default_seat (GDK_DISPLAY (display));
  state = get_keyboard_modifiers_from_ns_event (nsevent) |
         _gdk_macos_display_get_current_mouse_modifiers (display);
  input_region = GDK_SURFACE (surface)->input_region;

  switch ((int)[nsevent type])
    {
    case NSEventTypeLeftMouseDown:
    case NSEventTypeRightMouseDown:
    case NSEventTypeOtherMouseDown:
      type = GDK_BUTTON_PRESS;
      state &= ~get_mouse_button_modifiers_from_ns_event (nsevent);
      break;

    case NSEventTypeLeftMouseUp:
    case NSEventTypeRightMouseUp:
    case NSEventTypeOtherMouseUp:
      type = GDK_BUTTON_RELEASE;
      state |= get_mouse_button_modifiers_from_ns_event (nsevent);
      break;

    default:
      g_assert_not_reached ();
    }

  /* Ignore button press events outside the window coords but
   * allow for button release which can happen during grabs.
   */
  if (type == GDK_BUTTON_PRESS &&
      (x < 0 || x > GDK_SURFACE (surface)->width ||
       y < 0 || y > GDK_SURFACE (surface)->height ||
       (input_region && !cairo_region_contains_point (input_region, x, y))))
    return NULL;

  /* Ignore button press events that happen on a native window button.
   * For those events we do not receive a button release event which leaves
   * our app in a "grabbed" state.
   */
  if (type == GDK_BUTTON_PRESS && over_native_window_buttons (nsevent))
    {
      GDK_DEBUG (EVENTS, "Ignoring button press over native controls (%d, %d)", x, y);
      return NULL;
    }

  n_button = get_mouse_button_from_ns_event (nsevent);

  if (([nsevent subtype] == NSEventSubtypeTabletPoint) &&
      _gdk_macos_seat_get_tablet (GDK_MACOS_SEAT (seat), &pointer, &tool))
    axes = _gdk_macos_seat_get_tablet_axes_from_nsevent (GDK_MACOS_SEAT (seat), nsevent);
  else
    pointer = gdk_seat_get_pointer (seat);

  if (type == GDK_BUTTON_PRESS && ((state & BUTTON_MASK) == 0))
    gdk_macos_device_set_implicit_grab (pointer, GDK_SURFACE (surface));
  else if (type == GDK_BUTTON_RELEASE &&
           ((state & BUTTON_MASK & ~(GDK_BUTTON1_MASK << (n_button - 1))) == 0))
    gdk_macos_device_set_implicit_grab (pointer, NULL);

  return gdk_button_event_new (type,
                               GDK_SURFACE (surface),
                               pointer,
                               tool,
                               get_time_from_ns_event (nsevent),
                               state,
                               n_button,
                               x,
                               y,
                               axes);
}

static GdkEvent *
synthesize_crossing_event (GdkMacosDisplay *display,
                           GdkMacosSurface *surface,
                           NSEvent         *nsevent,
                           int              x,
                           int              y)
{
  GdkEventType event_type;
  GdkModifierType state;
  GdkSeat *seat;

  switch ((int)[nsevent type])
    {
    case NSEventTypeMouseEntered:
      event_type = GDK_ENTER_NOTIFY;
      break;

    case NSEventTypeMouseExited:
      event_type = GDK_LEAVE_NOTIFY;
      break;

    default:
      g_return_val_if_reached (NULL);
    }

  state = get_keyboard_modifiers_from_ns_event (nsevent) |
         _gdk_macos_display_get_current_mouse_modifiers (display);
  seat = gdk_display_get_default_seat (GDK_DISPLAY (display));

  return gdk_crossing_event_new (event_type,
                                 GDK_SURFACE (surface),
                                 gdk_seat_get_pointer (seat),
                                 get_time_from_ns_event (nsevent),
                                 state,
                                 x,
                                 y,
                                 GDK_CROSSING_NORMAL,
                                 GDK_NOTIFY_NONLINEAR);
}

static inline guint
get_group_from_ns_event (NSEvent *nsevent)
{
  return ([nsevent modifierFlags] & NSEventModifierFlagOption) ? 1 : 0;
}

static GdkEvent *
fill_key_event (GdkMacosDisplay *display,
                GdkMacosSurface *surface,
                NSEvent         *nsevent,
                GdkEventType     type)
{
  GdkTranslatedKey translated = {0};
  GdkTranslatedKey no_lock = {0};
  GdkModifierType consumed;
  GdkModifierType state;
  GdkKeymap *keymap;
  gboolean is_modifier;
  GdkSeat *seat;
  guint keycode;
  guint keyval;
  guint group;
  int layout;
  int level;

  g_assert (GDK_IS_MACOS_DISPLAY (display));
  g_assert (GDK_IS_MACOS_SURFACE (surface));
  g_assert (nsevent != NULL);

  seat = gdk_display_get_default_seat (GDK_DISPLAY (display));
  keymap = gdk_display_get_keymap (GDK_DISPLAY (display));
  keycode = [nsevent keyCode];
  keyval = GDK_KEY_VoidSymbol;
  state = get_keyboard_modifiers_from_ns_event (nsevent);
  group = get_group_from_ns_event (nsevent);
  is_modifier = _gdk_macos_keymap_is_modifier (keycode);

  gdk_keymap_translate_keyboard_state (keymap, keycode, state, group,
                                       &keyval, &layout, &level, &consumed);

  /* If the key press is a modifier, the state should include the mask for
   * that modifier but only for releases, not presses. This matches the
   * X11 backend behavior.
   */
  if (is_modifier)
    {
      guint mask = 0;

      switch (keyval)
        {
        case GDK_KEY_Meta_R:
        case GDK_KEY_Meta_L:
          mask = GDK_META_MASK;
          break;
        case GDK_KEY_Shift_R:
        case GDK_KEY_Shift_L:
          mask = GDK_SHIFT_MASK;
          break;
        case GDK_KEY_Caps_Lock:
          mask = GDK_LOCK_MASK;
          break;
        case GDK_KEY_Alt_R:
        case GDK_KEY_Alt_L:
          mask = GDK_ALT_MASK;
          break;
        case GDK_KEY_Control_R:
        case GDK_KEY_Control_L:
          mask = GDK_CONTROL_MASK;
          break;
        default:
          mask = 0;
        }

      if (type == GDK_KEY_PRESS)
        state &= ~mask;
      else if (type == GDK_KEY_RELEASE)
        state |= mask;
    }

  state |= _gdk_macos_display_get_current_mouse_modifiers (display);

  translated.keyval = keyval;
  translated.consumed = consumed;
  translated.layout = layout;
  translated.level = level;

  if (state & GDK_LOCK_MASK)
    {
      gdk_keymap_translate_keyboard_state (keymap,
                                           keycode,
                                           state & ~GDK_LOCK_MASK,
                                           group,
                                           &keyval,
                                           &layout,
                                           &level,
                                           &consumed);

      no_lock.keyval = keycode;
      no_lock.consumed = consumed;
      no_lock.layout = layout;
      no_lock.level = level;
    }
  else
    {
      no_lock = translated;
    }

  return gdk_key_event_new (type,
                            GDK_SURFACE (surface),
                            gdk_seat_get_keyboard (seat),
                            get_time_from_ns_event (nsevent),
                            [nsevent keyCode],
                            state,
                            is_modifier,
                            &translated,
                            &no_lock,
                            NULL);
}

static GdkEvent *
fill_pinch_event (GdkMacosDisplay *display,
                  GdkMacosSurface *surface,
                  NSEvent         *nsevent,
                  int              x,
                  int              y)
{
  static double last_scale = 1.0;
  static enum {
    FP_STATE_IDLE,
    FP_STATE_UPDATE
  } last_state = FP_STATE_IDLE;
  GdkSeat *seat;
  GdkTouchpadGesturePhase phase;
  double angle_delta = 0.0;

  g_assert (GDK_IS_MACOS_DISPLAY (display));
  g_assert (GDK_IS_MACOS_SURFACE (surface));

  /* fill_pinch_event handles the conversion from the two OSX gesture events
   * NSEventTypeMagnfiy and NSEventTypeRotate to the GDK_TOUCHPAD_PINCH event.
   * The normal behavior of the OSX events is that they produce as sequence of
   *   1 x NSEventPhaseBegan,
   *   n x NSEventPhaseChanged,
   *   1 x NSEventPhaseEnded
   * This can happen for both the Magnify and the Rotate events independently.
   * As both events are summarized in one GDK_TOUCHPAD_PINCH event sequence, a
   * little state machine handles the case of two NSEventPhaseBegan events in
   * a sequence, e.g. Magnify(Began), Magnify(Changed)..., Rotate(Began)...
   * such that PINCH(STARTED), PINCH(UPDATE).... will not show a second
   * PINCH(STARTED) event.
   */

  switch ((int)[nsevent phase])
    {
    case NSEventPhaseBegan:
      switch (last_state)
        {
        case FP_STATE_IDLE:
          phase = GDK_TOUCHPAD_GESTURE_PHASE_BEGIN;
          last_state = FP_STATE_UPDATE;
          last_scale = 1.0;
          break;
        case FP_STATE_UPDATE:
          /* We have already received a PhaseBegan event but no PhaseEnded
             event. This can happen, e.g. Magnify(Began), Magnify(Change)...
             Rotate(Began), Rotate (Change),...., Magnify(End) Rotate(End)
          */
          phase = GDK_TOUCHPAD_GESTURE_PHASE_UPDATE;
          break;
        }
      break;

    case NSEventPhaseChanged:
      phase = GDK_TOUCHPAD_GESTURE_PHASE_UPDATE;
      break;

    case NSEventPhaseEnded:
      phase = GDK_TOUCHPAD_GESTURE_PHASE_END;
      switch (last_state)
        {
        case FP_STATE_IDLE:
          /* We are idle but have received a second PhaseEnded event.
             This can happen because we have Magnify and Rotate OSX
             event sequences. We just send a second end GDK_PHASE_END.
          */
          break;
        case FP_STATE_UPDATE:
          last_state = FP_STATE_IDLE;
          break;
        }
      break;

    case NSEventPhaseCancelled:
      phase = GDK_TOUCHPAD_GESTURE_PHASE_CANCEL;
      last_state = FP_STATE_IDLE;
      break;

    case NSEventPhaseMayBegin:
    case NSEventPhaseStationary:
      phase = GDK_TOUCHPAD_GESTURE_PHASE_CANCEL;
      break;

    default:
      g_assert_not_reached ();
      break;
    }

  switch ((int)[nsevent type])
    {
    case NSEventTypeMagnify:
      last_scale *= [nsevent magnification] + 1.0;
      angle_delta = 0.0;
      break;

    case NSEventTypeRotate:
      angle_delta = - [nsevent rotation] * G_PI / 180.0;
      break;

    default:
      g_assert_not_reached ();
    }

  seat = gdk_display_get_default_seat (GDK_DISPLAY (display));

  return gdk_touchpad_event_new_pinch (GDK_SURFACE (surface),
                                       NULL, /* FIXME make up sequences */
                                       gdk_seat_get_pointer (seat),
                                       get_time_from_ns_event (nsevent),
                                       get_keyboard_modifiers_from_ns_event (nsevent),
                                       phase,
                                       x,
                                       y,
                                       2,
                                       0.0,
                                       0.0,
                                       last_scale,
                                       angle_delta);

}

static gboolean
is_motion_event (NSEventType event_type)
{
  return (event_type == NSEventTypeLeftMouseDragged ||
          event_type == NSEventTypeRightMouseDragged ||
          event_type == NSEventTypeOtherMouseDragged ||
          event_type == NSEventTypeMouseMoved);
}

static GdkEvent *
fill_motion_event (GdkMacosDisplay *display,
                   GdkMacosSurface *surface,
                   NSEvent         *nsevent,
                   int              x,
                   int              y)
{
  GdkSeat *seat;
  GdkModifierType state;
  GdkDevice *pointer = NULL;
  GdkDeviceTool *tool = NULL;
  double *axes = NULL;

  g_assert (GDK_IS_MACOS_SURFACE (surface));
  g_assert (nsevent != NULL);
  g_assert (is_motion_event ([nsevent type]));

  seat = gdk_display_get_default_seat (GDK_DISPLAY (display));
  state = get_keyboard_modifiers_from_ns_event (nsevent) |
          _gdk_macos_display_get_current_mouse_modifiers (display);

  if (([nsevent subtype] == NSEventSubtypeTabletPoint) &&
      _gdk_macos_seat_get_tablet (GDK_MACOS_SEAT (seat), &pointer, &tool))
    axes = _gdk_macos_seat_get_tablet_axes_from_nsevent (GDK_MACOS_SEAT (seat), nsevent);
  else
    pointer = gdk_seat_get_pointer (seat);

  return gdk_motion_event_new (GDK_SURFACE (surface),
                               pointer,
                               tool,
                               get_time_from_ns_event (nsevent),
                               state,
                               x,
                               y,
                               axes);
}

static GdkEvent *
fill_scroll_event (GdkMacosDisplay *self,
                   GdkMacosSurface *surface,
                   NSEvent         *nsevent,
                   int              x,
                   int              y)
{
  GdkScrollDirection direction = 0;
  GdkScrollRelativeDirection relative_direction;
  GdkModifierType state;
  GdkDevice *pointer;
  GdkEvent *ret = NULL;
  NSEventPhase phase;
  NSEventPhase momentumPhase;
  GdkSeat *seat;
  double dx;
  double dy;

  g_assert (GDK_IS_MACOS_SURFACE (surface));
  g_assert (nsevent != NULL);

  phase = [nsevent phase];
  momentumPhase = [nsevent momentumPhase];
  relative_direction = [nsevent isDirectionInvertedFromDevice] ?
    GDK_SCROLL_RELATIVE_DIRECTION_INVERTED :
    GDK_SCROLL_RELATIVE_DIRECTION_IDENTICAL;

  /* Ignore kinetic scroll events from the display server as we already
   * handle those internally.
   */
  if (phase == 0 && momentumPhase != 0)
    return GDK_MACOS_EVENT_DROP;

  seat = gdk_display_get_default_seat (GDK_DISPLAY (self));
  pointer = gdk_seat_get_pointer (seat);
  state = _gdk_macos_display_get_current_mouse_modifiers (self) |
          _gdk_macos_display_get_current_keyboard_modifiers (self);

  /* If we are starting a new phase, send a stop so any previous
   * scrolling immediately stops.
   */
  if (phase == NSEventPhaseMayBegin)
    return gdk_scroll_event_new (GDK_SURFACE (surface),
                                 pointer,
                                 NULL,
                                 get_time_from_ns_event (nsevent),
                                 state,
                                 0.0, 0.0, TRUE,
                                 GDK_SCROLL_UNIT_SURFACE,
                                 relative_direction);

  dx = [nsevent deltaX];
  dy = [nsevent deltaY];

  if ([nsevent hasPreciseScrollingDeltas])
    {
      double sx;
      double sy;

      sx = [nsevent scrollingDeltaX];
      sy = [nsevent scrollingDeltaY];

      if (sx != 0.0 || sy != 0.0)
        ret = gdk_scroll_event_new (GDK_SURFACE (surface),
                                    pointer,
                                    NULL,
                                    get_time_from_ns_event (nsevent),
                                    state,
                                    -sx,
                                    -sy,
                                    FALSE,
                                    GDK_SCROLL_UNIT_SURFACE,
                                    relative_direction);

      /* Fall through for scroll emulation */
    }

  if (dy != 0.0)
    {
      if (dy < 0.0)
        direction = GDK_SCROLL_DOWN;
      else
        direction = GDK_SCROLL_UP;

      dx = 0.0;
    }
  else if (dx != 0.0)
    {
      if (dx < 0.0)
        direction = GDK_SCROLL_RIGHT;
      else
        direction = GDK_SCROLL_LEFT;

      dy = 0.0;
    }

  if ((dx != 0.0 || dy != 0.0) && ![nsevent hasPreciseScrollingDeltas])
    {
      g_assert (ret == NULL);

      ret = gdk_scroll_event_new_discrete (GDK_SURFACE (surface),
                                           pointer,
                                           NULL,
                                           get_time_from_ns_event (nsevent),
                                           state,
                                           direction,
                                           relative_direction);
    }

  if (phase == NSEventPhaseEnded || phase == NSEventPhaseCancelled)
    {
      /* The user must have released their fingers in a touchpad
       * scroll, so try to send a scroll is_stop event.
       */
      if (ret != NULL)
        _gdk_event_queue_append (GDK_DISPLAY (self), g_steal_pointer (&ret));
      ret = gdk_scroll_event_new (GDK_SURFACE (surface),
                                  pointer,
                                  NULL,
                                  get_time_from_ns_event (nsevent),
                                  state,
                                  0.0, 0.0, TRUE,
                                  GDK_SCROLL_UNIT_SURFACE,
                                  relative_direction);
    }

  return g_steal_pointer (&ret);
}


static GdkEvent *
fill_event (GdkMacosDisplay *self,
            GdkMacosSurface *surface,
            NSEvent         *nsevent,
            int              x,
            int              y,
            gboolean         in_manual_resize_or_move)
{
  NSEventType event_type = [nsevent type];
  GdkEvent *ret = NULL;

  switch ((int)event_type)
    {
    case NSEventTypeLeftMouseDown:
    case NSEventTypeRightMouseDown:
    case NSEventTypeOtherMouseDown:
    case NSEventTypeLeftMouseUp:
    case NSEventTypeRightMouseUp:
    case NSEventTypeOtherMouseUp:
      ret = fill_button_event (self, surface, nsevent, x, y);
      break;

    case NSEventTypeLeftMouseDragged:
    case NSEventTypeRightMouseDragged:
    case NSEventTypeOtherMouseDragged:
    case NSEventTypeMouseMoved:
      ret = fill_motion_event (self, surface, nsevent, x, y);
      break;

    case NSEventTypeMagnify:
    case NSEventTypeRotate:
      ret = fill_pinch_event (self, surface, nsevent, x, y);
      break;

    case NSEventTypeMouseExited:
    case NSEventTypeMouseEntered:
      {
        GdkSeat *seat = gdk_display_get_default_seat (GDK_DISPLAY (self));
        GdkDevice *pointer = gdk_seat_get_pointer (seat);

        if (in_manual_resize_or_move)
          {
            ret = GDK_MACOS_EVENT_DROP;
          }
        else if (!gdk_macos_device_get_implicit_grab (pointer))
          {
            if (event_type == NSEventTypeMouseExited)
              [[NSCursor arrowCursor] set];

            ret = synthesize_crossing_event (self, surface, nsevent, x, y);
          }
      }

      break;

    case NSEventTypeKeyDown:
    case NSEventTypeKeyUp:
    case NSEventTypeFlagsChanged: {
      GdkEventType type = _gdk_macos_keymap_get_event_type (nsevent);

      if (type)
        ret = fill_key_event (self, surface, nsevent, type);

      break;
    }

    case NSEventTypeScrollWheel:
      ret = fill_scroll_event (self, surface, nsevent, x, y);
      break;

    default:
      break;
    }

  return ret;
}

static gboolean
is_mouse_button_press_event (NSEventType type)
{
  switch ((int)type)
    {
    case NSEventTypeLeftMouseDown:
    case NSEventTypeRightMouseDown:
    case NSEventTypeOtherMouseDown:
      return TRUE;

    default:
      return FALSE;
    }
}

static void
get_surface_point_from_screen_point (GdkMacosDisplay *self,
                                     GdkMacosSurface *surface,
                                     NSPoint          screen_point,
                                     int             *x,
                                     int             *y)
{
  int x_tmp, y_tmp;

  _gdk_macos_display_from_display_coords (self,
                                          screen_point.x,
                                          screen_point.y,
                                          &x_tmp, &y_tmp);
  *x = x_tmp - surface->root_x;
  *y = y_tmp - surface->root_y;
}

static GdkSurface *
find_surface_under_pointer (GdkMacosDisplay *self,
                            NSPoint          screen_point,
                            int             *x,
                            int             *y)
{
  GdkMacosSurface *surface;
  int x_tmp, y_tmp;

  surface = _gdk_macos_display_get_surface_at_display_coords (self,
                                                              screen_point.x,
                                                              screen_point.y,
                                                              &x_tmp,
                                                              &y_tmp);

  if (surface != NULL)
    {
      _gdk_macos_display_from_display_coords (self,
                                              screen_point.x,
                                              screen_point.y,
                                              &x_tmp, &y_tmp);
      *x = x_tmp - surface->root_x;
      *y = y_tmp - surface->root_y;
      /* If the coordinates are out of window bounds, this surface is not
       * under the pointer and we thus return NULL. This can occur when
       * surface under pointer has not yet been updated due to a very recent
       * window resize. Alternatively, we should no longer be relying on
       * the surface_under_pointer value which is maintained in gdkwindow.c.
       */
      if (*x < 0 ||
          *y < 0 ||
          *x >= GDK_SURFACE (surface)->width ||
          *y >= GDK_SURFACE (surface)->height)
        surface = NULL;
    }

  return GDK_SURFACE (surface);
}

static GdkSurface *
get_surface_from_ns_event (GdkMacosDisplay *self,
                           NSEvent         *nsevent,
                           NSPoint         *screen_point,
                           int             *x,
                           int             *y)
{
  GdkSurface *surface = NULL;
  NSWindow *nswindow = [nsevent window];

  if (GDK_IS_MACOS_WINDOW (nswindow))
    {
      GdkMacosBaseView *view;
      NSPoint point, view_point;
      NSRect view_frame;

      view = (GdkMacosBaseView *)[nswindow contentView];
      if (!GDK_IS_MACOS_BASE_VIEW (view))
        goto find_under_pointer;

      surface = GDK_SURFACE ([view gdkSurface]);

      point = [nsevent locationInWindow];
      view_point = [view convertPoint:point fromView:nil];
      view_frame = [view frame];

      /* NSEvents come in with a window set, but with window coordinates
       * out of window bounds. For e.g. moved events this is fine, we use
       * this information to properly handle enter/leave notify and motion
       * events. For mouse button press/release, we want to avoid forwarding
       * these events however, because the window they relate to is not the
       * window set in the event. This situation appears to occur when button
       * presses come in just before (or just after?) a window is resized and
       * also when a button press occurs on the OS X window titlebar.
       *
       * By setting surface to NULL, we do another attempt to get the right
       * surface window below.
       */
      if (is_mouse_button_press_event ([nsevent type]) &&
          (view_point.x < view_frame.origin.x ||
           view_point.x >= view_frame.origin.x + view_frame.size.width ||
           view_point.y < view_frame.origin.y ||
           view_point.y >= view_frame.origin.y + view_frame.size.height))
        {
          NSRect windowRect = [nswindow frame];

          surface = NULL;

          /* This is a hack for button presses to break all grabs. E.g. if
           * a menu is open and one clicks on the title bar (or anywhere
           * out of window bounds), we really want to pop down the menu (by
           * breaking the grabs) before OS X handles the action of the title
           * bar button.
           *
           * Because we cannot ingest this event into GDK, we have to do it
           * here, not very nice.
           */
          _gdk_macos_display_break_all_grabs (self, get_time_from_ns_event (nsevent));

          /* If the X,Y is on the frame itself, then we don't want to discover
           * the surface under the pointer at all so that we let OS X handle
           * it instead. We add padding to include resize operations too.
           */
          windowRect.origin.x = -GDK_LION_RESIZE;
          windowRect.origin.y = -GDK_LION_RESIZE;
          windowRect.size.width += (2 * GDK_LION_RESIZE);
          windowRect.size.height += (2 * GDK_LION_RESIZE);
          if (NSPointInRect (point, windowRect))
            return NULL;
        }
      else
        {
          *screen_point = convert_nspoint_to_screen ([nsevent window], point);
          *x = point.x;
          *y = surface->height - point.y;
        }
    }

find_under_pointer:

  if (surface == NULL && nswindow == NULL)
    {
      /* Fallback used when no NSWindow set. This happens e.g. when
       * we allow motion events without a window set in gdk_event_translate()
       * that occur immediately after the main menu bar was clicked/used.
       * This fallback will not return coordinates contained in a window's
       * titlebar.
       */
      *screen_point = [NSEvent mouseLocation];
      surface = find_surface_under_pointer (self, *screen_point, x, y);
    }

  return surface;
}

static GdkMacosSurface *
find_surface_for_keyboard_event (NSEvent *nsevent)
{
  NSView *nsview = [[nsevent window] contentView];

  if (GDK_IS_MACOS_BASE_VIEW (nsview))
    {
      GdkMacosBaseView *view = (GdkMacosBaseView *)nsview;
      GdkSurface *surface = GDK_SURFACE ([view gdkSurface]);
      GdkDisplay *display = gdk_surface_get_display (surface);
      GdkSeat *seat = gdk_display_get_default_seat (display);
      GdkSurface *grab_surface = gdk_seat_get_topmost_grab_surface (seat);

      if (grab_surface)
        return GDK_MACOS_SURFACE (grab_surface);
      else
        return GDK_MACOS_SURFACE (surface);
    }

  return NULL;
}

static GdkMacosSurface *
find_surface_for_mouse_event (GdkMacosDisplay *self,
                              NSEvent         *nsevent,
                              int             *x,
                              int             *y)
{
  NSPoint point;
  NSEventType event_type;
  GdkSurface *surface;
  GdkMacosSurface *implicit_grab_surface;
  GdkSurface *grab_surface;
  GdkDevice *pointer;
  GdkSeat *seat;

  /* Even if we had a surface window, it might be for something outside
   * the input region (shadow) which we might want to ignore. This is
   * handled for us deeper in the event unwrapping.
   */
  if (!(surface = get_surface_from_ns_event (self, nsevent, &point, x, y)))
    return NULL;

  seat = gdk_display_get_default_seat (GDK_DISPLAY (self));
  pointer = gdk_seat_get_pointer (seat);

  event_type = [nsevent type];

  implicit_grab_surface = GDK_MACOS_SURFACE (gdk_macos_device_get_implicit_grab (pointer));
  grab_surface = gdk_seat_get_topmost_grab_surface (seat);

  if (implicit_grab_surface)
    {
      get_surface_point_from_screen_point (self, implicit_grab_surface, point, x, y);
      return implicit_grab_surface;
    }
  else if (grab_surface)
    {
      /* For owner events, we need to use the surface under the
       * pointer, not the window from the NSEvent, since that is
       * reported with respect to the key window, which could be
       * wrong.
       */
      GdkSurface *surface_under_pointer;
      int x_tmp, y_tmp;

      surface_under_pointer = find_surface_under_pointer (self, point, &x_tmp, &y_tmp);
      if (surface_under_pointer)
        {
          surface = surface_under_pointer;
          *x = x_tmp;
          *y = y_tmp;
        }

      return GDK_MACOS_SURFACE (surface);
    }
  else
    {
      /* The non-grabbed case. */
      GdkSurface *surface_under_pointer;
      int x_tmp, y_tmp;

      /* Ignore all events but mouse moved that might be on the title
       * bar (above the content view). The reason is that otherwise
       * gdk gets confused about getting e.g. button presses with no
       * window (the title bar is not known to it).
       */
      if (event_type != NSEventTypeMouseMoved)
        {
          if (*y < 0)
            return NULL;
        }

      /* As for owner events, we need to use the surface under the
       * pointer, not the window from the NSEvent.
       */
      surface_under_pointer = find_surface_under_pointer (self, point, &x_tmp, &y_tmp);
      if (surface_under_pointer != NULL)
        {
          surface = surface_under_pointer;
          *x = x_tmp;
          *y = y_tmp;
        }

      return GDK_MACOS_SURFACE (surface);
    }

  return NULL;
}

/* This function finds the correct window to send an event to, taking
 * into account grabs, event propagation, and event masks.
 */
static GdkMacosSurface *
find_surface_for_ns_event (GdkMacosDisplay *self,
                           NSEvent         *nsevent,
                           int             *x,
                           int             *y)
{
  GdkMacosBaseView *view;
  GdkSurface *surface;
  NSPoint point;

  g_assert (GDK_IS_MACOS_DISPLAY (self));
  g_assert (nsevent != NULL);
  g_assert (x != NULL);
  g_assert (y != NULL);

  switch ((int)[nsevent type])
    {
    case NSEventTypeLeftMouseDown:
    case NSEventTypeRightMouseDown:
    case NSEventTypeOtherMouseDown:
    case NSEventTypeLeftMouseUp:
    case NSEventTypeRightMouseUp:
    case NSEventTypeOtherMouseUp:
    case NSEventTypeLeftMouseDragged:
    case NSEventTypeRightMouseDragged:
    case NSEventTypeOtherMouseDragged:
    case NSEventTypeMouseMoved:
    case NSEventTypeScrollWheel:
    case NSEventTypeMagnify:
    case NSEventTypeRotate:
      return find_surface_for_mouse_event (self, nsevent, x, y);

    case NSEventTypeMouseEntered:
    case NSEventTypeMouseExited:
      /* Only handle our own entered/exited events, not the ones for the
       * titlebar buttons.
       */
      if ((surface = get_surface_from_ns_event (self, nsevent, &point, x, y)) &&
          (view = (GdkMacosBaseView *)[GDK_MACOS_SURFACE (surface)->window contentView]) &&
          ([nsevent trackingArea] == [view trackingArea]))
        return GDK_MACOS_SURFACE (surface);
      else
        return NULL;

    case NSEventTypeKeyDown:
    case NSEventTypeKeyUp:
    case NSEventTypeFlagsChanged:
      return find_surface_for_keyboard_event (nsevent);

    default:
      /* Ignore everything else. */
      return NULL;
    }
}

GdkEvent *
_gdk_macos_display_translate (GdkMacosDisplay *self,
                              NSEvent         *nsevent)
{
  GdkMacosSurface *surface;
  GdkMacosWindow *window;
  NSEventType event_type;
  NSWindow *event_window;
  int x;
  int y;

  g_return_val_if_fail (GDK_IS_MACOS_DISPLAY (self), NULL);
  g_return_val_if_fail (nsevent != NULL, NULL);

  /* There is no support for real desktop wide grabs, so we break
   * grabs when the application loses focus (gets deactivated).
   */
  event_type = [nsevent type];
  if (event_type == NSEventTypeAppKitDefined)
    {
      if ([nsevent subtype] == NSEventSubtypeApplicationDeactivated)
        _gdk_macos_display_break_all_grabs (self, get_time_from_ns_event (nsevent));

      /* This could potentially be used to break grabs when clicking
       * on the title. The subtype 20 is undocumented so it's probably
       * not a good idea: else if (subtype == 20) break_all_grabs ();
       */

      /* Leave all AppKit events to AppKit. */
      return NULL;
    }

  /* We need to register the proximity event from any point on the screen
   * to properly register the devices
   * FIXME: is there a better way to detect if a tablet has been plugged?
   */
  if (event_type == NSEventTypeTabletProximity)
    {
      GdkSeat *seat = gdk_display_get_default_seat (GDK_DISPLAY (self));

      _gdk_macos_seat_handle_tablet_tool_event (GDK_MACOS_SEAT (seat), nsevent);

      /* FIXME: we might want to cache this proximity event and propagate it
       * but proximity events in gdk work at a window level while on macos
       * works at a screen level. For now we just skip them.
       */
      return NULL;
    }

  /* If the event was delivered to NSWindow that is foreign (or rather,
   * Cocoa native), then we should pass the event along to that window.
   */
  if ((event_window = [nsevent window]) && !GDK_IS_MACOS_WINDOW (event_window))
    return NULL;

  /* If we can't find a GdkSurface to deliver the event to, then we
   * should pass it along to the NSApp.
   */
  if (!(surface = find_surface_for_ns_event (self, nsevent, &x, &y)))
    return NULL;

  if (!(window = (GdkMacosWindow *)_gdk_macos_surface_get_native (surface)) ||
      !GDK_IS_MACOS_WINDOW (window))
    return NULL;

  /* Ignore events and break grabs while the window is being
   * dragged. This is a workaround for the window getting events for
   * the window title.
   */
  if ([window isInMove])
    {
      _gdk_macos_display_break_all_grabs (self, get_time_from_ns_event (nsevent));
      return NULL;
    }

  /* Also when in a manual resize or move , we ignore events so that
   * these are pushed to GdkMacosNSWindow's sendEvent handler.
   */
  if ([window isInManualResizeOrMove])
    return NULL;

  /* Make sure we have a GdkSurface */
  if (!(surface = [window gdkSurface]))
    return NULL;

  /* Quartz handles resizing on its own, so stay out of the way. */
  if (test_resize (nsevent, surface, x, y))
    return NULL;

  if (event_type == NSEventTypeRightMouseDown ||
      event_type == NSEventTypeOtherMouseDown ||
      event_type == NSEventTypeLeftMouseDown)
    {
      if (![NSApp isActive])
        [NSApp activateIgnoringOtherApps:YES];

      if (![window isKeyWindow])
        {
          NSWindow *orig_window = [nsevent window];

          /* To get NSApp to supress activating the window we might
           * have clicked through the shadow of, we need to dispatch
           * the event and handle it in GdkMacosView:mouseDown to call
           * [NSApp preventWindowOrdering]. Calling it here will not
           * do anything as the event is not registered.
           */
          if (orig_window &&
              GDK_IS_MACOS_WINDOW (orig_window) &&
              [(GdkMacosWindow *)orig_window needsMouseDownQuirk])
            [NSApp sendEvent:nsevent];

          [window showAndMakeKey:YES];
          _gdk_macos_display_clear_sorting (self);
        }
    }
  else if (is_motion_event(event_type))
    {
      NSWindow *orig_window = [nsevent window];

      if (orig_window && GDK_IS_MACOS_WINDOW (orig_window))
        [NSApp sendEvent:nsevent];
    }

  return fill_event (self, surface, nsevent, x, y, [window isInManualResizeOrMove]);
}

void
_gdk_macos_display_send_event (GdkMacosDisplay *self,
                               NSEvent         *nsevent)
{
  GdkSeat *seat = gdk_display_get_default_seat (GDK_DISPLAY (self));
  GdkMacosSurface *surface = NULL;
  GdkMacosWindow *window;
  GdkEvent *event;
  int x;
  int y;

  g_return_if_fail (GDK_IS_MACOS_DISPLAY (self));
  g_return_if_fail (nsevent != NULL);

  if (seat)
    {
      GdkDevice *pointer = gdk_seat_get_pointer (seat);
      surface = (GdkMacosSurface *) gdk_macos_device_get_implicit_grab (pointer);
    }
  if (surface == NULL)
    surface = find_surface_for_ns_event (self, nsevent, &x, &y);

  if (surface &&
      (window = (GdkMacosWindow *)_gdk_macos_surface_get_native (surface)) &&
      (event = fill_event (self, surface, nsevent, x, y, [window isInManualResizeOrMove])))
    _gdk_windowing_got_event (GDK_DISPLAY (self),
                              _gdk_event_queue_append (GDK_DISPLAY (self), event),
                              event,
                              _gdk_display_get_next_serial (GDK_DISPLAY (self)));
}