/* GDK - The GIMP Drawing Kit

 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * 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 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, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 

 */

#include "config.h"

#include <stdlib.h>

#import <Cocoa/Cocoa.h>

#include <Carbon/Carbon.h>

#include "gdkprivate-quartz.h"

#include "gdkscreen-quartz.h"

#include "gdkinput.h"

#include "gdkprivate.h"

#include "gdkinputprivate.h"

#define N_CORE_POINTER_AXES 2

#define N_INPUT_DEVICE_AXES 5

static GdkDeviceAxis gdk_input_core_axes[] = {

  { GDK_AXIS_X, 0, 0 },

  { GDK_AXIS_Y, 0, 0 }

};

static GdkDeviceAxis gdk_quartz_pen_axes[] = {

  { GDK_AXIS_X, 0, 0 },

  { GDK_AXIS_Y, 0, 0 },

  { GDK_AXIS_PRESSURE, 0, 1 },

  { GDK_AXIS_XTILT, -1, 1 },

  { GDK_AXIS_YTILT, -1, 1 }

};

static GdkDeviceAxis gdk_quartz_cursor_axes[] = {

  { GDK_AXIS_X, 0, 0 },

  { GDK_AXIS_Y, 0, 0 },

  { GDK_AXIS_PRESSURE, 0, 1 },

  { GDK_AXIS_XTILT, -1, 1 },

  { GDK_AXIS_YTILT, -1, 1 }

};

static GdkDeviceAxis gdk_quartz_eraser_axes[] = {

  { GDK_AXIS_X, 0, 0 },

  { GDK_AXIS_Y, 0, 0 },

  { GDK_AXIS_PRESSURE, 0, 1 },

  { GDK_AXIS_XTILT, -1, 1 },

  { GDK_AXIS_YTILT, -1, 1 }

};

/* Global variables  */

static GList     *_gdk_input_windows = NULL;

static GList     *_gdk_input_devices = NULL;

static GdkDevice *_gdk_core_pointer = NULL;

static GdkDevice *_gdk_quartz_pen = NULL;

static GdkDevice *_gdk_quartz_cursor = NULL;

static GdkDevice *_gdk_quartz_eraser = NULL;

static GdkDevice *active_device = NULL;

static void

gdk_device_finalize (GObject *object)

{

  g_error ("A GdkDevice object was finalized. This should not happen");

}

static void

gdk_device_class_init (GObjectClass *class)

{

  class->finalize = gdk_device_finalize;

}

GType

gdk_device_get_type (void)

{

  static GType object_type = 0;

  if (!object_type)

    {

      const GTypeInfo object_info =

      {

        sizeof (GdkDeviceClass),

        (GBaseInitFunc) NULL,

        (GBaseFinalizeFunc) NULL,

        (GClassInitFunc) gdk_device_class_init,

        NULL,           /* class_finalize */

        NULL,           /* class_data */

        sizeof (GdkDevicePrivate),

        0,              /* n_preallocs */

        (GInstanceInitFunc) NULL,

      };

      object_type = g_type_register_static (G_TYPE_OBJECT,

                                            "GdkDevice",

                                            &object_info, 0);

    }

  return object_type;

}

GList *

gdk_devices_list (void)

{

  return _gdk_input_devices;

}

GList *

gdk_display_list_devices (GdkDisplay *dpy)

{

  return _gdk_input_devices;

}

const gchar *

gdk_device_get_name (GdkDevice *device)

{

  g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);

  return device->name;

}

GdkInputSource

gdk_device_get_source (GdkDevice *device)

{

  g_return_val_if_fail (GDK_IS_DEVICE (device), 0);

  return device->source;

}

GdkInputMode

gdk_device_get_mode (GdkDevice *device)

{

  g_return_val_if_fail (GDK_IS_DEVICE (device), 0);

  return device->mode;

}

gboolean

gdk_device_get_has_cursor (GdkDevice *device)

{

  g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);

  return device->has_cursor;

}

void

gdk_device_set_source (GdkDevice *device,

		       GdkInputSource source)

{

  device->source = source;

}

void

gdk_device_get_key (GdkDevice       *device,

                    guint            index,

                    guint           *keyval,

                    GdkModifierType *modifiers)

{

  g_return_if_fail (GDK_IS_DEVICE (device));

  g_return_if_fail (index < device->num_keys);

  if (!device->keys[index].keyval &&

      !device->keys[index].modifiers)

    return;

  if (keyval)

    *keyval = device->keys[index].keyval;

  if (modifiers)

    *modifiers = device->keys[index].modifiers;

}

