/* GDK - The GIMP Drawing Kit

 * gdkdisplay.c

 * 

 * Copyright 2001 Sun Microsystems Inc. 

 *

 * Erwann Chenede <erwann.chenede@sun.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library 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

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library 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.

 */

#include "config.h"

#include <math.h>

#include <glib.h>

#include "gdk.h"		/* gdk_event_send_client_message() */

#include "gdkdisplay.h"

#include "gdkwindowimpl.h"

#include "gdkinternals.h"

#include "gdkmarshalers.h"

#include "gdkscreen.h"

#include "gdkalias.h"

enum {

  CLOSED,

  LAST_SIGNAL

};

static void gdk_display_dispose    (GObject         *object);

static void gdk_display_finalize   (GObject         *object);

static void       singlehead_get_pointer (GdkDisplay       *display,

					  GdkScreen       **screen,

					  gint             *x,

					  gint             *y,

					  GdkModifierType  *mask);

static GdkWindow* singlehead_window_get_pointer (GdkDisplay       *display,

						 GdkWindow        *window,

						 gint             *x,

						 gint             *y,

						 GdkModifierType  *mask);

static GdkWindow* singlehead_window_at_pointer  (GdkDisplay       *display,

						 gint             *win_x,

						 gint             *win_y);

static GdkWindow* singlehead_default_window_get_pointer (GdkWindow       *window,

							 gint            *x,

							 gint            *y,

							 GdkModifierType *mask);

static GdkWindow* singlehead_default_window_at_pointer  (GdkScreen       *screen,

							 gint            *win_x,

							 gint            *win_y);

static GdkWindow *gdk_window_real_window_get_pointer     (GdkDisplay       *display,

                                                          GdkWindow        *window,

                                                          gint             *x,

                                                          gint             *y,

                                                          GdkModifierType  *mask);

static GdkWindow *gdk_display_real_get_window_at_pointer (GdkDisplay       *display,

                                                          gint             *win_x,

                                                          gint             *win_y);

static guint signals[LAST_SIGNAL] = { 0 };

static char *gdk_sm_client_id;

static const GdkDisplayPointerHooks default_pointer_hooks = {

  _gdk_windowing_get_pointer,

  gdk_window_real_window_get_pointer,

  gdk_display_real_get_window_at_pointer

};

static const GdkDisplayPointerHooks singlehead_pointer_hooks = {

  singlehead_get_pointer,

  singlehead_window_get_pointer,

  singlehead_window_at_pointer

};

static const GdkPointerHooks singlehead_default_pointer_hooks = {

  singlehead_default_window_get_pointer,

  singlehead_default_window_at_pointer

};

static const GdkPointerHooks *singlehead_current_pointer_hooks = &singlehead_default_pointer_hooks;

G_DEFINE_TYPE (GdkDisplay, gdk_display, G_TYPE_OBJECT)

static void

gdk_display_class_init (GdkDisplayClass *class)

{

  GObjectClass *object_class = G_OBJECT_CLASS (class);

  object_class->finalize = gdk_display_finalize;

  object_class->dispose = gdk_display_dispose;

  /**

   * GdkDisplay::closed:

   * @display: the object on which the signal is emitted

   * @is_error: %TRUE if the display was closed due to an error

   *

   * The ::closed signal is emitted when the connection to the windowing

   * system for @display is closed.

   *

   * Since: 2.2

   */   

  signals[CLOSED] =

    g_signal_new (g_intern_static_string ("closed"),

		  G_OBJECT_CLASS_TYPE (object_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GdkDisplayClass, closed),

		  NULL, NULL,

		  _gdk_marshal_VOID__BOOLEAN,

		  G_TYPE_NONE,

		  1,

		  G_TYPE_BOOLEAN);

}

static void

gdk_display_init (GdkDisplay *display)

{

  _gdk_displays = g_slist_prepend (_gdk_displays, display);

  display->button_click_time[0] = display->button_click_time[1] = 0;

  display->button_window[0] = display->button_window[1] = NULL;

  display->button_number[0] = display->button_number[1] = -1;

  display->button_x[0] = display->button_x[1] = 0;

  display->button_y[0] = display->button_y[1] = 0;

  display->double_click_time = 250;

  display->double_click_distance = 5;

  display->pointer_hooks = &default_pointer_hooks;

}

