/* gtk-clutter-embed.c: Embeddable ClutterStage

 *

 * Copyright (C) 2007 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.fsf.org/licensing>.

 *

 * Authors:

 *   Iain Holmes  <iain@openedhand.com>

 *   Emmanuele Bassi  <ebassi@openedhand.com>

 */

/**

 * SECTION:gtk-clutter-embed

 * @Title: GtkClutterEmbed

 * @short_description: Widget for embedding a Clutter scene

 * @See_Also: #ClutterStage

 *

 * #GtkClutterEmbed is a GTK+ widget embedding a #ClutterStage inside

 * a GTK+ application.

 *

 * By using a #GtkClutterEmbed widget is possible to build, show and

 * interact with a scene built using Clutter inside a GTK+ application.

 *

 * ## Event handling with GtkClutterEmbed

 *

 * Due to re-entrancy concerns, you should not use GTK event-related

 * API from within event handling signals emitted by Clutter actors

 * inside a #GtkClutterEmbed.

 *

 * Event-related API, like the GTK drag and drop functions, or the

 * GTK grab ones, cause events to be processed inside the GDK event

 * loop; #GtkClutterEmbed and the Clutter event loop may use those

 * events to generate Clutter events, and thus emit signals on

 * #ClutterActors. If you use the event-related signals of a

 * #ClutterActor to call the GTK API, one of the two event loops

 * will try to re-enter into each other, and either cause a crash

 * or simply block your application.

 *

 * To avoid this behavior, you can either:

 *

 *  - only use GTK+ event handling signals to call event-related

 *    GTK functions

 *  - let the main loop re-enter, by calling event-related GTK

 *    functions from within an idle or a timeout callback

 *

 * You should also make sure you're not using GTK widgets that call

 * event-related GTK API, like the grab functions in a #GtkMenu, in

 * response to Clutter actor events.

 *

 * ## Using GtkClutterEmbed as a container

 *

 * Though #GtkClutterEmbed is a #GtkContainer subclass, it is not a

 * real GTK+ container; #GtkClutterEmbed is required to implement the

 * #GtkContainer virtual functions in order to embed a #GtkWidget

 * through the #GtkClutterActor class. Calling gtk_container_add()

 * on a #GtkClutterEmbed will trigger an assertion. It is strongly

 * advised not to override the #GtkContainer implementation when

 * subclassing #GtkClutterEmbed, to avoid breaking internal state.

 */

#include "config.h"

#include <math.h>

#include <string.h>

#include "gtk-clutter-embed.h"

#include "gtk-clutter-offscreen.h"

#include "gtk-clutter-actor.h"

#include <glib-object.h>

#include <gdk/gdk.h>

#if defined(CLUTTER_WINDOWING_X11)

#include <clutter/x11/clutter-x11.h>

#endif

#if defined(CLUTTER_WINDOWING_GDK)

#include <clutter/gdk/clutter-gdk.h>

#endif

#if defined(CLUTTER_WINDOWING_WIN32)

#include <clutter/win32/clutter-win32.h>

#endif

#if defined(CLUTTER_WINDOWING_WAYLAND)

#include <clutter/wayland/clutter-wayland.h>

#endif

#if defined(GDK_WINDOWING_X11)

#include <gdk/gdkx.h>

#endif

#if defined(GDK_WINDOWING_WIN32)

#include <gdk/gdkwin32.h>

#endif

#if defined(GDK_WINDOWING_WAYLAND)

#include <gdk/gdkwayland.h>

#endif

struct _GtkClutterEmbedPrivate

{

  ClutterActor *stage;

  GList *children;

  int n_active_children;

  guint queue_redraw_id;

  guint queue_relayout_id;

  guint geometry_changed : 1;

  guint use_layout_size : 1;

#if defined(GDK_WINDOWING_WAYLAND) && defined(CLUTTER_WINDOWING_WAYLAND)

  struct wl_subcompositor *subcompositor;

  struct wl_surface *clutter_surface;

  struct wl_subsurface *subsurface;

#endif

};

static gint num_filter = 0;

enum

{

  PROP_0,

  PROP_USE_LAYOUT_SIZE

};