void

gdk_device_set_key (GdkDevice      *device,

		    guint           index,

		    guint           keyval,

		    GdkModifierType modifiers)

{

  g_return_if_fail (device != NULL);

  g_return_if_fail (index < device->num_keys);

  device->keys[index].keyval = keyval;

  device->keys[index].modifiers = modifiers;

}

GdkAxisUse

gdk_device_get_axis_use (GdkDevice *device,

                         guint      index)

{

  g_return_val_if_fail (GDK_IS_DEVICE (device), GDK_AXIS_IGNORE);

  g_return_val_if_fail (index < device->num_axes, GDK_AXIS_IGNORE);

  return device->axes[index].use;

}

gint

gdk_device_get_n_keys (GdkDevice *device)

{

  g_return_val_if_fail (GDK_IS_DEVICE (device), 0);

  return device->num_keys;

}

gint

gdk_device_get_n_axes (GdkDevice *device)

{

  g_return_val_if_fail (GDK_IS_DEVICE (device), 0);

  return device->num_axes;

}

void

gdk_device_set_axis_use (GdkDevice   *device,

                         guint        index,

                         GdkAxisUse   use)

{

#if 0

  /* Remapping axes is unsupported for now */

  g_return_if_fail (device != NULL);

  g_return_if_fail (index < device->num_axes);

  device->axes[index].use = use;

  switch (use)

    {

    case GDK_AXIS_X:

    case GDK_AXIS_Y:

      device->axes[index].min = 0.;

      device->axes[index].max = 0.;

      break;

    case GDK_AXIS_XTILT:

    case GDK_AXIS_YTILT:

      device->axes[index].min = -1.;

      device->axes[index].max = 1;

      break;

    default:

      device->axes[index].min = 0.;

      device->axes[index].max = 1;

      break;

    }

#endif

}

/**

 * gdk_input_set_device_state:

 * @device: The devices to set

 * @mask: The new button mask

 * @axes: The new axes values

 *

 * Set the state of a device's inputs for later

 * retrieval by gdk_device_get_state.

 */

static void

gdk_input_set_device_state (GdkDevice *device,

                            GdkModifierType mask,

                            gdouble *axes)

{

  GdkDevicePrivate *priv;

  gint i;

  if (device != _gdk_core_pointer)

    {

      priv = (GdkDevicePrivate *)device;

      priv->last_state = mask;

      for (i = 0; i < device->num_axes; ++i)

        priv->last_axes_state[i] = axes[i];

    }

}

void

gdk_device_get_state (GdkDevice       *device,

                      GdkWindow       *window,

                      gdouble         *axes,

                      GdkModifierType *mask)

{

  GdkDevicePrivate *priv;

  gint i;

  if (device == _gdk_core_pointer)

    {

      gint x_int, y_int;

      gdk_window_get_pointer (window, &x_int, &y_int, mask);

      if (axes)

        {

          axes[0] = x_int;

          axes[1] = y_int;

        }

    }

  else

    {

      priv = (GdkDevicePrivate *)device;

      if (mask)

        *mask = priv->last_state;

      if (axes)

        for (i = 0; i < device->num_axes; ++i)

          axes[i] = priv->last_axes_state[i];

    }

}

void 

gdk_device_free_history (GdkTimeCoord **events,

			 gint           n_events)

{

  gint i;

  for (i = 0; i < n_events; i++)

    g_free (events[i]);

  g_free (events);

}

gboolean

gdk_device_get_history  (GdkDevice         *device,

			 GdkWindow         *window,

			 guint32            start,

			 guint32            stop,

			 GdkTimeCoord    ***events,

			 gint              *n_events)

{

  g_return_val_if_fail (window != NULL, FALSE);

  g_return_val_if_fail (GDK_WINDOW_IS_QUARTZ (window), FALSE);

  g_return_val_if_fail (events != NULL, FALSE);

  g_return_val_if_fail (n_events != NULL, FALSE);

  *n_events = 0;

  *events = NULL;

  return FALSE;

}

gboolean

gdk_device_set_mode (GdkDevice   *device,

                     GdkInputMode mode)

{

  /* FIXME: Window mode isn't supported yet */

  if (device != _gdk_core_pointer &&

      (mode == GDK_MODE_DISABLED || mode == GDK_MODE_SCREEN))

    {

      device->mode = mode;

      return TRUE;

    }

  return FALSE;

}

gint