static void

gdk_display_dispose (GObject *object)

{

  GdkDisplay *display = GDK_DISPLAY_OBJECT (object);

  g_list_foreach (display->queued_events, (GFunc)gdk_event_free, NULL);

  g_list_free (display->queued_events);

  display->queued_events = NULL;

  display->queued_tail = NULL;

  _gdk_displays = g_slist_remove (_gdk_displays, object);

  if (gdk_display_get_default() == display)

    {

      if (_gdk_displays)

        gdk_display_manager_set_default_display (gdk_display_manager_get(),

                                                 _gdk_displays->data);

      else

        gdk_display_manager_set_default_display (gdk_display_manager_get(),

                                                 NULL);

    }

  G_OBJECT_CLASS (gdk_display_parent_class)->dispose (object);

}

static void

gdk_display_finalize (GObject *object)

{

  G_OBJECT_CLASS (gdk_display_parent_class)->finalize (object);

}

/**

 * gdk_display_close:

 * @display: a #GdkDisplay

 *

 * Closes the connection to the windowing system for the given display,

 * and cleans up associated resources.

 *

 * Since: 2.2

 */

void

gdk_display_close (GdkDisplay *display)

{

  g_return_if_fail (GDK_IS_DISPLAY (display));

  if (!display->closed)

    {

      display->closed = TRUE;

      g_signal_emit (display, signals[CLOSED], 0, FALSE);

      g_object_run_dispose (G_OBJECT (display));

      g_object_unref (display);

    }

}

/**

 * gdk_display_is_closed:

 * @display: a #GdkDisplay

 *

 * Finds out if the display has been closed.

 *

 * Returns: %TRUE if the display is closed.

 *

 * Since: 2.22

 */

gboolean

gdk_display_is_closed  (GdkDisplay  *display)

{

  g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);

  return display->closed;

}

/**

 * gdk_display_get_event:

 * @display: a #GdkDisplay

 * 

 * Gets the next #GdkEvent to be processed for @display, fetching events from the

 * windowing system if necessary.

 * 

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

 *

 * Since: 2.2

 **/

GdkEvent*

gdk_display_get_event (GdkDisplay *display)

{

  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);

  _gdk_events_queue (display);

  return _gdk_event_unqueue (display);

}

/**

 * gdk_display_peek_event:

 * @display: a #GdkDisplay 

 * 

 * Gets a copy of the first #GdkEvent in the @display's event queue, without

 * removing the event from the queue.  (Note that this function will

 * not get more events from the windowing system.  It only checks the events

 * that have already been moved to the GDK event queue.)

 * 

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

 * if no events are in the queue. The returned #GdkEvent should be freed with

 * gdk_event_free().

 *

 * Since: 2.2

 **/

GdkEvent*

gdk_display_peek_event (GdkDisplay *display)

{

  GList *tmp_list;

  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);

  tmp_list = _gdk_event_queue_find_first (display);

  if (tmp_list)

    return gdk_event_copy (tmp_list->data);

  else

    return NULL;

}

/**

 * gdk_display_put_event:

 * @display: a #GdkDisplay

 * @event: a #GdkEvent.

 *

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

 * queue for @display.

 *

 * Since: 2.2

 **/

void

gdk_display_put_event (GdkDisplay     *display,

		       const GdkEvent *event)

{

  g_return_if_fail (GDK_IS_DISPLAY (display));

  g_return_if_fail (event != NULL);

  _gdk_event_queue_append (display, gdk_event_copy (event));

  /* If the main loop is blocking in a different thread, wake it up */

  g_main_context_wakeup (NULL); 

}

/**

 * gdk_pointer_ungrab:

 * @time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no 

 *  timestamp is available.

 *

 * Ungrabs the pointer on the default display, if it is grabbed by this 

 * application.

 **/

void

gdk_pointer_ungrab (guint32 time)

{

  gdk_display_pointer_ungrab (gdk_display_get_default (), time);

}

