/*

 * Clutter.

 *

 * An OpenGL based 'interactive canvas' library.

 *

 * Authored By Matthew Allum  <mallum@openedhand.com>

 *

 * Copyright (C) 2006 OpenedHand

 *

 * 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, see <http://www.gnu.org/licenses/>.

 *

 *

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "clutter-backend-private.h"

#include "clutter-debug.h"

#include "clutter-event-private.h"

#include "clutter-keysyms.h"

#include "clutter-private.h"

#include <math.h>

/**

 * SECTION:clutter-event

 * @short_description: User and window system events

 *

 * Windowing events handled by Clutter.

 *

 * The events usually come from the windowing backend, but can also

 * be synthesized by Clutter itself or by the application code.

 */

typedef struct _ClutterEventPrivate {

  ClutterEvent base;

  ClutterInputDevice *device;

  ClutterInputDevice *source_device;

  gdouble delta_x;

  gdouble delta_y;

  gpointer platform_data;

  ClutterModifierType button_state;

  ClutterModifierType base_state;

  ClutterModifierType latched_state;

  ClutterModifierType locked_state;

  guint is_pointer_emulated : 1;

} ClutterEventPrivate;

typedef struct _ClutterEventFilter {

  int id;

  ClutterStage *stage;

  ClutterEventFilterFunc func;

  GDestroyNotify notify;

  gpointer user_data;

} ClutterEventFilter;

static GHashTable *all_events = NULL;

G_DEFINE_BOXED_TYPE (ClutterEvent, clutter_event,

                     clutter_event_copy,

                     clutter_event_free);

static ClutterEventSequence *

clutter_event_sequence_copy (ClutterEventSequence *sequence)

{

  /* Nothing to copy here */

  return sequence;

}

static void

clutter_event_sequence_free (ClutterEventSequence *sequence)

{

  /* Nothing to free here */

}

G_DEFINE_BOXED_TYPE (ClutterEventSequence, clutter_event_sequence,

                     clutter_event_sequence_copy,

                     clutter_event_sequence_free);

static gboolean

is_event_allocated (const ClutterEvent *event)

{

  if (all_events == NULL)

    return FALSE;

  return g_hash_table_lookup (all_events, event) != NULL;

}

/*

 * _clutter_event_get_platform_data:

 * @event: a #ClutterEvent

 *

 * Retrieves the pointer to platform-specific data inside an event

 *

 * Return value: a pointer to platform-specific data

 *

 * Since: 1.4

 */

gpointer

_clutter_event_get_platform_data (const ClutterEvent *event)

{

  if (!is_event_allocated (event))

    return NULL;

  return ((ClutterEventPrivate *) event)->platform_data;

}

/*< private >

 * _clutter_event_set_platform_data:

 * @event: a #ClutterEvent

 * @data: a pointer to platform-specific data

 *

 * Sets the pointer to platform-specific data inside an event

 *

 * Since: 1.4

 */

void

_clutter_event_set_platform_data (ClutterEvent *event,

                                  gpointer      data)

{

  if (!is_event_allocated (event))

    return;

  ((ClutterEventPrivate *) event)->platform_data = data;

}

void

_clutter_event_set_pointer_emulated (ClutterEvent *event,

                                     gboolean      is_emulated)

{

  if (!is_event_allocated (event))

    return;

  ((ClutterEventPrivate *) event)->is_pointer_emulated = !!is_emulated;

}

/**

 * clutter_event_type:

 * @event: a #ClutterEvent

 *

 * Retrieves the type of the event.

 *

 * Return value: a #ClutterEventType

 */

ClutterEventType

clutter_event_type (const ClutterEvent *event)

{

  g_return_val_if_fail (event != NULL, CLUTTER_NOTHING);

  return event->type;

}

/**

 * clutter_event_get_time:

 * @event: a #ClutterEvent

 *

 * Retrieves the time of the event.

 *

 * Return value: the time of the event, or %CLUTTER_CURRENT_TIME

 *

 * Since: 0.4

 */

