/* gtktooltip.c

 *

 * Copyright (C) 2006-2007 Imendio AB

 * Contact: Kristian Rietveld <kris@imendio.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 <string.h>

#include "gtktooltip.h"

#include "gtkintl.h"

#include "gtkwindow.h"

#include "gtkmain.h"

#include "gtklabel.h"

#include "gtkimage.h"

#include "gtkhbox.h"

#include "gtkalignment.h"

#include "gtkalias.h"

#undef DEBUG_TOOLTIP

#define GTK_TOOLTIP_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOOLTIP, GtkTooltipClass))

#define GTK_IS_TOOLTIP_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOOLTIP))

#define GTK_TOOLTIP_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TOOLTIP, GtkTooltipClass))

typedef struct _GtkTooltipClass   GtkTooltipClass;

struct _GtkTooltip

{

  GObject parent_instance;

  GtkWidget *window;

  GtkWidget *alignment;

  GtkWidget *box;

  GtkWidget *image;

  GtkWidget *label;

  GtkWidget *custom_widget;

  GtkWindow *current_window;

  GtkWidget *keyboard_widget;

  GtkWidget *tooltip_widget;

  GdkWindow *toplevel_window;

  gdouble last_x;

  gdouble last_y;

  GdkWindow *last_window;

  guint timeout_id;

  guint browse_mode_timeout_id;

  GdkRectangle tip_area;

  guint browse_mode_enabled : 1;

  guint keyboard_mode_enabled : 1;

  guint tip_area_set : 1;

  guint custom_was_reset : 1;

};

struct _GtkTooltipClass

{

  GObjectClass parent_class;

};

#define GTK_TOOLTIP_VISIBLE(tooltip) ((tooltip)->current_window && gtk_widget_get_visible (GTK_WIDGET((tooltip)->current_window)))

static void       gtk_tooltip_class_init           (GtkTooltipClass *klass);

static void       gtk_tooltip_init                 (GtkTooltip      *tooltip);

static void       gtk_tooltip_dispose              (GObject         *object);

static void       gtk_tooltip_window_style_set     (GtkTooltip      *tooltip);

static gboolean   gtk_tooltip_paint_window         (GtkTooltip      *tooltip);

static void       gtk_tooltip_window_hide          (GtkWidget       *widget,

						    gpointer         user_data);

static void       gtk_tooltip_display_closed       (GdkDisplay      *display,

						    gboolean         was_error,

						    GtkTooltip      *tooltip);

static void       gtk_tooltip_set_last_window      (GtkTooltip      *tooltip,

						    GdkWindow       *window);

static void       update_shape                     (GtkTooltip      *tooltip);

G_DEFINE_TYPE (GtkTooltip, gtk_tooltip, G_TYPE_OBJECT);

static void

gtk_tooltip_class_init (GtkTooltipClass *klass)

{

  GObjectClass *object_class;

  object_class = G_OBJECT_CLASS (klass);

  object_class->dispose = gtk_tooltip_dispose;

}

static void

on_composited_changed (GtkWidget  *window,

                       GtkTooltip *tooltip)

{

  update_shape (tooltip);

}

static void

on_screen_changed (GtkWidget  *window,

                   GdkScreen  *previous,

                   GtkTooltip *tooltip)

{

  GdkScreen *screen;

  GdkColormap *cmap;

  screen = gtk_widget_get_screen (window);

  cmap = NULL;

  if (gdk_screen_is_composited (screen))

    cmap = gdk_screen_get_rgba_colormap (screen);

  if (cmap == NULL)

    cmap = gdk_screen_get_rgb_colormap (screen);

  gtk_widget_set_colormap (window, cmap);

}

static void

on_realized (GtkWidget  *window,

             GtkTooltip *tooltip)

{

  update_shape (tooltip);

}

static void

gtk_tooltip_init (GtkTooltip *tooltip)

{

  tooltip->timeout_id = 0;

  tooltip->browse_mode_timeout_id = 0;

  tooltip->browse_mode_enabled = FALSE;

  tooltip->keyboard_mode_enabled = FALSE;

  tooltip->current_window = NULL;

  tooltip->keyboard_widget = NULL;

  tooltip->tooltip_widget = NULL;

  tooltip->toplevel_window = NULL;

  tooltip->last_window = NULL;

  tooltip->window = g_object_ref (gtk_window_new (GTK_WINDOW_POPUP));

  on_screen_changed (tooltip->window, NULL, tooltip);

  gtk_window_set_type_hint (GTK_WINDOW (tooltip->window),

			    GDK_WINDOW_TYPE_HINT_TOOLTIP);

  gtk_widget_set_app_paintable (tooltip->window, TRUE);

  gtk_window_set_resizable (GTK_WINDOW (tooltip->window), FALSE);

  gtk_widget_set_name (tooltip->window, "gtk-tooltip");

  g_signal_connect (tooltip->window, "hide",

		    G_CALLBACK (gtk_tooltip_window_hide), tooltip);

  tooltip->alignment = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);

  gtk_alignment_set_padding (GTK_ALIGNMENT (tooltip->alignment),

			     tooltip->window->style->ythickness,

			     tooltip->window->style->ythickness,

			     tooltip->window->style->xthickness,

			     tooltip->window->style->xthickness);

  gtk_container_add (GTK_CONTAINER (tooltip->window), tooltip->alignment);

  gtk_widget_show (tooltip->alignment);

  g_signal_connect_swapped (tooltip->window, "style-set",

			    G_CALLBACK (gtk_tooltip_window_style_set), tooltip);

  g_signal_connect_swapped (tooltip->window, "expose-event",

			    G_CALLBACK (gtk_tooltip_paint_window), tooltip);

  tooltip->box = gtk_hbox_new (FALSE, tooltip->window->style->xthickness);

  gtk_container_add (GTK_CONTAINER (tooltip->alignment), tooltip->box);

  gtk_widget_show (tooltip->box);

  tooltip->image = gtk_image_new ();

  gtk_box_pack_start (GTK_BOX (tooltip->box), tooltip->image,

		      FALSE, FALSE, 0);

  tooltip->label = gtk_label_new ("");

  gtk_label_set_line_wrap (GTK_LABEL (tooltip->label), TRUE);

  gtk_box_pack_start (GTK_BOX (tooltip->box), tooltip->label,

		      FALSE, FALSE, 0);

  g_signal_connect (tooltip->window, "composited-changed",

                    G_CALLBACK (on_composited_changed), tooltip);

  g_signal_connect (tooltip->window, "screen-changed",

                    G_CALLBACK (on_screen_changed), tooltip);

  g_signal_connect (tooltip->window, "realize",

                    G_CALLBACK (on_realized), tooltip);

  tooltip->custom_widget = NULL;

}

static void

gtk_tooltip_dispose (GObject *object)

{

  GtkTooltip *tooltip = GTK_TOOLTIP (object);

  if (tooltip->timeout_id)

    {

      g_source_remove (tooltip->timeout_id);

      tooltip->timeout_id = 0;

    }

  if (tooltip->browse_mode_timeout_id)

    {

      g_source_remove (tooltip->browse_mode_timeout_id);

      tooltip->browse_mode_timeout_id = 0;

    }

  gtk_tooltip_set_custom (tooltip, NULL);

  gtk_tooltip_set_last_window (tooltip, NULL);

  if (tooltip->window)

    {

      GdkDisplay *display;

      display = gtk_widget_get_display (tooltip->window);

      g_signal_handlers_disconnect_by_func (display,

					    gtk_tooltip_display_closed,

					    tooltip);

      gtk_widget_destroy (tooltip->window);

      tooltip->window = NULL;

    }

  G_OBJECT_CLASS (gtk_tooltip_parent_class)->dispose (object);

}

/* public API */