/**

 * gdk_pointer_is_grabbed:

 * 

 * Returns %TRUE if the pointer on the default display is currently 

 * grabbed by this application.

 *

 * Note that this does not take the inmplicit pointer grab on button

 * presses into account.

 * Return value: %TRUE if the pointer is currently grabbed by this application.* 

 **/

gboolean

gdk_pointer_is_grabbed (void)

{

  return gdk_display_pointer_is_grabbed (gdk_display_get_default ());

}

/**

 * gdk_keyboard_ungrab:

 * @time_: a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no

 *        timestamp is available.

 * 

 * Ungrabs the keyboard on the default display, if it is grabbed by this 

 * application.

 **/

void

gdk_keyboard_ungrab (guint32 time)

{

  gdk_display_keyboard_ungrab (gdk_display_get_default (), time);

}

/**

 * gdk_beep:

 * 

 * Emits a short beep on the default display.

 **/

void

gdk_beep (void)

{

  gdk_display_beep (gdk_display_get_default ());

}

/**

 * gdk_event_send_client_message:

 * @event: the #GdkEvent to send, which should be a #GdkEventClient.

 * @winid:  the window to send the X ClientMessage event to.

 * 

 * Sends an X ClientMessage event to a given window (which must be

 * on the default #GdkDisplay.)

 * This could be used for communicating between different applications,

 * though the amount of data is limited to 20 bytes.

 * 

 * Return value: non-zero on success.

 **/

gboolean

gdk_event_send_client_message (GdkEvent        *event,

			       GdkNativeWindow  winid)

{

  g_return_val_if_fail (event != NULL, FALSE);

  return gdk_event_send_client_message_for_display (gdk_display_get_default (),

						    event, winid);

}

/**

 * gdk_event_send_clientmessage_toall:

 * @event: the #GdkEvent to send, which should be a #GdkEventClient.

 *

 * Sends an X ClientMessage event to all toplevel windows on the default

 * #GdkScreen.

 *

 * Toplevel windows are determined by checking for the WM_STATE property, as

 * described in the Inter-Client Communication Conventions Manual (ICCCM).

 * If no windows are found with the WM_STATE property set, the message is sent

 * to all children of the root window.

 **/

void

gdk_event_send_clientmessage_toall (GdkEvent *event)

{

  g_return_if_fail (event != NULL);

  gdk_screen_broadcast_client_message (gdk_screen_get_default (), event);

}

/**

 * gdk_device_get_core_pointer:

 * 

 * Returns the core pointer device for the default display.

 * 

 * Return value: the core pointer device; this is owned by the

 *   display and should not be freed.

 **/

GdkDevice *

gdk_device_get_core_pointer (void)

{

  return gdk_display_get_core_pointer (gdk_display_get_default ());

}

/**

 * gdk_display_get_core_pointer:

 * @display: a #GdkDisplay

 * 

 * Returns the core pointer device for the given display

 * 

 * Return value: the core pointer device; this is owned by the

 *   display and should not be freed.

 *

 * Since: 2.2

 **/

GdkDevice *

gdk_display_get_core_pointer (GdkDisplay *display)

{

  return display->core_pointer;

}

/**

 * gdk_set_sm_client_id:

 * @sm_client_id: the client id assigned by the session manager when the

 *    connection was opened, or %NULL to remove the property.

 * 

 * Sets the <literal>SM_CLIENT_ID</literal> property on the application's leader window so that

 * the window manager can save the application's state using the X11R6 ICCCM

 * session management protocol.

 *

 * See the X Session Management Library documentation for more information on

 * session management and the Inter-Client Communication Conventions Manual

 * (ICCCM) for information on the <literal>WM_CLIENT_LEADER</literal> property. 

 * (Both documents are part of the X Window System distribution.)

 *

 * Deprecated:2.24: Use gdk_x11_set_sm_client_id() instead

 **/

void

gdk_set_sm_client_id (const gchar* sm_client_id)

{

  GSList *displays, *tmp_list;

  g_free (gdk_sm_client_id);

  gdk_sm_client_id = g_strdup (sm_client_id);

  displays = gdk_display_manager_list_displays (gdk_display_manager_get ());

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

    _gdk_windowing_display_set_sm_client_id (tmp_list->data, sm_client_id);

  g_slist_free (displays);

}