G_DEFINE_TYPE_WITH_PRIVATE (GtkClutterEmbed, gtk_clutter_embed, GTK_TYPE_CONTAINER)

static void

gtk_clutter_embed_send_configure (GtkClutterEmbed *embed)

{

  GtkWidget *widget;

  GtkAllocation allocation;

  GdkEvent *event = gdk_event_new (GDK_CONFIGURE);

  widget = GTK_WIDGET (embed);

  gtk_widget_get_allocation (widget, &allocation);

  event->configure.window = g_object_ref (gtk_widget_get_window (widget));

  event->configure.send_event = TRUE;

  event->configure.x = allocation.x;

  event->configure.y = allocation.y;

  event->configure.width = allocation.width;

  event->configure.height = allocation.height;

  gtk_widget_event (widget, event);

  gdk_event_free (event);

}

#if defined(GDK_WINDOWING_WAYLAND) && defined(CLUTTER_WINDOWING_WAYLAND)

static void

gtk_clutter_embed_ensure_surface (GtkClutterEmbed *embed)

{

  GtkClutterEmbedPrivate *priv = embed->priv;

  if (priv->subcompositor && !priv->clutter_surface)

    {

      GdkDisplay *display;

      struct wl_compositor *compositor;

      display = gtk_widget_get_display (GTK_WIDGET (embed));

      compositor = gdk_wayland_display_get_wl_compositor (display);

      priv->clutter_surface = wl_compositor_create_surface (compositor);

    }

}

static void

gtk_clutter_embed_ensure_subsurface (GtkClutterEmbed *embed)

{

  GtkClutterEmbedPrivate *priv;

  GtkWidget *widget;

  struct wl_surface *gtk_surface;

  GdkWindow *window;

  gint x, y;

  widget = GTK_WIDGET (embed);

  priv = embed->priv;

  if (priv->subsurface)

    return;

  window = gtk_widget_get_window (widget);

  gtk_surface = gdk_wayland_window_get_wl_surface (gdk_window_get_toplevel (window));

  priv->subsurface =

    wl_subcompositor_get_subsurface (priv->subcompositor,

                                     priv->clutter_surface,

                                     gtk_surface);

  gdk_window_get_origin (window, &x, &y);

  wl_subsurface_set_position (priv->subsurface, x, y);

  wl_subsurface_set_desync (priv->subsurface);

}

#endif

static void

gtk_clutter_embed_ensure_stage_realized (GtkClutterEmbed *embed)

{

  GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (embed)->priv;

  if (!gtk_widget_get_realized (GTK_WIDGET (embed)))

    return;

  if (!clutter_actor_is_realized (priv->stage))

    {

      GdkWindow *window = gtk_widget_get_window (GTK_WIDGET (embed));

#if defined(CLUTTER_WINDOWING_GDK)

      if (clutter_check_windowing_backend (CLUTTER_WINDOWING_GDK))

        {

          clutter_gdk_set_stage_foreign (CLUTTER_STAGE (priv->stage), window);

        }

      else

#endif

#if defined(GDK_WINDOWING_X11) && defined(CLUTTER_WINDOWING_X11)

      if (clutter_check_windowing_backend (CLUTTER_WINDOWING_X11) &&

          GDK_IS_X11_WINDOW (window))

        {

          clutter_x11_set_stage_foreign (CLUTTER_STAGE (priv->stage),

                                         GDK_WINDOW_XID (window));

        }

      else

#endif

#if defined(GDK_WINDOWING_WIN32) && defined(CLUTTER_WINDOWING_WIN32)

      if (clutter_check_windowing_backend (CLUTTER_WINDOWING_WIN32) &&

          GDK_IS_WIN32_WINDOW (window))

        {

          clutter_win32_set_stage_foreign (CLUTTER_STAGE (priv->stage),

                                           GDK_WINDOW_HWND (window));

        }

      else

#endif

#if defined(GDK_WINDOWING_WAYLAND) && defined (CLUTTER_WINDOWING_WAYLAND)

      if (clutter_check_windowing_backend (CLUTTER_WINDOWING_WAYLAND) &&

          GDK_IS_WAYLAND_WINDOW (window))

        {

          gtk_clutter_embed_ensure_surface (embed);

          clutter_wayland_stage_set_wl_surface (CLUTTER_STAGE (priv->stage),

                                                priv->clutter_surface);

        }

      else

#endif

        {

          g_warning ("No backend found!");

        }

      clutter_actor_realize (priv->stage);

    }

  /* A stage cannot really be unmapped because it is the top of

   * Clutter's scene tree. So if the Gtk embedder is mapped, we

   * translate this as visible for the ClutterStage. */

  if (gtk_widget_get_mapped (GTK_WIDGET (embed)))

    clutter_actor_show (priv->stage);

  clutter_actor_queue_relayout (priv->stage);

  gtk_clutter_embed_send_configure (embed);

#if defined(GDK_WINDOWING_WAYLAND) && defined (CLUTTER_WINDOWING_WAYLAND)

  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_WAYLAND))

    gtk_clutter_embed_ensure_subsurface (embed);