/**

 * gtk_tooltip_set_markup:

 * @tooltip: a #GtkTooltip

 * @markup: (allow-none): a markup string (see <link linkend="PangoMarkupFormat">Pango markup format</link>) or %NULL

 *

 * Sets the text of the tooltip to be @markup, which is marked up

 * with the 

 * linkend="PangoMarkupFormat">Pango text markup language</link>.

 * If @markup is %NULL, the label will be hidden.

 *

 * Since: 2.12

 */

void

gtk_tooltip_set_markup (GtkTooltip  *tooltip,

			const gchar *markup)

{

  g_return_if_fail (GTK_IS_TOOLTIP (tooltip));

  gtk_label_set_markup (GTK_LABEL (tooltip->label), markup);

  if (markup)

    gtk_widget_show (tooltip->label);

  else

    gtk_widget_hide (tooltip->label);

}

/**

 * gtk_tooltip_set_text:

 * @tooltip: a #GtkTooltip

 * @text: (allow-none): a text string or %NULL

 *

 * Sets the text of the tooltip to be @text. If @text is %NULL, the label

 * will be hidden. See also gtk_tooltip_set_markup().

 *

 * Since: 2.12

 */

void

gtk_tooltip_set_text (GtkTooltip  *tooltip,

                      const gchar *text)