/**

 * _gdk_get_sm_client_id:

 * 

 * Gets the client ID set with gdk_set_sm_client_id(), if any.

 * 

 * Return value: Session ID, or %NULL if gdk_set_sm_client_id()

 *               has never been called.

 **/

const char *

_gdk_get_sm_client_id (void)

{

  return gdk_sm_client_id;

}

void

_gdk_display_enable_motion_hints (GdkDisplay *display)

{

  gulong serial;

  if (display->pointer_info.motion_hint_serial != 0)

    {

      serial = _gdk_windowing_window_get_next_serial (display);

      /* We might not actually generate the next request, so

	 make sure this triggers always, this may cause it to

	 trigger slightly too early, but this is just a hint

	 anyway. */

      if (serial > 0)

	serial--;

      if (serial < display->pointer_info.motion_hint_serial)

	display->pointer_info.motion_hint_serial = serial;

    }

}

/**

 * gdk_display_get_pointer:

 * @display: a #GdkDisplay

 * @screen: (out) (allow-none): location to store the screen that the

 *          cursor is on, or %NULL.

 * @x: (out) (allow-none): location to store root window X coordinate of pointer, or %NULL.

 * @y: (out) (allow-none): location to store root window Y coordinate of pointer, or %NULL.

 * @mask: (out) (allow-none): location to store current modifier mask, or %NULL

 *

 * Gets the current location of the pointer and the current modifier

 * mask for a given display.

 *

 * Since: 2.2

 **/

void

gdk_display_get_pointer (GdkDisplay      *display,

			 GdkScreen      **screen,

			 gint            *x,

			 gint            *y,

			 GdkModifierType *mask)

{

  GdkScreen *tmp_screen;

  gint tmp_x, tmp_y;

  GdkModifierType tmp_mask;

  g_return_if_fail (GDK_IS_DISPLAY (display));

  display->pointer_hooks->get_pointer (display, &tmp_screen, &tmp_x, &tmp_y, &tmp_mask);

  if (screen)

    *screen = tmp_screen;

  if (x)

    *x = tmp_x;

  if (y)

    *y = tmp_y;

  if (mask)

    *mask = tmp_mask;

}

static GdkWindow *

gdk_display_real_get_window_at_pointer (GdkDisplay *display,

                                        gint       *win_x,

                                        gint       *win_y)

{

  GdkWindow *window;

  gint x, y;

  window = _gdk_windowing_window_at_pointer (display, &x, &y, NULL, FALSE);

  /* This might need corrections, as the native window returned

     may contain client side children */

  if (window)

    {

      double xx, yy;

      window = _gdk_window_find_descendant_at (window,

					       x, y,

					       &xx, &yy;;

      x = floor (xx + 0.5);

      y = floor (yy + 0.5);

    }

  *win_x = x;

  *win_y = y;

  return window;

}

static GdkWindow *

gdk_window_real_window_get_pointer (GdkDisplay       *display,

                                    GdkWindow        *window,

                                    gint             *x,

                                    gint             *y,

                                    GdkModifierType  *mask)

{

  GdkWindowObject *private;

  gint tmpx, tmpy;

  GdkModifierType tmp_mask;

  gboolean normal_child;

  private = (GdkWindowObject *) window;

  normal_child = GDK_WINDOW_IMPL_GET_IFACE (private->impl)->get_pointer (window,

									 &tmpx, &tmpy,

									 &tmp_mask);

  /* We got the coords on the impl, convert to the window */

  tmpx -= private->abs_x;

  tmpy -= private->abs_y;

  if (x)

    *x = tmpx;

  if (y)

    *y = tmpy;

  if (mask)

    *mask = tmp_mask;

  if (normal_child)

    return _gdk_window_find_child_at (window, tmpx, tmpy);

  return NULL;

}

/**

 * gdk_display_get_window_at_pointer:

 * @display: a #GdkDisplay

 * @win_x: (out) (allow-none): return location for x coordinate of the pointer location relative

 *    to the window origin, or %NULL

 * @win_y: (out) (allow-none): return location for y coordinate of the pointer location relative

 &    to the window origin, or %NULL

 *

 * Obtains the window underneath the mouse pointer, returning the location

 * of the pointer in that window in @win_x, @win_y for @screen. Returns %NULL

 * if the window under the mouse pointer is not known to GDK (for example, 

 * belongs to another application).

 *

 * Returns: (transfer none): the window under the mouse pointer, or %NULL

 *

 * Since: 2.2

 **/

GdkWindow *

gdk_display_get_window_at_pointer (GdkDisplay *display,

				   gint       *win_x,

				   gint       *win_y)

{

  gint tmp_x, tmp_y;

  GdkWindow *window;

  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);

  window = display->pointer_hooks->window_at_pointer (display, &tmp_x, &tmp_y);

  if (win_x)

    *win_x = tmp_x;

  if (win_y)

    *win_y = tmp_y;

  return window;

}