_gdk_input_enable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)

{

  return TRUE;

}

gint

_gdk_input_disable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)

{

  return TRUE;

}

GdkInputWindow *

_gdk_input_window_find(GdkWindow *window)

{

  GList *tmp_list;

  for (tmp_list=_gdk_input_windows; tmp_list; tmp_list=tmp_list->next)

    if (((GdkInputWindow *)(tmp_list->data))->window == window)

      return (GdkInputWindow *)(tmp_list->data);

  return NULL;      /* Not found */

}

/* FIXME: this routine currently needs to be called between creation

   and the corresponding configure event (because it doesn't get the

   root_relative_geometry).  This should work with

   gtk_window_set_extension_events, but will likely fail in other

   cases */

void

gdk_input_set_extension_events (GdkWindow *window, gint mask,

				GdkExtensionMode mode)

{

  GdkWindowObject *window_private;

  GList *tmp_list;

  GdkInputWindow *iw;

  g_return_if_fail (window != NULL);

  g_return_if_fail (GDK_WINDOW_IS_QUARTZ (window));

  window_private = (GdkWindowObject*) window;

  if (mode == GDK_EXTENSION_EVENTS_NONE)

    mask = 0;

  if (mask != 0)

    {

      iw = g_new(GdkInputWindow,1);

      iw->window = window;

      iw->mode = mode;

      iw->obscuring = NULL;

      iw->num_obscuring = 0;

      iw->grabbed = FALSE;

      _gdk_input_windows = g_list_append (_gdk_input_windows,iw);

      window_private->extension_events = mask;

      /* Add enter window events to the event mask */

      /* FIXME, this is not needed for XINPUT_NONE */

      gdk_window_set_events (window,

			     gdk_window_get_events (window) | 

			     GDK_ENTER_NOTIFY_MASK);

    }

  else

    {

      iw = _gdk_input_window_find (window);

      if (iw)

	{

	  _gdk_input_windows = g_list_remove (_gdk_input_windows,iw);

	  g_free (iw);

	}

      window_private->extension_events = 0;

    }

  for (tmp_list = _gdk_input_devices; tmp_list; tmp_list = tmp_list->next)

    {

      GdkDevicePrivate *gdkdev = (GdkDevicePrivate *)(tmp_list->data);

      if (gdkdev != (GdkDevicePrivate *)_gdk_core_pointer)

	{

	  if (mask != 0 && gdkdev->info.mode != GDK_MODE_DISABLED

	      && (gdkdev->info.has_cursor || mode == GDK_EXTENSION_EVENTS_ALL))

	    _gdk_input_enable_window (window,gdkdev);

	  else

	    _gdk_input_disable_window (window,gdkdev);

	}

    }

}

void

_gdk_input_window_destroy (GdkWindow *window)

{

  GdkInputWindow *input_window;

  input_window = _gdk_input_window_find (window);

  g_return_if_fail (input_window != NULL);

  _gdk_input_windows = g_list_remove (_gdk_input_windows,input_window);

  g_free (input_window);

}

void

_gdk_input_init (void)