#endif

}

static void

gtk_clutter_embed_stage_unrealize (GtkClutterEmbed *embed)

{

  GtkClutterEmbedPrivate *priv = embed->priv;

#if defined(GDK_WINDOWING_WAYLAND) && defined(CLUTTER_WINDOWING_WAYLAND)

  g_clear_pointer (&priv->subsurface, wl_subsurface_destroy);

  g_clear_pointer (&priv->clutter_surface, wl_surface_destroy);

#endif

  /* gtk may emit an unmap signal after dispose, so it's possible we

   * may have already disposed priv->stage. */

  if (priv->stage != NULL)

    {

      clutter_actor_hide (priv->stage);

      clutter_actor_unrealize (priv->stage);

    }

}

static void

on_stage_queue_redraw (ClutterStage *stage,

                       ClutterActor *origin,

                       gpointer      user_data)

{

  GtkWidget *embed = user_data;

  GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (embed)->priv;

  if (priv->n_active_children > 0)

    priv->geometry_changed = TRUE;

  gtk_widget_queue_draw (embed);

}

static void

on_stage_queue_relayout (ClutterStage *stage,

			 gpointer      user_data)

{

  GtkWidget *embed = user_data;

  GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (embed)->priv;

  if (priv->use_layout_size)

    gtk_widget_queue_resize (embed);

}

static void

gtk_clutter_embed_dispose (GObject *gobject)

{

  GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (gobject)->priv;

  if (priv->stage)

    {

      if (priv->queue_redraw_id)

        g_signal_handler_disconnect (priv->stage, priv->queue_redraw_id);

      if (priv->queue_relayout_id)

        g_signal_handler_disconnect (priv->stage, priv->queue_relayout_id);

      priv->queue_redraw_id = 0;

      priv->queue_relayout_id = 0;

      clutter_actor_destroy (priv->stage);

      priv->stage = NULL;

#if defined(GDK_WINDOWING_WAYLAND) && defined(CLUTTER_WINDOWING_WAYLAND)

      g_clear_pointer (&priv->subsurface, wl_subsurface_destroy);

#endif

    }

  G_OBJECT_CLASS (gtk_clutter_embed_parent_class)->dispose (gobject);

}

static void

gtk_clutter_embed_show (GtkWidget *widget)

{

  GTK_WIDGET_CLASS (gtk_clutter_embed_parent_class)->show (widget);

  gtk_clutter_embed_ensure_stage_realized (GTK_CLUTTER_EMBED (widget));

}

static GdkWindow *

pick_embedded_child (GdkWindow       *offscreen_window,

                     double           widget_x,

                     double           widget_y,

                     GtkClutterEmbed *embed)

{

  GtkClutterEmbedPrivate *priv = embed->priv;

  ClutterActor *a;

  GtkWidget *widget;

  a = clutter_stage_get_actor_at_pos (CLUTTER_STAGE (priv->stage),

				      CLUTTER_PICK_REACTIVE,

				      widget_x, widget_y);

  if (GTK_CLUTTER_IS_ACTOR (a))

    {

      widget = gtk_clutter_actor_get_widget (GTK_CLUTTER_ACTOR (a));

      if (GTK_CLUTTER_OFFSCREEN (widget)->active)

	return gtk_widget_get_window (widget);

    }

  return NULL;

}

