/* 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 <string.h>		/* For memset() */

#include "gdk.h"

#include "gdkinternals.h"

#include "gdkalias.h"

typedef struct _GdkIOClosure GdkIOClosure;

struct _GdkIOClosure

{

  GdkInputFunction function;

  GdkInputCondition condition;

  GDestroyNotify notify;

  gpointer data;

};

/* Private variable declarations

 */

GdkEventFunc   _gdk_event_func = NULL;    /* Callback for events */

gpointer       _gdk_event_data = NULL;

GDestroyNotify _gdk_event_notify = NULL;

/*********************************************

 * Functions for maintaining the event queue *

 *********************************************/

/**

 * _gdk_event_queue_find_first:

 * @display: a #GdkDisplay

 * 

 * Find the first event on the queue that is not still

 * being filled in.

 * 

 * Return value: Pointer to the list node for that event, or NULL.

 **/

GList*

_gdk_event_queue_find_first (GdkDisplay *display)

{

  GList *tmp_list = display->queued_events;

  while (tmp_list)

    {

      GdkEventPrivate *event = tmp_list->data;

      if (!(event->flags & GDK_EVENT_PENDING))

	return tmp_list;

      tmp_list = g_list_next (tmp_list);

    }

  return NULL;

}

/**

 * _gdk_event_queue_prepend:

 * @display: a #GdkDisplay

 * @event: Event to prepend.

 *

 * Prepends an event before the head of the event queue.

 *

 * Returns: the newly prepended list node.

 **/

GList*

_gdk_event_queue_prepend (GdkDisplay *display,

			  GdkEvent   *event)

{

  display->queued_events = g_list_prepend (display->queued_events, event);

  if (!display->queued_tail)

    display->queued_tail = display->queued_events;

  return display->queued_events;

}

/**

 * _gdk_event_queue_append:

 * @display: a #GdkDisplay

 * @event: Event to append.

 * 

 * Appends an event onto the tail of the event queue.

 *

 * Returns: the newly appended list node.

 **/

GList *

_gdk_event_queue_append (GdkDisplay *display,

			 GdkEvent   *event)

{

  display->queued_tail = g_list_append (display->queued_tail, event);

  if (!display->queued_events)

    display->queued_events = display->queued_tail;

  else

    display->queued_tail = display->queued_tail->next;

  return display->queued_tail;

}

/**

 * _gdk_event_queue_insert_after:

 * @display: a #GdkDisplay

 * @sibling: Append after this event.

 * @event: Event to append.

 *

 * Appends an event after the specified event, or if it isn't in

 * the queue, onto the tail of the event queue.

 *

 * Returns: the newly appended list node.

 *

 * Since: 2.16

 */

GList*

_gdk_event_queue_insert_after (GdkDisplay *display,

                               GdkEvent   *sibling,

                               GdkEvent   *event)

{

  GList *prev = g_list_find (display->queued_events, sibling);

  if (prev && prev->next)

    {

      display->queued_events = g_list_insert_before (display->queued_events, prev->next, event);

      return prev->next;

    }

  else

    return _gdk_event_queue_append (display, event);

}

/**

 * _gdk_event_queue_insert_after:

 * @display: a #GdkDisplay

 * @sibling: Append after this event.

 * @event: Event to append.

 *

 * Appends an event before the specified event, or if it isn't in

 * the queue, onto the tail of the event queue.

 *

 * Returns: the newly appended list node.

 *

 * Since: 2.16

 */

GList*

_gdk_event_queue_insert_before (GdkDisplay *display,

				GdkEvent   *sibling,

				GdkEvent   *event)

{

  GList *next = g_list_find (display->queued_events, sibling);

  if (next)

    {

      display->queued_events = g_list_insert_before (display->queued_events, next, event);

      return next->prev;

    }

  else

    return _gdk_event_queue_append (display, event);

}

/**

 * _gdk_event_queue_remove_link:

 * @display: a #GdkDisplay

 * @node: node to remove

 * 

 * Removes a specified list node from the event queue.

 **/