{

  g_return_if_fail (GTK_IS_TOOLTIP (tooltip));

  gtk_label_set_text (GTK_LABEL (tooltip->label), text);

  if (text)

    gtk_widget_show (tooltip->label);

  else

    gtk_widget_hide (tooltip->label);

}

/**

 * gtk_tooltip_set_icon:

 * @tooltip: a #GtkTooltip

 * @pixbuf: (allow-none): a #GdkPixbuf, or %NULL

 *

 * Sets the icon of the tooltip (which is in front of the text) to be

 * @pixbuf.  If @pixbuf is %NULL, the image will be hidden.

 *

 * Since: 2.12

 */

void

gtk_tooltip_set_icon (GtkTooltip *tooltip,

		      GdkPixbuf  *pixbuf)

{

  g_return_if_fail (GTK_IS_TOOLTIP (tooltip));

  if (pixbuf)

    g_return_if_fail (GDK_IS_PIXBUF (pixbuf));

  gtk_image_set_from_pixbuf (GTK_IMAGE (tooltip->image), pixbuf);

  if (pixbuf)

    gtk_widget_show (tooltip->image);

  else

    gtk_widget_hide (tooltip->image);

}

/**

 * gtk_tooltip_set_icon_from_stock:

 * @tooltip: a #GtkTooltip

 * @stock_id: (allow-none): a stock id, or %NULL

 * @size: (type int): a stock icon size

 *

 * Sets the icon of the tooltip (which is in front of the text) to be

 * the stock item indicated by @stock_id with the size indicated

 * by @size.  If @stock_id is %NULL, the image will be hidden.

 *

 * Since: 2.12

 */

void

gtk_tooltip_set_icon_from_stock (GtkTooltip  *tooltip,

				 const gchar *stock_id,

				 GtkIconSize  size)

{

  g_return_if_fail (GTK_IS_TOOLTIP (tooltip));

  gtk_image_set_from_stock (GTK_IMAGE (tooltip->image), stock_id, size);

  if (stock_id)

    gtk_widget_show (tooltip->image);

  else

    gtk_widget_hide (tooltip->image);

}

/**

 * gtk_tooltip_set_icon_from_icon_name:

 * @tooltip: a #GtkTooltip

 * @icon_name: (allow-none): an icon name, or %NULL

 * @size: (type int): a stock icon size

 *

 * Sets the icon of the tooltip (which is in front of the text) to be

 * the icon indicated by @icon_name with the size indicated

 * by @size.  If @icon_name is %NULL, the image will be hidden.

 *

 * Since: 2.14

 */