guint32

clutter_event_get_time (const ClutterEvent *event)

{

  g_return_val_if_fail (event != NULL, CLUTTER_CURRENT_TIME);

  return event->any.time;

}

/**

 * clutter_event_set_time:

 * @event: a #ClutterEvent

 * @time_: the time of the event

 *

 * Sets the time of the event.

 *

 * Since: 1.8

 */

void

clutter_event_set_time (ClutterEvent *event,

                        guint32       time_)

{

  g_return_if_fail (event != NULL);

  event->any.time = time_;

}

/**

 * clutter_event_get_state:

 * @event: a #ClutterEvent

 *

 * Retrieves the modifier state of the event. In case the window system

 * supports reporting latched and locked modifiers, this function returns

 * the effective state.

 *

 * Return value: the modifier state parameter, or 0

 *

 * Since: 0.4

 */

ClutterModifierType

clutter_event_get_state (const ClutterEvent *event)

{

  g_return_val_if_fail (event != NULL, 0);

  switch (event->type)

    {

    case CLUTTER_KEY_PRESS:

    case CLUTTER_KEY_RELEASE:

      return event->key.modifier_state;

    case CLUTTER_BUTTON_PRESS:

    case CLUTTER_BUTTON_RELEASE:

      return event->button.modifier_state;

    case CLUTTER_TOUCH_BEGIN:

    case CLUTTER_TOUCH_UPDATE:

    case CLUTTER_TOUCH_END:

    case CLUTTER_TOUCH_CANCEL:

      return event->touch.modifier_state;

    case CLUTTER_MOTION:

      return event->motion.modifier_state;

    case CLUTTER_SCROLL:

      return event->scroll.modifier_state;

    default:

      break;

    }

  return 0;

}

/**

 * clutter_event_set_state:

 * @event: a #ClutterEvent

 * @state: the modifier state to set

 *

 * Sets the modifier state of the event.

 *

 * Since: 1.8

 */

void

clutter_event_set_state (ClutterEvent        *event,

                         ClutterModifierType  state)

{

  g_return_if_fail (event != NULL);

  switch (event->type)

    {

    case CLUTTER_KEY_PRESS:

    case CLUTTER_KEY_RELEASE:

      event->key.modifier_state = state;

      break;

    case CLUTTER_BUTTON_PRESS:

    case CLUTTER_BUTTON_RELEASE:

      event->button.modifier_state = state;

      break;

    case CLUTTER_MOTION:

      event->motion.modifier_state = state;

      break;

    case CLUTTER_TOUCH_BEGIN:

    case CLUTTER_TOUCH_UPDATE:

    case CLUTTER_TOUCH_END:

    case CLUTTER_TOUCH_CANCEL:

      event->touch.modifier_state = state;

      break;

    case CLUTTER_SCROLL:

      event->scroll.modifier_state = state;

      break;

    default:

      break;

    }

}

void

_clutter_event_set_state_full (ClutterEvent        *event,

			       ClutterModifierType  button_state,

			       ClutterModifierType  base_state,

			       ClutterModifierType  latched_state,

			       ClutterModifierType  locked_state,

			       ClutterModifierType  effective_state)

{

  ClutterEventPrivate *private = (ClutterEventPrivate*) event;

  private->button_state = button_state;

  private->base_state = base_state;

  private->latched_state = latched_state;

  private->locked_state = locked_state;

  clutter_event_set_state (event, effective_state);

}

/**

 * clutter_event_get_state_full:

 * @event: a #ClutterEvent

 * @button_state: (out) (allow-none): the pressed buttons as a mask

 * @base_state: (out) (allow-none): the regular pressed modifier keys

 * @latched_state: (out) (allow-none): the latched modifier keys (currently released but still valid for one key press/release)

 * @locked_state: (out) (allow-none): the locked modifier keys (valid until the lock key is pressed and released again)

 * @effective_state: (out) (allow-none): the logical OR of all the state bits above

 *

 * Retrieves the decomposition of the keyboard state into button, base,

 * latched, locked and effective. This can be used to transmit to other

 * applications, for example when implementing a wayland compositor.

 *

 * Since: 1.16

 */