void

_gdk_event_queue_remove_link (GdkDisplay *display,

			      GList      *node)

{

  if (node->prev)

    node->prev->next = node->next;

  else

    display->queued_events = node->next;

  if (node->next)

    node->next->prev = node->prev;

  else

    display->queued_tail = node->prev;

}

/**

 * _gdk_event_unqueue:

 * @display: a #GdkDisplay

 * 

 * Removes and returns the first event from the event

 * queue that is not still being filled in.

 * 

 * Return value: the event, or %NULL. Ownership is transferred

 * to the caller.

 **/

GdkEvent*

_gdk_event_unqueue (GdkDisplay *display)

{

  GdkEvent *event = NULL;

  GList *tmp_list;

  tmp_list = _gdk_event_queue_find_first (display);

  if (tmp_list)

    {

      event = tmp_list->data;

      _gdk_event_queue_remove_link (display, tmp_list);

      g_list_free_1 (tmp_list);

    }

  return event;

}

/**

 * gdk_event_handler_set:

 * @func: the function to call to handle events from GDK.

 * @data: user data to pass to the function. 

 * @notify: the function to call when the handler function is removed, i.e. when

 *          gdk_event_handler_set() is called with another event handler.

 * 

 * Sets the function to call to handle all events from GDK.

 *

 * Note that GTK+ uses this to install its own event handler, so it is

 * usually not useful for GTK+ applications. (Although an application

 * can call this function then call gtk_main_do_event() to pass

 * events to GTK+.)

 **/

void 

gdk_event_handler_set (GdkEventFunc   func,

		       gpointer       data,

		       GDestroyNotify notify)

{

  if (_gdk_event_notify)

    (*_gdk_event_notify) (_gdk_event_data);

  _gdk_event_func = func;

  _gdk_event_data = data;

  _gdk_event_notify = notify;

}

/**

 * gdk_event_get:

 * 

 * Checks all open displays for a #GdkEvent to process,to be processed

 * on, fetching events from the windowing system if necessary.

 * See gdk_display_get_event().

 * 

 * Return value: the next #GdkEvent to be processed, or %NULL if no events

 * are pending. The returned #GdkEvent should be freed with gdk_event_free().

 **/

GdkEvent*

gdk_event_get (void)

{

  GSList *tmp_list;

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

    {

      GdkEvent *event = gdk_display_get_event (tmp_list->data);

      if (event)

	return event;

    }

  return NULL;

}

/**

 * gdk_event_peek:

 *

 * If there is an event waiting in the event queue of some open

 * display, returns a copy of it. See gdk_display_peek_event().

 * 

 * Return value: a copy of the first #GdkEvent on some event queue, or %NULL if no

 * events are in any queues. The returned #GdkEvent should be freed with

 * gdk_event_free().

 **/

GdkEvent*

gdk_event_peek (void)

{

  GSList *tmp_list;

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

    {

      GdkEvent *event = gdk_display_peek_event (tmp_list->data);

      if (event)

	return event;

    }

  return NULL;

}

/**

 * gdk_event_put:

 * @event: a #GdkEvent.

 *

 * Appends a copy of the given event onto the front of the event

 * queue for event->any.window's display, or the default event

 * queue if event->any.window is %NULL. See gdk_display_put_event().

 **/

void

gdk_event_put (const GdkEvent *event)

{

  GdkDisplay *display;

  g_return_if_fail (event != NULL);

  if (event->any.window)

    display = gdk_drawable_get_display (event->any.window);

  else

    {

      GDK_NOTE (MULTIHEAD,

		g_message ("Falling back to default display for gdk_event_put()"));

      display = gdk_display_get_default ();

    }

  gdk_display_put_event (display, event);

}

static GHashTable *event_hash = NULL;

/**

 * gdk_event_new:

 * @type: a #GdkEventType 

 * 

 * Creates a new event of the given type. All fields are set to 0.

 * 

 * Return value: a newly-allocated #GdkEvent. The returned #GdkEvent 

 * should be freed with gdk_event_free().

 *

 * Since: 2.2

 **/