static GdkFilterReturn

gtk_clutter_filter_func (GdkXEvent *native_event,

                         GdkEvent  *event         G_GNUC_UNUSED,

                         gpointer   user_data     G_GNUC_UNUSED)

{

#if defined(CLUTTER_WINDOWING_X11)

  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_X11))

    {

      XEvent *xevent = native_event;

      /* let Clutter handle all events coming from the windowing system */

      clutter_x11_handle_event (xevent);

    }

  else

#endif

#if defined(CLUTTER_WINDOWING_WIN32)

  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_WIN32))

    {

      MSG *msg = native_event;

      clutter_win32_handle_event (msg);

    }

  else

#endif

    g_critical ("Unsuppored Clutter backend");

  /* we don't care if Clutter handled the event: we want GDK to continue

   * the event processing as usual

   */

  return GDK_FILTER_CONTINUE;

}

static gboolean

gtk_clutter_embed_draw (GtkWidget *widget, cairo_t *cr)

{

#if defined(CLUTTER_WINDOWING_GDK)

  GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (widget)->priv;

  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_GDK))

    clutter_stage_ensure_redraw (CLUTTER_STAGE (priv->stage));

#endif

  return GTK_WIDGET_CLASS (gtk_clutter_embed_parent_class)->draw (widget, cr);

}

static void

gtk_clutter_embed_realize (GtkWidget *widget)

{

  GtkAllocation allocation;

  GtkStyleContext *style_context;

  GdkWindow *window;

  GdkWindowAttr attributes;

  gint attributes_mask;

  gint border_width;

#if defined(CLUTTER_WINDOWING_GDK)

  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_GDK))

    {

      GdkVisual *visual = clutter_gdk_get_visual ();

      gtk_widget_set_visual (widget, visual);

    }

#endif

#if defined(GDK_WINDOWING_X11) && defined(CLUTTER_WINDOWING_X11)

  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_X11))

    {

      const XVisualInfo *xvinfo;

      GdkVisual *visual;

      /* We need to use the colormap from the Clutter visual, since

       * the visual is tied to the GLX context

       */

      xvinfo = clutter_x11_get_visual_info ();

      if (xvinfo == None)

        {

          g_critical ("Unable to retrieve the XVisualInfo from Clutter");

          return;

        }

      visual = gdk_x11_screen_lookup_visual (gtk_widget_get_screen (widget),

                                             xvinfo->visualid);

      gtk_widget_set_visual (widget, visual);

    }

#endif

  gtk_widget_set_realized (widget, TRUE);

  gtk_widget_get_allocation (widget, &allocation);

  border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));

  attributes.window_type = GDK_WINDOW_CHILD;

  attributes.x = allocation.x + border_width;

  attributes.y = allocation.y + border_width;

  attributes.width = allocation.width - 2 * border_width;

  attributes.height = allocation.height - 2 * border_width;

  attributes.wclass = GDK_INPUT_OUTPUT;

  attributes.visual = gtk_widget_get_visual (widget);

  /* NOTE: GDK_MOTION_NOTIFY above should be safe as Clutter does its own

   *       throttling.

   */

  attributes.event_mask = gtk_widget_get_events (widget)

                        | GDK_EXPOSURE_MASK

                        | GDK_SCROLL_MASK

                        | GDK_BUTTON_PRESS_MASK

                        | GDK_BUTTON_RELEASE_MASK

                        | GDK_KEY_PRESS_MASK

                        | GDK_KEY_RELEASE_MASK

                        | GDK_POINTER_MOTION_MASK

                        | GDK_ENTER_NOTIFY_MASK

                        | GDK_LEAVE_NOTIFY_MASK

                        | GDK_TOUCH_MASK

                        | GDK_SMOOTH_SCROLL_MASK

                        | GDK_STRUCTURE_MASK;

  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;

  window = gdk_window_new (gtk_widget_get_parent_window (widget),

                           &attributes,

                           attributes_mask);

  gtk_widget_set_window (widget, window);

  gdk_window_set_user_data (window, widget);

  /* this does the translation of the event from Clutter to GDK

   * we embedding a GtkWidget inside a GtkClutterActor

   */

  g_signal_connect (window, "pick-embedded-child",

		    G_CALLBACK (pick_embedded_child),

                    widget);

  style_context = gtk_widget_get_style_context (widget);

  gtk_style_context_set_background (style_context, window);