void

gtk_tooltip_set_icon_from_icon_name (GtkTooltip  *tooltip,

				     const gchar *icon_name,

				     GtkIconSize  size)

{

  g_return_if_fail (GTK_IS_TOOLTIP (tooltip));

  gtk_image_set_from_icon_name (GTK_IMAGE (tooltip->image), icon_name, size);

  if (icon_name)

    gtk_widget_show (tooltip->image);

  else

    gtk_widget_hide (tooltip->image);

}

/**

 * gtk_tooltip_set_icon_from_gicon:

 * @tooltip: a #GtkTooltip

 * @gicon: (allow-none): a #GIcon representing the icon, or %NULL

 * @size: (type int): a stock icon size

 *

 * Sets the icon of the tooltip (which is in front of the text)

 * to be the icon indicated by @gicon with the size indicated

 * by @size. If @gicon is %NULL, the image will be hidden.

 *

 * Since: 2.20

 */

void

gtk_tooltip_set_icon_from_gicon (GtkTooltip  *tooltip,

				 GIcon       *gicon,

				 GtkIconSize  size)

{

  g_return_if_fail (GTK_IS_TOOLTIP (tooltip));

  gtk_image_set_from_gicon (GTK_IMAGE (tooltip->image), gicon, size);

  if (gicon)

    gtk_widget_show (tooltip->image);

  else

    gtk_widget_hide (tooltip->image);

}

/**

 * gtk_tooltip_set_custom:

 * @tooltip: a #GtkTooltip

 * @custom_widget: (allow-none): a #GtkWidget, or %NULL to unset the old custom widget.

 *

 * Replaces the widget packed into the tooltip with

 * @custom_widget. @custom_widget does not get destroyed when the tooltip goes

 * away.

 * By default a box with a #GtkImage and #GtkLabel is embedded in 

 * the tooltip, which can be configured using gtk_tooltip_set_markup() 

 * and gtk_tooltip_set_icon().

 *

 * Since: 2.12

 */

void

gtk_tooltip_set_custom (GtkTooltip *tooltip,

			GtkWidget  *custom_widget)

{

  g_return_if_fail (GTK_IS_TOOLTIP (tooltip));

  if (custom_widget)

    g_return_if_fail (GTK_IS_WIDGET (custom_widget));

  /* The custom widget has been updated from the query-tooltip

   * callback, so we do not want to reset the custom widget later on.

   */

  tooltip->custom_was_reset = TRUE;

  /* No need to do anything if the custom widget stays the same */

  if (tooltip->custom_widget == custom_widget)

    return;

  if (tooltip->custom_widget)

    {

      GtkWidget *custom = tooltip->custom_widget;

      /* Note: We must reset tooltip->custom_widget first, 

       * since gtk_container_remove() will recurse into 

       * gtk_tooltip_set_custom()

       */

      tooltip->custom_widget = NULL;

      gtk_container_remove (GTK_CONTAINER (tooltip->box), custom);

      g_object_unref (custom);

    }

  if (custom_widget)

    {

      tooltip->custom_widget = g_object_ref (custom_widget);

      gtk_container_add (GTK_CONTAINER (tooltip->box), custom_widget);

      gtk_widget_show (custom_widget);

    }

}

/**

 * gtk_tooltip_set_tip_area:

 * @tooltip: a #GtkTooltip

 * @rect: a #GdkRectangle

 *

 * Sets the area of the widget, where the contents of this tooltip apply,

 * to be @rect (in widget coordinates).  This is especially useful for

 * properly setting tooltips on #GtkTreeView rows and cells, #GtkIconViews,

 * etc.

 *

 * For setting tooltips on #GtkTreeView, please refer to the convenience

 * functions for this: gtk_tree_view_set_tooltip_row() and

 * gtk_tree_view_set_tooltip_cell().

 *

 * Since: 2.12

 */

void