GdkEvent*

gdk_event_new (GdkEventType type)

{

  GdkEventPrivate *new_private;

  GdkEvent *new_event;

  if (!event_hash)

    event_hash = g_hash_table_new (g_direct_hash, NULL);

  new_private = g_slice_new0 (GdkEventPrivate);

  new_private->flags = 0;

  new_private->screen = NULL;

  g_hash_table_insert (event_hash, new_private, GUINT_TO_POINTER (1));

  new_event = (GdkEvent *) new_private;

  new_event->any.type = type;

  /*

   * Bytewise 0 initialization is reasonable for most of the 

   * current event types. Explicitely initialize double fields

   * since I trust bytewise 0 == 0. less than for integers

   * or pointers.

   */

  switch (type)

    {

    case GDK_MOTION_NOTIFY:

      new_event->motion.x = 0.;

      new_event->motion.y = 0.;

      new_event->motion.x_root = 0.;

      new_event->motion.y_root = 0.;

      break;

    case GDK_BUTTON_PRESS:

    case GDK_2BUTTON_PRESS:

    case GDK_3BUTTON_PRESS:

    case GDK_BUTTON_RELEASE:

      new_event->button.x = 0.;

      new_event->button.y = 0.;

      new_event->button.x_root = 0.;

      new_event->button.y_root = 0.;

      break;

    case GDK_SCROLL:

      new_event->scroll.x = 0.;

      new_event->scroll.y = 0.;

      new_event->scroll.x_root = 0.;

      new_event->scroll.y_root = 0.;

      break;

    case GDK_ENTER_NOTIFY:

    case GDK_LEAVE_NOTIFY:

      new_event->crossing.x = 0.;

      new_event->crossing.y = 0.;

      new_event->crossing.x_root = 0.;

      new_event->crossing.y_root = 0.;

      break;

    default:

      break;

    }

  return new_event;

}

static gboolean

gdk_event_is_allocated (const GdkEvent *event)

{

  if (event_hash)

    return g_hash_table_lookup (event_hash, event) != NULL;

  return FALSE;

}

/**

 * gdk_event_copy:

 * @event: a #GdkEvent

 * 

 * Copies a #GdkEvent, copying or incrementing the reference count of the

 * resources associated with it (e.g. #GdkWindow's and strings).

 * 

 * Return value: a copy of @event. The returned #GdkEvent should be freed with

 * gdk_event_free().

 **/

GdkEvent*

gdk_event_copy (const GdkEvent *event)

{

  GdkEventPrivate *new_private;

  GdkEvent *new_event;

  g_return_val_if_fail (event != NULL, NULL);

  new_event = gdk_event_new (GDK_NOTHING);

  new_private = (GdkEventPrivate *)new_event;

  *new_event = *event;

  if (new_event->any.window)

    g_object_ref (new_event->any.window);

  if (gdk_event_is_allocated (event))

    {

      GdkEventPrivate *private = (GdkEventPrivate *)event;

      new_private->screen = private->screen;

    }

  switch (event->any.type)

    {

    case GDK_KEY_PRESS:

    case GDK_KEY_RELEASE:

      new_event->key.string = g_strdup (event->key.string);

      break;

    case GDK_ENTER_NOTIFY:

    case GDK_LEAVE_NOTIFY:

      if (event->crossing.subwindow != NULL)

	g_object_ref (event->crossing.subwindow);

      break;

    case GDK_DRAG_ENTER:

    case GDK_DRAG_LEAVE:

    case GDK_DRAG_MOTION:

    case GDK_DRAG_STATUS:

    case GDK_DROP_START:

    case GDK_DROP_FINISHED:

      g_object_ref (event->dnd.context);

      break;

    case GDK_EXPOSE:

    case GDK_DAMAGE:

      if (event->expose.region)

	new_event->expose.region = gdk_region_copy (event->expose.region);

      break;

    case GDK_SETTING:

      new_event->setting.name = g_strdup (new_event->setting.name);

      break;

    case GDK_BUTTON_PRESS:

    case GDK_BUTTON_RELEASE:

      if (event->button.axes) 

	new_event->button.axes = g_memdup (event->button.axes, 

					     sizeof (gdouble) * event->button.device->num_axes);

      break;

    case GDK_MOTION_NOTIFY:

      if (event->motion.axes) 

	new_event->motion.axes = g_memdup (event->motion.axes, 

					   sizeof (gdouble) * event->motion.device->num_axes);

      break;

    default:

      break;

    }

  if (gdk_event_is_allocated (event))

    _gdk_windowing_event_data_copy (event, new_event);

  return new_event;

}