{

  GdkDevicePrivate *priv;

  _gdk_core_pointer = g_object_new (GDK_TYPE_DEVICE, NULL);

  _gdk_core_pointer->name = "Core Pointer";

  _gdk_core_pointer->source = GDK_SOURCE_MOUSE;

  _gdk_core_pointer->mode = GDK_MODE_SCREEN;

  _gdk_core_pointer->has_cursor = TRUE;

  _gdk_core_pointer->num_axes = N_CORE_POINTER_AXES;

  _gdk_core_pointer->axes = gdk_input_core_axes;

  _gdk_core_pointer->num_keys = 0;

  _gdk_core_pointer->keys = NULL;

  _gdk_display->core_pointer = _gdk_core_pointer;

  _gdk_input_devices = g_list_append (NULL, _gdk_core_pointer);

  _gdk_quartz_pen = g_object_new (GDK_TYPE_DEVICE, NULL);

  _gdk_quartz_pen->name = "Quartz Pen";

  _gdk_quartz_pen->source = GDK_SOURCE_PEN;

  _gdk_quartz_pen->mode = GDK_MODE_SCREEN;

  _gdk_quartz_pen->has_cursor = TRUE;

  _gdk_quartz_pen->num_axes = N_INPUT_DEVICE_AXES;

  _gdk_quartz_pen->axes = gdk_quartz_pen_axes;

  _gdk_quartz_pen->num_keys = 0;

  _gdk_quartz_pen->keys = NULL;

  priv = (GdkDevicePrivate *)_gdk_quartz_pen;

  priv->last_axes_state = g_malloc_n (_gdk_quartz_pen->num_axes, sizeof (gdouble));

  _gdk_input_devices = g_list_append (_gdk_input_devices, _gdk_quartz_pen);

  _gdk_quartz_cursor = g_object_new (GDK_TYPE_DEVICE, NULL);

  _gdk_quartz_cursor->name = "Quartz Cursor";

  _gdk_quartz_cursor->source = GDK_SOURCE_CURSOR;

  _gdk_quartz_cursor->mode = GDK_MODE_SCREEN;

  _gdk_quartz_cursor->has_cursor = TRUE;

  _gdk_quartz_cursor->num_axes = N_INPUT_DEVICE_AXES;

  _gdk_quartz_cursor->axes = gdk_quartz_cursor_axes;

  _gdk_quartz_cursor->num_keys = 0;

  _gdk_quartz_cursor->keys = NULL;

  priv = (GdkDevicePrivate *)_gdk_quartz_cursor;

  priv->last_axes_state = g_malloc_n (_gdk_quartz_cursor->num_axes, sizeof (gdouble));

  _gdk_input_devices = g_list_append (_gdk_input_devices, _gdk_quartz_cursor);

  _gdk_quartz_eraser = g_object_new (GDK_TYPE_DEVICE, NULL);

  _gdk_quartz_eraser->name = "Quartz Eraser";

  _gdk_quartz_eraser->source = GDK_SOURCE_ERASER;

  _gdk_quartz_eraser->mode = GDK_MODE_SCREEN;

  _gdk_quartz_eraser->has_cursor = TRUE;

  _gdk_quartz_eraser->num_axes = N_INPUT_DEVICE_AXES;

  _gdk_quartz_eraser->axes = gdk_quartz_eraser_axes;

  _gdk_quartz_eraser->num_keys = 0;

  _gdk_quartz_eraser->keys = NULL;

  priv = (GdkDevicePrivate *)_gdk_quartz_eraser;

  priv->last_axes_state = g_malloc_n (_gdk_quartz_eraser->num_axes, sizeof (gdouble));

  _gdk_input_devices = g_list_append (_gdk_input_devices, _gdk_quartz_eraser);

  active_device = _gdk_core_pointer;

}

void

_gdk_input_exit (void)

{

  GList *tmp_list;

  GdkDevicePrivate *gdkdev;

  for (tmp_list = _gdk_input_devices; tmp_list; tmp_list = tmp_list->next)

    {

      gdkdev = (GdkDevicePrivate *)(tmp_list->data);

      if (gdkdev != (GdkDevicePrivate *)_gdk_core_pointer)

        {

          gdk_device_set_mode ((GdkDevice *)gdkdev, GDK_MODE_DISABLED);

          g_free (gdkdev->info.name);

          g_free (gdkdev->info.axes);

          g_free (gdkdev->info.keys);

          g_free (gdkdev->last_axes_state);

          g_free (gdkdev);

        }

    }

  g_list_free (_gdk_input_devices);

  for (tmp_list = _gdk_input_windows; tmp_list; tmp_list = tmp_list->next)

    {

      g_free (tmp_list->data);

    }

  g_list_free (_gdk_input_windows);

}

gboolean

gdk_device_get_axis (GdkDevice *device, gdouble *axes, GdkAxisUse use, gdouble *value)

{

  gint i;

  g_return_val_if_fail (device != NULL, FALSE);

  if (axes == NULL)

    return FALSE;

  for (i = 0; i < device->num_axes; i++)

    if (device->axes[i].use == use)

      {

	if (value)

	  *value = axes[i];

	return TRUE;

      }

  return FALSE;

}

void

_gdk_input_window_crossing (GdkWindow *window,

                            gboolean   enter)

{

}

/**

 * _gdk_input_quartz_tablet_proximity:

 * @deviceType: The result of [nsevent pointingDeviceType]

 *

 * Update the current active device based on a proximity event.

 */

void

_gdk_input_quartz_tablet_proximity (NSPointingDeviceType deviceType)

{

  if (deviceType == NSPenPointingDevice)

    active_device = _gdk_quartz_pen;

  else if (deviceType == NSCursorPointingDevice)

    active_device = _gdk_quartz_cursor;

  else if (deviceType == NSEraserPointingDevice)

    active_device = _gdk_quartz_eraser;

  else

    active_device = _gdk_core_pointer;

}