gtk_tooltip_set_tip_area (GtkTooltip         *tooltip,

			  const GdkRectangle *rect)

{

  g_return_if_fail (GTK_IS_TOOLTIP (tooltip));

  if (!rect)

    tooltip->tip_area_set = FALSE;

  else

    {

      tooltip->tip_area_set = TRUE;

      tooltip->tip_area = *rect;

    }

}

/**

 * gtk_tooltip_trigger_tooltip_query:

 * @display: a #GdkDisplay

 *

 * Triggers a new tooltip query on @display, in order to update the current

 * visible tooltip, or to show/hide the current tooltip.  This function is

 * useful to call when, for example, the state of the widget changed by a

 * key press.

 *

 * Since: 2.12

 */

void

gtk_tooltip_trigger_tooltip_query (GdkDisplay *display)

{

  gint x, y;

  GdkWindow *window;

  GdkEvent event;

  /* Trigger logic as if the mouse moved */

  window = gdk_display_get_window_at_pointer (display, &x, &y);

  if (!window)

    return;

  event.type = GDK_MOTION_NOTIFY;

  event.motion.window = window;

  event.motion.x = x;

  event.motion.y = y;

  event.motion.is_hint = FALSE;

  gdk_window_get_root_coords (window, x, y, &x, &y);

  event.motion.x_root = x;

  event.motion.y_root = y;

  _gtk_tooltip_handle_event (&event);

}

/* private functions */

static void

gtk_tooltip_reset (GtkTooltip *tooltip)

{

  gtk_tooltip_set_markup (tooltip, NULL);

  gtk_tooltip_set_icon (tooltip, NULL);

  gtk_tooltip_set_tip_area (tooltip, NULL);

  /* See if the custom widget is again set from the query-tooltip

   * callback.

   */

  tooltip->custom_was_reset = FALSE;

}

static void

gtk_tooltip_window_style_set (GtkTooltip *tooltip)

{

  gtk_alignment_set_padding (GTK_ALIGNMENT (tooltip->alignment),

			     tooltip->window->style->ythickness,

			     tooltip->window->style->ythickness,

			     tooltip->window->style->xthickness,

			     tooltip->window->style->xthickness);

  gtk_box_set_spacing (GTK_BOX (tooltip->box),

		       tooltip->window->style->xthickness);

  gtk_widget_queue_draw (tooltip->window);

}

static void

draw_round_rect (cairo_t *cr,

                 gdouble  aspect,

                 gdouble  x,

                 gdouble  y,

                 gdouble  corner_radius,

                 gdouble  width,

                 gdouble  height)

{

  gdouble radius = corner_radius / aspect;

  cairo_move_to (cr, x + radius, y);

  /* top-right, left of the corner */

  cairo_line_to (cr, x + width - radius, y);

  /* top-right, below the corner */

  cairo_arc (cr,

             x + width - radius, y + radius, radius,

             -90.0f * G_PI / 180.0f, 0.0f * G_PI / 180.0f);

  /* bottom-right, above the corner */

  cairo_line_to (cr, x + width, y + height - radius);

  /* bottom-right, left of the corner */

  cairo_arc (cr,

             x + width - radius, y + height - radius, radius,

             0.0f * G_PI / 180.0f, 90.0f * G_PI / 180.0f);

  /* bottom-left, right of the corner */

  cairo_line_to (cr, x + radius, y + height);

  /* bottom-left, above the corner */

  cairo_arc (cr,

             x + radius, y + height - radius, radius,

             90.0f * G_PI / 180.0f, 180.0f * G_PI / 180.0f);

  /* top-left, below the corner */

  cairo_line_to (cr, x, y + radius);

  /* top-left, right of the corner */

  cairo_arc (cr,

             x + radius, y + radius, radius,

             180.0f * G_PI / 180.0f, 270.0f * G_PI / 180.0f);

  cairo_close_path (cr);

}

static void