/**

 * gdk_event_free:

 * @event:  a #GdkEvent.

 * 

 * Frees a #GdkEvent, freeing or decrementing any resources associated with it.

 * Note that this function should only be called with events returned from

 * functions such as gdk_event_peek(), gdk_event_get(),

 * gdk_event_get_graphics_expose() and gdk_event_copy() and gdk_event_new().

 **/

void

gdk_event_free (GdkEvent *event)

{

  g_return_if_fail (event != NULL);

  if (event->any.window)

    g_object_unref (event->any.window);

  switch (event->any.type)

    {

    case GDK_KEY_PRESS:

    case GDK_KEY_RELEASE:

      g_free (event->key.string);

      break;

    case GDK_ENTER_NOTIFY:

    case GDK_LEAVE_NOTIFY:

      if (event->crossing.subwindow != NULL)

	g_object_unref (event->crossing.subwindow);

      break;

    case GDK_DRAG_ENTER:

    case GDK_DRAG_LEAVE:

    case GDK_DRAG_MOTION:

    case GDK_DRAG_STATUS:

    case GDK_DROP_START:

    case GDK_DROP_FINISHED:

      g_object_unref (event->dnd.context);

      break;

    case GDK_BUTTON_PRESS:

    case GDK_BUTTON_RELEASE:

      g_free (event->button.axes);

      break;

    case GDK_EXPOSE:

    case GDK_DAMAGE:

      if (event->expose.region)

	gdk_region_destroy (event->expose.region);

      break;

    case GDK_MOTION_NOTIFY:

      g_free (event->motion.axes);

      break;

    case GDK_SETTING:

      g_free (event->setting.name);

      break;

    default:

      break;

    }

  _gdk_windowing_event_data_free (event);

  g_hash_table_remove (event_hash, event);

  g_slice_free (GdkEventPrivate, (GdkEventPrivate*) event);

}

/**

 * gdk_event_get_time:

 * @event: a #GdkEvent

 * 

 * Returns the time stamp from @event, if there is one; otherwise

 * returns #GDK_CURRENT_TIME. If @event is %NULL, returns #GDK_CURRENT_TIME.

 * 

 * Return value: time stamp field from @event

 **/

guint32

gdk_event_get_time (const GdkEvent *event)

{

  if (event)

    switch (event->type)

      {

      case GDK_MOTION_NOTIFY:

	return event->motion.time;

      case GDK_BUTTON_PRESS:

      case GDK_2BUTTON_PRESS:

      case GDK_3BUTTON_PRESS:

      case GDK_BUTTON_RELEASE:

	return event->button.time;

      case GDK_SCROLL:

        return event->scroll.time;

      case GDK_KEY_PRESS:

      case GDK_KEY_RELEASE:

	return event->key.time;

      case GDK_ENTER_NOTIFY:

      case GDK_LEAVE_NOTIFY:

	return event->crossing.time;

      case GDK_PROPERTY_NOTIFY:

	return event->property.time;

      case GDK_SELECTION_CLEAR:

      case GDK_SELECTION_REQUEST:

      case GDK_SELECTION_NOTIFY:

	return event->selection.time;

      case GDK_PROXIMITY_IN:

      case GDK_PROXIMITY_OUT:

	return event->proximity.time;

      case GDK_DRAG_ENTER:

      case GDK_DRAG_LEAVE:

      case GDK_DRAG_MOTION:

      case GDK_DRAG_STATUS:

      case GDK_DROP_START:

      case GDK_DROP_FINISHED:

	return event->dnd.time;

      case GDK_CLIENT_EVENT:

      case GDK_VISIBILITY_NOTIFY:

      case GDK_NO_EXPOSE:

      case GDK_CONFIGURE:

      case GDK_FOCUS_CHANGE:

      case GDK_NOTHING:

      case GDK_DAMAGE:

      case GDK_DELETE:

      case GDK_DESTROY:

      case GDK_EXPOSE:

      case GDK_MAP:

      case GDK_UNMAP:

      case GDK_WINDOW_STATE:

      case GDK_SETTING:

      case GDK_OWNER_CHANGE:

      case GDK_GRAB_BROKEN:

      case GDK_EVENT_LAST:

        /* return current time */

        break;

      }

  return GDK_CURRENT_TIME;

}