#if defined(GDK_WINDOWING_X11) && defined(CLUTTER_WINDOWING_X11)

  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_X11) &&

      GDK_IS_X11_WINDOW (window))

    {

      if (num_filter == 0)

        gdk_window_add_filter (NULL, gtk_clutter_filter_func, widget);

      num_filter++;

    }

  else

#endif

#if defined(GDK_WINDOWING_WIN32) && defined(CLUTTER_WINDOWING_WIN32)

  if (clutter_check_windowing_backend (CLUTTER_WINDOWING_WIN32) &&

      GDK_IS_WIN32_WINDOW (window))

    {

      if (num_filter == 0)

        gdk_window_add_filter (NULL, gtk_clutter_filter_func, widget);

      num_filter++;

    }

  else

#endif

    {

      /* Nothing to do. */

    }

  gtk_clutter_embed_ensure_stage_realized (GTK_CLUTTER_EMBED (widget));

}

static void

gtk_clutter_embed_unrealize (GtkWidget *widget)

{

  GtkClutterEmbed *embed = GTK_CLUTTER_EMBED (widget);

  if (num_filter > 0)

    {

      num_filter--;

      if (num_filter == 0)

        gdk_window_remove_filter (NULL, gtk_clutter_filter_func, widget);

    }

  gtk_clutter_embed_stage_unrealize (embed);

  GTK_WIDGET_CLASS (gtk_clutter_embed_parent_class)->unrealize (widget);

}

static GtkSizeRequestMode

gtk_clutter_embed_get_request_mode (GtkWidget *widget)

{

  GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (widget)->priv;

  GtkSizeRequestMode mode;

  mode = GTK_SIZE_REQUEST_CONSTANT_SIZE;

  if (priv->stage != NULL &&

      priv->use_layout_size &&

      clutter_actor_get_layout_manager (priv->stage) != NULL)

    {

      switch (clutter_actor_get_request_mode (priv->stage))

	{

	case CLUTTER_REQUEST_HEIGHT_FOR_WIDTH:

	  mode = GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;

	  break;

	case CLUTTER_REQUEST_WIDTH_FOR_HEIGHT:

	  mode = GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT;

	  break;

        case CLUTTER_REQUEST_CONTENT_SIZE:

          mode = GTK_SIZE_REQUEST_CONSTANT_SIZE;

          break;

	}

    }

  return mode;

}

static void

gtk_clutter_embed_get_preferred_width_for_height (GtkWidget *widget,

						  gint       height,

						  gint      *minimum,

						  gint      *natural)

{

  GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (widget)->priv;

  float min, nat;

  min = 0;

  nat = 0;

  if (priv->stage != NULL &&

      priv->use_layout_size)

    {

      ClutterLayoutManager *manager = clutter_actor_get_layout_manager (priv->stage);

      if (manager)

	clutter_layout_manager_get_preferred_width (manager,

						    CLUTTER_CONTAINER (priv->stage),

						    (float)height, &min, &nat);

    }

  min = ceilf (min);

  nat = ceilf (nat);

  if (minimum)

    *minimum = min;

  if (natural)

    *natural = nat;

}

static void

gtk_clutter_embed_get_preferred_height_for_width (GtkWidget *widget,

						  gint       width,

						  gint      *minimum,

						  gint      *natural)

{

  GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (widget)->priv;

  float min, nat;

  min = 0;

  nat = 0;

  if (priv->stage != NULL &&

      priv->use_layout_size)

    {

      ClutterLayoutManager *manager = clutter_actor_get_layout_manager (priv->stage);

      if (manager)

	clutter_layout_manager_get_preferred_height (manager,

						     CLUTTER_CONTAINER (priv->stage),

						     (float)width, &min, &nat);

    }

  min = ceilf (min);

  nat = ceilf (nat);

  if (minimum)

    *minimum = min;

  if (natural)

    *natural = nat;

}