fill_background (GtkWidget  *widget,

                 cairo_t    *cr,

                 GdkColor   *bg_color,

                 GdkColor   *border_color,

                 guchar      alpha)

{

  gint tooltip_radius;

  if (!gtk_widget_is_composited (widget))

    alpha = 255;

  gtk_widget_style_get (widget,

                        "tooltip-radius", &tooltip_radius,

                        NULL);

  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);

  cairo_paint (cr);

  cairo_set_operator (cr, CAIRO_OPERATOR_OVER);

  draw_round_rect (cr,

                   1.0, 0.5, 0.5, tooltip_radius,

                   widget->allocation.width - 1,

                   widget->allocation.height - 1);

  cairo_set_source_rgba (cr,

                         (float) bg_color->red / 65535.0,

                         (float) bg_color->green / 65535.0,

                         (float) bg_color->blue / 65535.0,

                         (float) alpha / 255.0);

  cairo_fill_preserve (cr);

  cairo_set_source_rgba (cr,

                         (float) border_color->red / 65535.0,

                         (float) border_color->green / 65535.0,

                         (float) border_color->blue / 65535.0,

                         (float) alpha / 255.0);

  cairo_set_line_width (cr, 1.0);

  cairo_stroke (cr);

}

static void

update_shape (GtkTooltip *tooltip)

{

  GdkBitmap *mask;

  cairo_t *cr;

  gint width, height, tooltip_radius;

  gtk_widget_style_get (tooltip->window,

                        "tooltip-radius", &tooltip_radius,

                        NULL);

  if (tooltip_radius == 0 ||

      gtk_widget_is_composited (tooltip->window))

    {

      gtk_widget_shape_combine_mask (tooltip->window, NULL, 0, 0);

      return;

    }

  gtk_window_get_size (GTK_WINDOW (tooltip->window), &width, &height);

  mask = (GdkBitmap *) gdk_pixmap_new (NULL, width, height, 1);

  cr = gdk_cairo_create (mask);

  fill_background (tooltip->window, cr,

                   &tooltip->window->style->black,

                   &tooltip->window->style->black,

                   255);

  gtk_widget_shape_combine_mask (tooltip->window, mask, 0, 0);

  cairo_destroy (cr);

  g_object_unref (mask);

}

static gboolean

gtk_tooltip_paint_window (GtkTooltip *tooltip)

{

  guchar tooltip_alpha;

  gint tooltip_radius;

  gtk_widget_style_get (tooltip->window,

                        "tooltip-alpha", &tooltip_alpha,

                        "tooltip-radius", &tooltip_radius,

                        NULL);

  if (tooltip_alpha != 255 || tooltip_radius != 0)

    {

      cairo_t *cr;

      cr = gdk_cairo_create (tooltip->window->window);

      fill_background (tooltip->window, cr,

                       &tooltip->window->style->bg [GTK_STATE_NORMAL],

                       &tooltip->window->style->bg [GTK_STATE_SELECTED],

                       tooltip_alpha);

      cairo_destroy (cr);

      update_shape (tooltip);

    }

  else

    {

      gtk_paint_flat_box (tooltip->window->style,

                          tooltip->window->window,

                          GTK_STATE_NORMAL,

                          GTK_SHADOW_OUT,

                          NULL,

                          tooltip->window,

                          "tooltip",

                          0, 0,

                          tooltip->window->allocation.width,

                          tooltip->window->allocation.height);

    }

  return FALSE;

}

static void

gtk_tooltip_window_hide (GtkWidget *widget,

			 gpointer   user_data)

{

  GtkTooltip *tooltip = GTK_TOOLTIP (user_data);

  gtk_tooltip_set_custom (tooltip, NULL);

}

/* event handling, etc */

struct ChildLocation

{

  GtkWidget *child;

  GtkWidget *container;

  gint x;

  gint y;

};

static void

child_location_foreach (GtkWidget *child,

			gpointer   data)