/**

 * gdk_event_get_state:

 * @event: a #GdkEvent or NULL

 * @state: (out): return location for state

 * 

 * If the event contains a "state" field, puts that field in @state. Otherwise

 * stores an empty state (0). Returns %TRUE if there was a state field

 * in the event. @event may be %NULL, in which case it's treated

 * as if the event had no state field.

 * 

 * Return value: %TRUE if there was a state field in the event 

 **/

gboolean

gdk_event_get_state (const GdkEvent        *event,

                     GdkModifierType       *state)

{

  g_return_val_if_fail (state != NULL, FALSE);

  if (event)

    switch (event->type)

      {

      case GDK_MOTION_NOTIFY:

	*state = event->motion.state;

        return TRUE;

      case GDK_BUTTON_PRESS:

      case GDK_2BUTTON_PRESS:

      case GDK_3BUTTON_PRESS:

      case GDK_BUTTON_RELEASE:

        *state =  event->button.state;

        return TRUE;

      case GDK_SCROLL:

	*state =  event->scroll.state;

        return TRUE;

      case GDK_KEY_PRESS:

      case GDK_KEY_RELEASE:

	*state =  event->key.state;

        return TRUE;

      case GDK_ENTER_NOTIFY:

      case GDK_LEAVE_NOTIFY:

	*state =  event->crossing.state;

        return TRUE;

      case GDK_PROPERTY_NOTIFY:

	*state =  event->property.state;

        return TRUE;

      case GDK_VISIBILITY_NOTIFY:

      case GDK_CLIENT_EVENT:

      case GDK_NO_EXPOSE:

      case GDK_CONFIGURE:

      case GDK_FOCUS_CHANGE:

      case GDK_SELECTION_CLEAR:

      case GDK_SELECTION_REQUEST:

      case GDK_SELECTION_NOTIFY:

      case GDK_PROXIMITY_IN:

      case GDK_PROXIMITY_OUT:

      case GDK_DAMAGE:

      case GDK_DRAG_ENTER:

      case GDK_DRAG_LEAVE:

      case GDK_DRAG_MOTION:

      case GDK_DRAG_STATUS:

      case GDK_DROP_START:

      case GDK_DROP_FINISHED:

      case GDK_NOTHING:

      case GDK_DELETE:

      case GDK_DESTROY:

      case GDK_EXPOSE:

      case GDK_MAP:

      case GDK_UNMAP:

      case GDK_WINDOW_STATE:

      case GDK_SETTING:

      case GDK_OWNER_CHANGE:

      case GDK_GRAB_BROKEN:

      case GDK_EVENT_LAST:

        /* no state field */

        break;

      }

  *state = 0;

  return FALSE;

}

/**

 * gdk_event_get_coords:

 * @event: a #GdkEvent

 * @x_win: (out): location to put event window x coordinate

 * @y_win: (out): location to put event window y coordinate

 * 

 * Extract the event window relative x/y coordinates from an event.

 * 

 * Return value: %TRUE if the event delivered event window coordinates

 **/