static void

gtk_clutter_embed_get_preferred_width (GtkWidget *widget,

				       gint      *minimum,

				       gint      *natural)

{

  gtk_clutter_embed_get_preferred_width_for_height (widget, -1, minimum, natural);

}

static void

gtk_clutter_embed_get_preferred_height (GtkWidget *widget,

					gint      *minimum,

					gint      *natural)

{

  gtk_clutter_embed_get_preferred_height_for_width (widget, -1, minimum, natural);

}

static void

gtk_clutter_embed_size_allocate (GtkWidget     *widget,

                                 GtkAllocation *allocation)

{

  GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (widget)->priv;

  int scale_factor = gtk_widget_get_scale_factor (widget);

  gtk_widget_set_allocation (widget, allocation);

  /* change the size of the stage and ensure that the viewport

   * has been updated as well

   */

  clutter_actor_set_size (priv->stage, allocation->width, allocation->height);

  if (gtk_widget_get_realized (widget))

    {

      gdk_window_move_resize (gtk_widget_get_window (widget),

                              allocation->x,

                              allocation->y,

                              allocation->width,

                              allocation->height);

      clutter_stage_ensure_viewport (CLUTTER_STAGE (priv->stage));

      gtk_clutter_embed_send_configure (GTK_CLUTTER_EMBED (widget));

#if defined(GDK_WINDOWING_X11) && defined(CLUTTER_WINDOWING_X11)

      if (clutter_check_windowing_backend (CLUTTER_WINDOWING_X11) &&

	  GDK_IS_X11_WINDOW (gtk_widget_get_window (widget)))

	{

	  XConfigureEvent xevent = { ConfigureNotify };

	  xevent.window = GDK_WINDOW_XID (gtk_widget_get_window (widget));

	  xevent.width = allocation->width * scale_factor;

	  xevent.height = allocation->height * scale_factor;

	  /* Ensure cogl knows about the new size immediately, as we will

	     draw before we get the ConfigureNotify response. */

	  clutter_x11_handle_event ((XEvent *)&xevent);

	}

#endif

#if defined(GDK_WINDOWING_WAYLAND) && defined(CLUTTER_WINDOWING_WAYLAND)

      if (priv->subsurface)

        {

          gint x, y;

          gdk_window_get_origin (gtk_widget_get_window (widget), &x, &y);

          wl_subsurface_set_position (priv->subsurface, x, y);

        }

#endif

    }

}

static gboolean

gtk_clutter_embed_map_event (GtkWidget	 *widget,

                             GdkEventAny *event)

{

  GtkClutterEmbed *embed = GTK_CLUTTER_EMBED (widget);

  GtkClutterEmbedPrivate *priv = embed->priv;

  GtkWidgetClass *parent_class;

  gboolean res = FALSE;

  parent_class = GTK_WIDGET_CLASS (gtk_clutter_embed_parent_class);

  if (parent_class->map_event)

    res = parent_class->map_event (widget, event);

  gtk_clutter_embed_ensure_stage_realized (embed);

  clutter_actor_queue_redraw (priv->stage);

  return res;

}

static gboolean

gtk_clutter_embed_unmap_event (GtkWidget   *widget,

                               GdkEventAny *event)

{

  GtkClutterEmbed *embed = GTK_CLUTTER_EMBED (widget);

  GtkWidgetClass *parent_class;

  gboolean res = FALSE;

  parent_class = GTK_WIDGET_CLASS (gtk_clutter_embed_parent_class);

  if (parent_class->unmap_event)

    res = parent_class->unmap_event (widget, event);

  gtk_clutter_embed_stage_unrealize (embed);

  return res;

}

static gboolean

gtk_clutter_embed_focus_in (GtkWidget     *widget,

                            GdkEventFocus *event)

{

  GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (widget)->priv;

  g_signal_emit_by_name (priv->stage, "activate");

  clutter_stage_set_key_focus (CLUTTER_STAGE (priv->stage), NULL);

  return FALSE;

}

static gboolean