/**

 * gdk_display_set_pointer_hooks:

 * @display: a #GdkDisplay

 * @new_hooks: a table of pointers to functions for getting

 *   quantities related to the current pointer position,

 *   or %NULL to restore the default table.

 * 

 * This function allows for hooking into the operation

 * of getting the current location of the pointer on a particular

 * display. This is only useful for such low-level tools as an

 * event recorder. Applications should never have any

 * reason to use this facility.

 *

 * Return value: the previous pointer hook table

 *

 * Since: 2.2

 *

 * Deprecated: 2.24: This function will go away in GTK 3 for lack of use cases.

 **/

GdkDisplayPointerHooks *

gdk_display_set_pointer_hooks (GdkDisplay                   *display,

			       const GdkDisplayPointerHooks *new_hooks)

{

  const GdkDisplayPointerHooks *result;

  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);

  result = display->pointer_hooks;

  if (new_hooks)

    display->pointer_hooks = new_hooks;

  else

    display->pointer_hooks = &default_pointer_hooks;

  return (GdkDisplayPointerHooks *)result;

}

static void

singlehead_get_pointer (GdkDisplay       *display,

			GdkScreen       **screen,

			gint             *x,

			gint             *y,

			GdkModifierType  *mask)

{

  GdkScreen *default_screen = gdk_display_get_default_screen (display);

  GdkWindow *root_window = gdk_screen_get_root_window (default_screen);

  *screen = default_screen;

  singlehead_current_pointer_hooks->get_pointer (root_window, x, y, mask);

}

static GdkWindow*

singlehead_window_get_pointer (GdkDisplay       *display,

			       GdkWindow        *window,

			       gint             *x,

			       gint             *y,

			       GdkModifierType  *mask)

{

  return singlehead_current_pointer_hooks->get_pointer (window, x, y, mask);

}

static GdkWindow*

singlehead_window_at_pointer   (GdkDisplay *display,

				gint       *win_x,

				gint       *win_y)

{

  GdkScreen *default_screen = gdk_display_get_default_screen (display);

  return singlehead_current_pointer_hooks->window_at_pointer (default_screen,

							      win_x, win_y);

}

static GdkWindow*

singlehead_default_window_get_pointer (GdkWindow       *window,

				       gint            *x,

				       gint            *y,

				       GdkModifierType *mask)

{

  return gdk_window_real_window_get_pointer (gdk_drawable_get_display (window),

                                             window, x, y, mask);

}

static GdkWindow*

singlehead_default_window_at_pointer  (GdkScreen       *screen,

				       gint            *win_x,

				       gint            *win_y)

{

  return gdk_display_real_get_window_at_pointer (gdk_screen_get_display (screen),

                                                 win_x, win_y);

}

/**

 * gdk_set_pointer_hooks:

 * @new_hooks: a table of pointers to functions for getting

 *   quantities related to the current pointer position,

 *   or %NULL to restore the default table.

 * 

 * This function allows for hooking into the operation

 * of getting the current location of the pointer. This

 * is only useful for such low-level tools as an

 * event recorder. Applications should never have any

 * reason to use this facility.

 *

 * This function is not multihead safe. For multihead operation,

 * see gdk_display_set_pointer_hooks().

 * 

 * Return value: the previous pointer hook table

 *

 * Deprecated: 2.24: This function will go away in GTK 3 for lack of use cases.

 **/