gboolean

gdk_event_get_coords (const GdkEvent *event,

		      gdouble        *x_win,

		      gdouble        *y_win)

{

  gdouble x = 0, y = 0;

  gboolean fetched = TRUE;

  g_return_val_if_fail (event != NULL, FALSE);

  switch (event->type)

    {

    case GDK_CONFIGURE:

      x = event->configure.x;

      y = event->configure.y;

      break;

    case GDK_ENTER_NOTIFY:

    case GDK_LEAVE_NOTIFY:

      x = event->crossing.x;

      y = event->crossing.y;

      break;

    case GDK_SCROLL:

      x = event->scroll.x;

      y = event->scroll.y;

      break;

    case GDK_BUTTON_PRESS:

    case GDK_2BUTTON_PRESS:

    case GDK_3BUTTON_PRESS:

    case GDK_BUTTON_RELEASE:

      x = event->button.x;

      y = event->button.y;

      break;

    case GDK_MOTION_NOTIFY:

      x = event->motion.x;

      y = event->motion.y;

      break;

    default:

      fetched = FALSE;

      break;

    }

  if (x_win)

    *x_win = x;

  if (y_win)

    *y_win = y;

  return fetched;

}

/**

 * gdk_event_get_root_coords:

 * @event: a #GdkEvent

 * @x_root: (out): location to put root window x coordinate

 * @y_root: (out): location to put root window y coordinate

 * 

 * Extract the root window relative x/y coordinates from an event.

 * 

 * Return value: %TRUE if the event delivered root window coordinates

 **/

gboolean

gdk_event_get_root_coords (const GdkEvent *event,

			   gdouble        *x_root,

			   gdouble        *y_root)

{

  gdouble x = 0, y = 0;

  gboolean fetched = TRUE;

  g_return_val_if_fail (event != NULL, FALSE);

  switch (event->type)

    {

    case GDK_MOTION_NOTIFY:

      x = event->motion.x_root;

      y = event->motion.y_root;

      break;

    case GDK_SCROLL:

      x = event->scroll.x_root;

      y = event->scroll.y_root;

      break;

    case GDK_BUTTON_PRESS:

    case GDK_2BUTTON_PRESS:

    case GDK_3BUTTON_PRESS:

    case GDK_BUTTON_RELEASE:

      x = event->button.x_root;

      y = event->button.y_root;

      break;

    case GDK_ENTER_NOTIFY:

    case GDK_LEAVE_NOTIFY:

      x = event->crossing.x_root;

      y = event->crossing.y_root;

      break;

    case GDK_DRAG_ENTER:

    case GDK_DRAG_LEAVE:

    case GDK_DRAG_MOTION:

    case GDK_DRAG_STATUS:

    case GDK_DROP_START:

    case GDK_DROP_FINISHED:

      x = event->dnd.x_root;

      y = event->dnd.y_root;

      break;

    default:

      fetched = FALSE;

      break;

    }

  if (x_root)

    *x_root = x;

  if (y_root)

    *y_root = y;

  return fetched;

}

/**

 * gdk_event_get_axis:

 * @event: a #GdkEvent

 * @axis_use: the axis use to look for

 * @value: (out): location to store the value found

 * 

 * Extract the axis value for a particular axis use from

 * an event structure.

 * 

 * Return value: %TRUE if the specified axis was found, otherwise %FALSE

 **/

gboolean

gdk_event_get_axis (const GdkEvent *event,

		    GdkAxisUse      axis_use,

		    gdouble        *value)

{

  gdouble *axes;

  GdkDevice *device;

  g_return_val_if_fail (event != NULL, FALSE);

  if (axis_use == GDK_AXIS_X || axis_use == GDK_AXIS_Y)

    {

      gdouble x, y;

      switch (event->type)

	{

	case GDK_MOTION_NOTIFY:

	  x = event->motion.x;

	  y = event->motion.y;

	  break;

	case GDK_SCROLL:

	  x = event->scroll.x;