gtk_clutter_embed_focus_out (GtkWidget     *widget,

                             GdkEventFocus *event)

{

  GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (widget)->priv;

  g_signal_emit_by_name (priv->stage, "deactivate");

  /* give back key focus to the stage */

  clutter_stage_set_key_focus (CLUTTER_STAGE (priv->stage), NULL);

  return FALSE;

}

static gboolean

gtk_clutter_embed_key_event (GtkWidget   *widget,

                             GdkEventKey *event)

{

  GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (widget)->priv;

  ClutterDeviceManager *manager;

  ClutterInputDevice *device;

  ClutterEvent cevent = { 0, };

  if (event->type == GDK_KEY_PRESS)

    cevent.key.type = CLUTTER_KEY_PRESS;

  else if (event->type == GDK_KEY_RELEASE)

    cevent.key.type = CLUTTER_KEY_RELEASE;

  else

    return FALSE;

  manager = clutter_device_manager_get_default ();

  device = clutter_device_manager_get_core_device (manager, CLUTTER_KEYBOARD_DEVICE);

  cevent.key.stage = CLUTTER_STAGE (priv->stage);

  cevent.key.time = event->time;

  cevent.key.modifier_state = event->state;

  cevent.key.keyval = event->keyval;

  cevent.key.hardware_keycode = event->hardware_keycode;

  cevent.key.unicode_value = gdk_keyval_to_unicode (event->keyval);

  cevent.key.device = device;

  clutter_do_event (&cevent);

  return FALSE;

}

static void

gtk_clutter_embed_style_updated (GtkWidget *widget)

{

  GdkScreen *screen;

  GtkSettings *gtk_settings;

  ClutterSettings *clutter_settings;

  gchar *font_name;

  gint double_click_time, double_click_distance;

#if defined(GDK_WINDOWING_X11) && defined(CLUTTER_WINDOWING_X11)

  gint xft_dpi, xft_hinting, xft_antialias;

  gchar *xft_hintstyle, *xft_rgba;

#endif

  if (gtk_widget_get_realized (widget))

    {

#if 0

      GtkClutterEmbedPrivate *priv = GTK_CLUTTER_EMBED (widget)->priv;

      GtkStyleContext *style_context;

      GtkStateFlags state_flags;

      GdkRGBA *bg_color;

      ClutterColor color;

      style_context = gtk_widget_get_style_context (widget);

      state_flags = gtk_widget_get_state_flags (widget);

      gtk_style_context_get (style_context, state_flags,

                             "background-color", &bg_color,

                             NULL);

      color.red   = CLAMP (bg_color->red   * 255, 0, 255);

      color.green = CLAMP (bg_color->green * 255, 0, 255);

      color.blue  = CLAMP (bg_color->blue  * 255, 0, 255);

      color.alpha = CLAMP (bg_color->alpha * 255, 0, 255);

      clutter_stage_set_color (CLUTTER_STAGE (priv->stage), &color;;

      gdk_rgba_free (bg_color);

#endif

    }

  if (gtk_widget_has_screen (widget))

    screen = gtk_widget_get_screen (widget);

  else

    screen = gdk_screen_get_default ();

  gtk_settings = gtk_settings_get_for_screen (screen);

  g_object_get (G_OBJECT (gtk_settings),

                "gtk-font-name", &font_name,

                "gtk-double-click-time", &double_click_time,

                "gtk-double-click-distance", &double_click_distance,

                NULL);

#if defined(GDK_WINDOWING_X11) && defined(CLUTTER_WINDOWING_X11)

  if (GDK_IS_X11_SCREEN (screen))

    {

      g_object_get (G_OBJECT (gtk_settings),

                    "gtk-xft-dpi", &xft_dpi,

                    "gtk-xft-antialias", &xft_antialias,

                    "gtk-xft-hinting", &xft_hinting,

                    "gtk-xft-hintstyle", &xft_hintstyle,

                    "gtk-xft-rgba", &xft_rgba,

                    NULL);

    }

#endif

  /* copy all settings and values coming from GTK+ into

   * the ClutterBackend; this way, a scene embedded into

   * a GtkClutterEmbed will not look completely alien