void

clutter_event_get_state_full (const ClutterEvent  *event,

			      ClutterModifierType *button_state,

			      ClutterModifierType *base_state,

			      ClutterModifierType *latched_state,

			      ClutterModifierType *locked_state,

			      ClutterModifierType *effective_state)

{

  const ClutterEventPrivate *private = (const ClutterEventPrivate*) event;

  g_return_if_fail (event != NULL);

  if (button_state)

    *button_state = private->button_state;

  if (base_state)

    *base_state = private->base_state;

  if (latched_state)

    *latched_state = private->latched_state;

  if (locked_state)

    *locked_state = private->locked_state;

  if (effective_state)

    *effective_state = clutter_event_get_state (event);

}

/**

 * clutter_event_get_coords:

 * @event: a #ClutterEvent

 * @x: (out): return location for the X coordinate, or %NULL

 * @y: (out): return location for the Y coordinate, or %NULL

 *

 * Retrieves the coordinates of @event and puts them into @x and @y.

 *

 * Since: 0.4

 */

void

clutter_event_get_coords (const ClutterEvent *event,

                          gfloat             *x,

                          gfloat             *y)

{

  ClutterPoint coords;

  g_return_if_fail (event != NULL);

  clutter_event_get_position (event, &coords);

  if (x != NULL)

    *x = coords.x;

  if (y != NULL)

    *y = coords.y;

}

/**

 * clutter_event_get_position:

 * @event: a #ClutterEvent

 * @position: a #ClutterPoint

 *

 * Retrieves the event coordinates as a #ClutterPoint.

 *

 * Since: 1.12

 */

void

clutter_event_get_position (const ClutterEvent *event,

                            ClutterPoint       *position)

{

  g_return_if_fail (event != NULL);

  g_return_if_fail (position != NULL);

  switch (event->type)

    {

    case CLUTTER_NOTHING:

    case CLUTTER_KEY_PRESS:

    case CLUTTER_KEY_RELEASE:

    case CLUTTER_STAGE_STATE:

    case CLUTTER_DESTROY_NOTIFY:

    case CLUTTER_CLIENT_MESSAGE:

    case CLUTTER_DELETE:

    case CLUTTER_EVENT_LAST:

      clutter_point_init (position, 0.f, 0.f);

      break;

    case CLUTTER_ENTER:

    case CLUTTER_LEAVE:

      clutter_point_init (position, event->crossing.x, event->crossing.y);

      break;

    case CLUTTER_BUTTON_PRESS:

    case CLUTTER_BUTTON_RELEASE:

      clutter_point_init (position, event->button.x, event->button.y);

      break;

    case CLUTTER_MOTION:

      clutter_point_init (position, event->motion.x, event->motion.y);

      break;

    case CLUTTER_TOUCH_BEGIN:

    case CLUTTER_TOUCH_UPDATE:

    case CLUTTER_TOUCH_END:

    case CLUTTER_TOUCH_CANCEL:

      clutter_point_init (position, event->touch.x, event->touch.y);

      break;

    case CLUTTER_SCROLL:

      clutter_point_init (position, event->scroll.x, event->scroll.y);

      break;

    case CLUTTER_TOUCHPAD_PINCH:

      clutter_point_init (position, event->touchpad_pinch.x,

                          event->touchpad_pinch.y);

      break;

    case CLUTTER_TOUCHPAD_SWIPE:

      clutter_point_init (position, event->touchpad_swipe.x,

                          event->touchpad_swipe.y);

      break;

    }

}

/**

 * clutter_event_set_coords:

 * @event: a #ClutterEvent

 * @x: the X coordinate of the event

 * @y: the Y coordinate of the event

 *

 * Sets the coordinates of the @event.

 *

 * Since: 1.8

 */