GdkPointerHooks *

gdk_set_pointer_hooks (const GdkPointerHooks *new_hooks)

{

  const GdkPointerHooks *result = singlehead_current_pointer_hooks;

  if (new_hooks)

    singlehead_current_pointer_hooks = new_hooks;

  else

    singlehead_current_pointer_hooks = &singlehead_default_pointer_hooks;

  gdk_display_set_pointer_hooks (gdk_display_get_default (),

				 &singlehead_pointer_hooks);

  return (GdkPointerHooks *)result;

}

static void

generate_grab_broken_event (GdkWindow *window,

			    gboolean   keyboard,

			    gboolean   implicit,

			    GdkWindow *grab_window)

{

  g_return_if_fail (window != NULL);

  if (!GDK_WINDOW_DESTROYED (window))

    {

      GdkEvent event;

      event.type = GDK_GRAB_BROKEN;

      event.grab_broken.window = window;

      event.grab_broken.send_event = 0;

      event.grab_broken.keyboard = keyboard;

      event.grab_broken.implicit = implicit;

      event.grab_broken.grab_window = grab_window;

      gdk_event_put (&event);

    }

}

GdkPointerGrabInfo *

_gdk_display_get_last_pointer_grab (GdkDisplay *display)

{

  GList *l;

  l = g_list_last (display->pointer_grabs);

  if (l == NULL)

    return NULL;

  else

    return (GdkPointerGrabInfo *)l->data;

}

GdkPointerGrabInfo *

_gdk_display_add_pointer_grab (GdkDisplay *display,

			       GdkWindow *window,

			       GdkWindow *native_window,

			       gboolean owner_events,

			       GdkEventMask event_mask,

			       unsigned long serial_start,

			       guint32 time,

			       gboolean implicit)

{

  GdkPointerGrabInfo *info, *other_info;

  GList *l;

  info = g_new0 (GdkPointerGrabInfo, 1);

  info->window = g_object_ref (window);

  info->native_window = g_object_ref (native_window);

  info->serial_start = serial_start;

  info->serial_end = G_MAXULONG;

  info->owner_events = owner_events;

  info->event_mask = event_mask;

  info->time = time;

  info->implicit = implicit;

  /* Find the first grab that has a larger start time (if any) and insert

   * before that. I.E we insert after already existing grabs with same

   * start time */

  for (l = display->pointer_grabs; l != NULL; l = l->next)

    {

      other_info = l->data;

      if (info->serial_start < other_info->serial_start)

	break;

    }

  display->pointer_grabs =

    g_list_insert_before (display->pointer_grabs, l, info);

  /* Make sure the new grab end before next grab */

  if (l)

    {

      other_info = l->data;

      info->serial_end = other_info->serial_start;

    }

  /* Find any previous grab and update its end time */

  l = g_list_find  (display->pointer_grabs, info);

  l = l->prev;

  if (l)

    {

      other_info = l->data;

      other_info->serial_end = serial_start;

    }

  return info;

}

static void

free_pointer_grab (GdkPointerGrabInfo *info)

{

  g_object_unref (info->window);

  g_object_unref (info->native_window);

  g_free (info);

}

/* _gdk_synthesize_crossing_events only works inside one toplevel.

   This function splits things into two calls if needed, converting the

   coordinates to the right toplevel */

static void

synthesize_crossing_events (GdkDisplay *display,

			    GdkWindow *src_window,

			    GdkWindow *dest_window,

			    GdkCrossingMode crossing_mode,

			    guint32 time,

			    gulong serial)

{

  GdkWindow *src_toplevel, *dest_toplevel;

  GdkModifierType state;

  int x, y;

  /* We use the native crossing events if all native */

  if (_gdk_native_windows)

    return;

  if (src_window)

    src_toplevel = gdk_window_get_toplevel (src_window);

  else

    src_toplevel = NULL;

  if (dest_window)

    dest_toplevel = gdk_window_get_toplevel (dest_window);

  else

    dest_toplevel = NULL;

  if (src_toplevel == NULL && dest_toplevel == NULL)

    return;

  if (src_toplevel == NULL ||