/**

 * _gdk_input_fill_quartz_input_event:

 * @event: The GDK mouse event.

 * @nsevent: The NSEvent that generated the mouse event.

 * @input_event: (out): Return location for the input event.

 *

 * Handle extended input for the passed event, the GdkEvent object

 * passed in should be a filled mouse button or motion event.

 *

 * Return value: %TRUE if an extended input event was generated.

 */

gboolean

_gdk_input_fill_quartz_input_event (GdkEvent *event,

                                    NSEvent  *nsevent,

                                    GdkEvent *input_event)

{

  gdouble *axes;

  gint x, y;

  gint x_target, y_target;

  gdouble x_root, y_root;

  gint state;

  GdkInputWindow *iw;

  GdkWindow *target_window;

  GdkScreenQuartz *screen_quartz;

  if ([nsevent subtype] == NSTabletProximityEventSubtype)

    {

      _gdk_input_quartz_tablet_proximity ([nsevent pointingDeviceType]);

    }

  else if (([nsevent subtype] != NSTabletPointEventSubtype) ||

           (active_device == _gdk_core_pointer) ||

           (active_device->mode == GDK_MODE_DISABLED))

    {

      _gdk_display->ignore_core_events = FALSE;

      return FALSE;

    }

  switch (event->any.type)

    {

      case GDK_MOTION_NOTIFY:

        x = event->motion.x;

        y = event->motion.y;

        state = event->motion.state;

        break;

      case GDK_BUTTON_PRESS:

      case GDK_BUTTON_RELEASE:

        x = event->button.x;

        y = event->button.y;

        state = event->button.state;

        break;

      default:

        /* Not an input related event */

        return FALSE;

        break;

    }

  /* Input events won't be propagated through windows that aren't listening

   * for input events, so _gdk_window_get_input_window_for_event finds the

   * window to directly send the event to.

   */

  target_window = _gdk_window_get_input_window_for_event (event->any.window,

                                                          event->any.type,

                                                          0, x, y, 0);

  iw = _gdk_input_window_find (target_window);

  if (!iw)

    {

      /* Return if the target window doesn't have extended events enabled or

       * hasn't asked for this type of event.

       */

      _gdk_display->ignore_core_events = FALSE;

      return FALSE;

    }

  /* The cursor is inside an extended events window, block propagation of the

   * core motion / button events

   */

  _gdk_display->ignore_core_events = TRUE;

  axes = g_malloc_n (N_INPUT_DEVICE_AXES, sizeof (gdouble));

  gdk_window_get_origin (target_window, &x_target, &y_target);

  /* Equation for root x & y taken from _gdk_quartz_window_xy_to_gdk_xy

   * recalculated here to get doubles instead of ints.

   */

  screen_quartz = GDK_SCREEN_QUARTZ (_gdk_screen);

  x_root = [NSEvent mouseLocation].x - screen_quartz->min_x;

  y_root = screen_quartz->height - [NSEvent mouseLocation].y + screen_quartz->min_y;

  axes[0] = x_root - x_target;

  axes[1] = y_root - y_target;

  axes[2] = [nsevent pressure];

  axes[3] = [nsevent tilt].x;

  axes[4] = [nsevent tilt].y;

  gdk_input_set_device_state (active_device, state, axes);

  input_event->any.window     = target_window;

  input_event->any.type       = event->any.type;

  input_event->any.send_event = event->any.send_event;

  switch (event->any.type)

    {

      case GDK_MOTION_NOTIFY:

        input_event->motion.device = active_device;

        input_event->motion.x      = axes[0];

        input_event->motion.y      = axes[1];

        input_event->motion.axes   = axes;

        input_event->motion.x_root = x_root;

        input_event->motion.y_root = y_root;

        input_event->motion.time    = event->motion.time;

        input_event->motion.state   = event->motion.state;

        input_event->motion.is_hint = event->motion.is_hint;

        break;

      case GDK_BUTTON_PRESS:

      case GDK_BUTTON_RELEASE:

        input_event->button.device = active_device;

        input_event->button.x      = axes[0];

        input_event->button.y      = axes[1];

        input_event->button.axes   = axes;

        input_event->button.x_root = x_root;

        input_event->button.y_root = y_root;

        input_event->button.time   = event->button.time;

        input_event->button.state  = event->button.state;

        input_event->button.button = event->button.button;

        break;

      default:

        return FALSE;

        break;

    }

  return TRUE;

}