void

clutter_event_set_coords (ClutterEvent *event,

                          gfloat        x,

                          gfloat        y)

{

  g_return_if_fail (event != NULL);

  switch (event->type)

    {

    case CLUTTER_NOTHING:

    case CLUTTER_KEY_PRESS:

    case CLUTTER_KEY_RELEASE:

    case CLUTTER_STAGE_STATE:

    case CLUTTER_DESTROY_NOTIFY:

    case CLUTTER_CLIENT_MESSAGE:

    case CLUTTER_DELETE:

    case CLUTTER_EVENT_LAST:

      break;

    case CLUTTER_ENTER:

    case CLUTTER_LEAVE:

      event->crossing.x = x;

      event->crossing.y = y;

      break;

    case CLUTTER_BUTTON_PRESS:

    case CLUTTER_BUTTON_RELEASE:

      event->button.x = x;

      event->button.y = y;

      break;

    case CLUTTER_MOTION:

      event->motion.x = x;

      event->motion.y = y;

      break;

    case CLUTTER_TOUCH_BEGIN:

    case CLUTTER_TOUCH_UPDATE:

    case CLUTTER_TOUCH_END:

    case CLUTTER_TOUCH_CANCEL:

      event->touch.x = x;

      event->touch.y = y;

      break;

    case CLUTTER_SCROLL:

      event->scroll.x = x;

      event->scroll.y = y;

      break;

    case CLUTTER_TOUCHPAD_PINCH:

      event->touchpad_pinch.x = x;

      event->touchpad_pinch.y = y;

      break;

    case CLUTTER_TOUCHPAD_SWIPE:

      event->touchpad_swipe.x = x;

      event->touchpad_swipe.y = y;

      break;

    }

}

/**

 * clutter_event_get_source:

 * @event: a #ClutterEvent

 *

 * Retrieves the source #ClutterActor the event originated from, or

 * NULL if the event has no source.

 *

 * Return value: (transfer none): a #ClutterActor

 *

 * Since: 0.6

 */

ClutterActor *

clutter_event_get_source (const ClutterEvent *event)

{

  g_return_val_if_fail (event != NULL, NULL);

  return event->any.source;

}

/**

 * clutter_event_set_source:

 * @event: a #ClutterEvent

 * @actor: (allow-none): a #ClutterActor, or %NULL

 *

 * Sets the source #ClutterActor of @event.

 *

 * Since: 1.8

 */

void

clutter_event_set_source (ClutterEvent *event,

                          ClutterActor *actor)

{

  g_return_if_fail (event != NULL);

  g_return_if_fail (actor == NULL || CLUTTER_IS_ACTOR (actor));

  event->any.source = actor;

}

/**

 * clutter_event_get_stage:

 * @event: a #ClutterEvent

 *

 * Retrieves the source #ClutterStage the event originated for, or

 * %NULL if the event has no stage.

 *

 * Return value: (transfer none): a #ClutterStage

 *

 * Since: 0.8

 */

ClutterStage *

clutter_event_get_stage (const ClutterEvent *event)

{

  g_return_val_if_fail (event != NULL, NULL);

  return event->any.stage;

}

/**

 * clutter_event_set_stage:

 * @event: a #ClutterEvent

 * @stage: (allow-none): a #ClutterStage, or %NULL

 *

 * Sets the source #ClutterStage of the event.

 *

 * Since: 1.8

 */

void

clutter_event_set_stage (ClutterEvent *event,

                         ClutterStage *stage)

{

  g_return_if_fail (event != NULL);

  g_return_if_fail (stage == NULL || CLUTTER_IS_STAGE (stage));

  if (event->any.stage == stage)

    return;

  event->any.stage = stage;

}

/**

 * clutter_event_get_flags:

 * @event: a #ClutterEvent

 *

 * Retrieves the #ClutterEventFlags of @event

 *

 * Return value: the event flags

 *

 * Since: 1.0

 */

ClutterEventFlags