{

  gint x, y;

  struct ChildLocation *child_loc = data;

  /* Ignore invisible widgets */

  if (!gtk_widget_is_drawable (child))

    return;

  x = 0;

  y = 0;

  /* (child_loc->x, child_loc->y) are relative to

   * child_loc->container's allocation.

   */

  if (!child_loc->child &&

      gtk_widget_translate_coordinates (child_loc->container, child,

					child_loc->x, child_loc->y,

					&x, &y))

    {

#ifdef DEBUG_TOOLTIP

      g_print ("candidate: %s  alloc=[(%d,%d)  %dx%d]     (%d, %d)->(%d, %d)\n",

	       gtk_widget_get_name (child),

	       child->allocation.x,

	       child->allocation.y,

	       child->allocation.width,

	       child->allocation.height,

	       child_loc->x, child_loc->y,

	       x, y);

#endif /* DEBUG_TOOLTIP */

      /* (x, y) relative to child's allocation. */

      if (x >= 0 && x < child->allocation.width

	  && y >= 0 && y < child->allocation.height)

        {

	  if (GTK_IS_CONTAINER (child))

	    {

	      struct ChildLocation tmp = { NULL, NULL, 0, 0 };

	      /* Take (x, y) relative the child's allocation and

	       * recurse.

	       */

	      tmp.x = x;

	      tmp.y = y;

	      tmp.container = child;

	      gtk_container_forall (GTK_CONTAINER (child),

				    child_location_foreach, &tmp);

	      if (tmp.child)

		child_loc->child = tmp.child;

	      else

		child_loc->child = child;

	    }

	  else

	    child_loc->child = child;

	}

    }

}

/* Translates coordinates from dest_widget->window relative (src_x, src_y),

 * to allocation relative (dest_x, dest_y) of dest_widget.

 */

static void

window_to_alloc (GtkWidget *dest_widget,

		 gint       src_x,

		 gint       src_y,

		 gint      *dest_x,

		 gint      *dest_y)

{

  /* Translate from window relative to allocation relative */

  if (gtk_widget_get_has_window (dest_widget) && dest_widget->parent)

    {

      gint wx, wy;

      gdk_window_get_position (dest_widget->window, &wx, &wy;;

      /* Offset coordinates if widget->window is smaller than

       * widget->allocation.

       */

      src_x += wx - dest_widget->allocation.x;

      src_y += wy - dest_widget->allocation.y;

    }

  else

    {

      src_x -= dest_widget->allocation.x;

      src_y -= dest_widget->allocation.y;

    }

  if (dest_x)

    *dest_x = src_x;

  if (dest_y)

    *dest_y = src_y;

}

/* Translates coordinates from window relative (x, y) to

 * allocation relative (x, y) of the returned widget.

 */

GtkWidget *

_gtk_widget_find_at_coords (GdkWindow *window,

                            gint       window_x,

                            gint       window_y,

                            gint      *widget_x,

                            gint      *widget_y)

{

  GtkWidget *event_widget;

  struct ChildLocation child_loc = { NULL, NULL, 0, 0 };

  g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);

  gdk_window_get_user_data (window, (void **)&event_widget);

  if (!event_widget)

    return NULL;

#ifdef DEBUG_TOOLTIP

  g_print ("event window %p (belonging to %p (%s))  (%d, %d)\n",

	   window, event_widget, gtk_widget_get_name (event_widget),

	   window_x, window_y);

#endif

  /* Coordinates are relative to event window */

  child_loc.x = window_x;

  child_loc.y = window_y;

  /* We go down the window hierarchy to the widget->window,

   * coordinates stay relative to the current window.

   * We end up with window == widget->window, coordinates relative to that.

   */

  while (window && window != event_widget->window)

    {

      gdouble px, py;

      gdk_window_coords_to_parent (window,

                                   child_loc.x, child_loc.y,

                                   &px, &py;;

      child_loc.x = px;

      child_loc.y = py;