clutter_event_get_flags (const ClutterEvent *event)

{

  g_return_val_if_fail (event != NULL, CLUTTER_EVENT_NONE);

  return event->any.flags;

}

/**

 * clutter_event_set_flags:

 * @event: a #ClutterEvent

 * @flags: a binary OR of #ClutterEventFlags values

 *

 * Sets the #ClutterEventFlags of @event

 *

 * Since: 1.8

 */

void

clutter_event_set_flags (ClutterEvent      *event,

                         ClutterEventFlags  flags)

{

  g_return_if_fail (event != NULL);

  if (event->any.flags == flags)

    return;

  event->any.flags = flags;

  event->any.flags |= CLUTTER_EVENT_FLAG_SYNTHETIC;

}

/**

 * clutter_event_get_related:

 * @event: a #ClutterEvent of type %CLUTTER_ENTER or of

 *   type %CLUTTER_LEAVE

 *

 * Retrieves the related actor of a crossing event.

 *

 * Return value: (transfer none): the related #ClutterActor, or %NULL

 *

 * Since: 1.0

 */

ClutterActor *

clutter_event_get_related (const ClutterEvent *event)

{

  g_return_val_if_fail (event != NULL, NULL);

  g_return_val_if_fail (event->type == CLUTTER_ENTER ||

                        event->type == CLUTTER_LEAVE, NULL);

  return event->crossing.related;

}

/**

 * clutter_event_set_related:

 * @event: a #ClutterEvent of type %CLUTTER_ENTER or %CLUTTER_LEAVE

 * @actor: (allow-none): a #ClutterActor or %NULL

 *

 * Sets the related actor of a crossing event

 *

 * Since: 1.8

 */

void

clutter_event_set_related (ClutterEvent *event,

                           ClutterActor *actor)

{

  g_return_if_fail (event != NULL);

  g_return_if_fail (event->type == CLUTTER_ENTER ||

                    event->type == CLUTTER_LEAVE);

  g_return_if_fail (actor == NULL || CLUTTER_IS_ACTOR (actor));

  if (event->crossing.related == actor)

    return;

  event->crossing.related = actor;

}

/**

 * clutter_event_set_scroll_delta:

 * @event: a #ClutterEvent of type %CLUTTER_SCROLL

 * @dx: delta on the horizontal axis

 * @dy: delta on the vertical axis

 *

 * Sets the precise scrolling information of @event.

 *

 * Since: 1.10

 */

void

clutter_event_set_scroll_delta (ClutterEvent *event,

                                gdouble       dx,

                                gdouble       dy)

{

  g_return_if_fail (event != NULL);

  g_return_if_fail (event->type == CLUTTER_SCROLL);

  if (!is_event_allocated (event))

    return;

  event->scroll.direction = CLUTTER_SCROLL_SMOOTH;

  ((ClutterEventPrivate *) event)->delta_x = dx;

  ((ClutterEventPrivate *) event)->delta_y = dy;

}

/**

 * clutter_event_get_scroll_delta:

 * @event: a #ClutterEvent of type %CLUTTER_SCROLL

 * @dx: (out): return location for the delta on the horizontal axis

 * @dy: (out): return location for the delta on the vertical axis

 *

 * Retrieves the precise scrolling information of @event.

 *

 * The @event has to have a #ClutterScrollEvent.direction value

 * of %CLUTTER_SCROLL_SMOOTH.

 *

 * Since: 1.10

 */

void

clutter_event_get_scroll_delta (const ClutterEvent *event,

                                gdouble            *dx,

                                gdouble            *dy)

{

  gdouble delta_x, delta_y;

  g_return_if_fail (event != NULL);

  g_return_if_fail (event->type == CLUTTER_SCROLL);

  g_return_if_fail (event->scroll.direction == CLUTTER_SCROLL_SMOOTH);

  delta_x = delta_y = 0;

  if (is_event_allocated (event))

    {

      delta_x = ((ClutterEventPrivate *) event)->delta_x;

      delta_y = ((ClutterEventPrivate *) event)->delta_y;

    }

  if (dx != NULL)

    *dx = delta_x;

  if (dy != NULL)

    *dy = delta_y;

}

/**

 * clutter_event_get_scroll_direction:

 * @event: a #ClutterEvent of type %CLUTTER_SCROLL

 *

 * Retrieves the direction of the scrolling of @event

 *

 * Return value: the scrolling direction

 *

 * Since: 1.0

 */

ClutterScrollDirection

clutter_event_get_scroll_direction (const ClutterEvent *event)

{

  g_return_val_if_fail (event != NULL, CLUTTER_SCROLL_UP);

  g_return_val_if_fail (event->type == CLUTTER_SCROLL, CLUTTER_SCROLL_UP);

  return event->scroll.direction;

}

/**

 * clutter_event_set_scroll_direction:

 * @event: a #ClutterEvent

 * @direction: the scrolling direction

 *

 * Sets the direction of the scrolling of @event

 *

 * Since: 1.8

 */

void

clutter_event_set_scroll_direction (ClutterEvent           *event,

                                    ClutterScrollDirection  direction)

{

  g_return_if_fail (event != NULL);

  g_return_if_fail (event->type == CLUTTER_SCROLL);

  event->scroll.direction = direction;

}

/**

 * clutter_event_get_button:

 * @event: a #ClutterEvent of type %CLUTTER_BUTTON_PRESS or

 *   of type %CLUTTER_BUTTON_RELEASE

 *

 * Retrieves the button number of @event

 *

 * Return value: the button number

 *

 * Since: 1.0

 */

guint32

clutter_event_get_button (const ClutterEvent *event)

{

  g_return_val_if_fail (event != NULL, 0);

  g_return_val_if_fail (event->type == CLUTTER_BUTTON_PRESS ||

                        event->type == CLUTTER_BUTTON_RELEASE, 0);

  return event->button.button;

}

/**

 * clutter_event_set_button:

 * @event: a #ClutterEvent or type %CLUTTER_BUTTON_PRESS or

 *   of type %CLUTTER_BUTTON_RELEASE

 * @button: the button number

 *

 * Sets the button number of @event

 *

 * Since: 1.8

 */

void

clutter_event_set_button (ClutterEvent *event,

                          guint32       button)

{

  g_return_if_fail (event != NULL);

  g_return_if_fail (event->type == CLUTTER_BUTTON_PRESS ||

                    event->type == CLUTTER_BUTTON_RELEASE);

  event->button.button = button;

}

/**

 * clutter_event_get_click_count:

 * @event: a #ClutterEvent of type %CLUTTER_BUTTON_PRESS or

 *   of type %CLUTTER_BUTTON_RELEASE

 *

 * Retrieves the number of clicks of @event

 *

 * Return value: the click count

 *

 * Since: 1.0

 */

guint32

clutter_event_get_click_count (const ClutterEvent *event)

{

  g_return_val_if_fail (event != NULL, 0);

  g_return_val_if_fail (event->type == CLUTTER_BUTTON_PRESS ||

                        event->type == CLUTTER_BUTTON_RELEASE, 0);

  return event->button.click_count;

}

/* keys */

/**

 * clutter_event_get_key_symbol:

 * @event: a #ClutterEvent of type %CLUTTER_KEY_PRESS or

 *   of type %CLUTTER_KEY_RELEASE

 *

 * Retrieves the key symbol of @event

 *

 * Return value: the key symbol representing the key

 *

 * Since: 1.0

 */

guint

clutter_event_get_key_symbol (const ClutterEvent *event)

{

  g_return_val_if_fail (event != NULL, 0);

  g_return_val_if_fail (event->type == CLUTTER_KEY_PRESS ||

                        event->type == CLUTTER_KEY_RELEASE, 0);

  return event->key.keyval;

}

/**

 * clutter_event_set_key_symbol:

 * @event: a #ClutterEvent of type %CLUTTER_KEY_PRESS