/*

 * gtkclutteroffscreen.c

 */

#include "config.h"

#include <gtk/gtk.h>

#include "gtk-clutter-embed.h"

#include "gtk-clutter-offscreen.h"

#include "gtk-clutter-actor-internal.h"

G_DEFINE_TYPE (GtkClutterOffscreen, _gtk_clutter_offscreen, GTK_TYPE_BIN);

void _gtk_clutter_embed_set_child_active (GtkClutterEmbed *embed,

					  GtkWidget *child,

					  gboolean active);

static void

gtk_clutter_offscreen_add (GtkContainer *container,

                           GtkWidget    *child)

{

  GtkClutterOffscreen *offscreen = GTK_CLUTTER_OFFSCREEN (container);

  GTK_CONTAINER_CLASS (_gtk_clutter_offscreen_parent_class)->add (container, child);

  if (offscreen->actor != NULL &&

      clutter_actor_is_visible (offscreen->actor))

    {

      /* force a relayout */

      clutter_actor_queue_relayout (offscreen->actor);

    }

}

static void

gtk_clutter_offscreen_remove (GtkContainer *container,

                              GtkWidget    *child)

{

  GtkClutterOffscreen *offscreen = GTK_CLUTTER_OFFSCREEN (container);

  GTK_CONTAINER_CLASS (_gtk_clutter_offscreen_parent_class)->remove (container, child);

  if (offscreen->actor != NULL &&

      clutter_actor_is_visible (offscreen->actor))

    {

      /* force a relayout */

      clutter_actor_queue_relayout (offscreen->actor);

    }

}

static void

gtk_clutter_offscreen_check_resize (GtkContainer *container)

{

  GtkClutterOffscreen *offscreen = GTK_CLUTTER_OFFSCREEN (container);

  /* queue a relayout only if we're not in the middle of an

   * allocation

   */

  if (offscreen->actor != NULL && !offscreen->in_allocation)

    clutter_actor_queue_relayout (offscreen->actor);

}

static void

offscreen_window_to_parent (GdkWindow           *offscreen_window,

                            double               offscreen_x,

                            double               offscreen_y,

                            double              *parent_x,

                            double              *parent_y,

                            GtkClutterOffscreen *offscreen)

{

  ClutterVertex point, vertex;

  point.x = offscreen_x;

  point.y = offscreen_y;

  point.z = 0;

  clutter_actor_apply_transform_to_point (offscreen->actor, &point, &vertex);

  *parent_x = vertex.x;

  *parent_y = vertex.y;

}

static void

offscreen_window_from_parent (GdkWindow           *window,

                              double               parent_x,

                              double               parent_y,

                              double              *offscreen_x,

                              double              *offscreen_y,

                              GtkClutterOffscreen *offscreen)

{

  gfloat x, y;

  if (clutter_actor_transform_stage_point (offscreen->actor,

                                           parent_x,

                                           parent_y,

                                           &x, &y))

    {

      *offscreen_x = x;

      *offscreen_y = y;

    }

  else

    {

      /* Could't transform. What the heck do we do now? */

      *offscreen_x = parent_x;

      *offscreen_y = parent_y;

    }

}

static void

gtk_clutter_offscreen_realize (GtkWidget *widget)

{

  GtkClutterOffscreen *offscreen = GTK_CLUTTER_OFFSCREEN (widget);

  GtkAllocation allocation;

  GtkStyleContext *style_context;

  GdkWindow *window;

  GdkWindowAttr attributes;

  gint attributes_mask;

  guint border_width;

  GtkWidget *parent, *child;

  GdkScreen *screen;

  gtk_widget_set_realized (widget, TRUE);

  border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));

  gtk_widget_get_allocation (widget, &allocation);

  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.window_type = GDK_WINDOW_OFFSCREEN;

  attributes.event_mask = gtk_widget_get_events (widget)

                        | GDK_EXPOSURE_MASK;

  attributes.visual = gtk_widget_get_visual (widget);

  attributes.wclass = GDK_INPUT_OUTPUT;

  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;

  parent = gtk_widget_get_parent (widget);

  screen = gtk_widget_get_screen (widget);

  window = gdk_window_new (gdk_screen_get_root_window (screen),

			   &attributes,

                           attributes_mask);

  gtk_widget_set_window (widget, window);

  gdk_window_set_user_data (window, widget);

  gdk_offscreen_window_set_embedder (gtk_widget_get_window (parent),

                                     window);

  g_signal_connect (window, "to-embedder",

		    G_CALLBACK (offscreen_window_to_parent),

                    widget);

  g_signal_connect (window, "from-embedder",

		    G_CALLBACK (offscreen_window_from_parent),

                    widget);

  child = gtk_bin_get_child (GTK_BIN (widget));

  if (child != NULL)

    gtk_widget_set_parent_window (child, window);

  style_context = gtk_widget_get_style_context (widget);

  gtk_style_context_set_background (style_context, window);

  if (offscreen->active)

    _gtk_clutter_embed_set_child_active (GTK_CLUTTER_EMBED (parent),

					 widget, TRUE);

}

static void

gtk_clutter_offscreen_unrealize (GtkWidget *widget)

{

  GtkClutterOffscreen *offscreen = GTK_CLUTTER_OFFSCREEN (widget);

  if (offscreen->active)

    _gtk_clutter_embed_set_child_active (GTK_CLUTTER_EMBED (gtk_widget_get_parent (widget)),

					 widget, FALSE);

  GTK_WIDGET_CLASS (_gtk_clutter_offscreen_parent_class)->unrealize (widget);

}

static void

gtk_clutter_offscreen_get_preferred_width (GtkWidget *widget,

                                           gint      *minimum,

                                           gint      *natural)

{

  GtkBin *bin = GTK_BIN (widget);

  GtkWidget *child;

  gint border_width;

  border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));

  *minimum = border_width * 2;

  *natural = border_width * 2;

  child = gtk_bin_get_child (bin);

  if (child != NULL && gtk_widget_get_visible (child))

    {

      gint child_min, child_nat;

      gtk_widget_get_preferred_width (child, &child_min, &child_nat);

      *minimum += child_min;

      *natural += child_nat;

    }

}

static void

gtk_clutter_offscreen_get_preferred_height (GtkWidget *widget,

                                            gint      *minimum,

                                            gint      *natural)

{

  GtkBin *bin = GTK_BIN (widget);

  GtkWidget *child;

  gint border_width;

  border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));

  *minimum = border_width * 2;

  *natural = border_width * 2;

  child = gtk_bin_get_child (bin);

  if (child != NULL && gtk_widget_get_visible (child))

    {

      gint child_min, child_nat;

      gtk_widget_get_preferred_height (child, &child_min, &child_nat);

      *minimum += child_min;

      *natural += child_nat;

    }

}

static void

gtk_clutter_offscreen_size_allocate (GtkWidget     *widget,

				     GtkAllocation *allocation)

{

  GtkAllocation old_allocation;

  GtkBin *bin = GTK_BIN (widget);

  GtkWidget *child;

  gint border_width;

  gtk_widget_get_allocation (widget, &old_allocation);

  /* some widgets call gtk_widget_queue_resize() which triggers a

   * size request/allocate cycle.

   *

   * Calling gdk_window_move_resize() triggers an expose-event of the entire

   * widget tree, so we only want to do it if the allocation has changed in

   * some way, otherwise we can just ignore it.

   */

  if (gtk_widget_get_realized (widget) &&

      (allocation->x != old_allocation.x ||

       allocation->y != old_allocation.y ||

       allocation->width != old_allocation.width ||

       allocation->height != old_allocation.height))

    {

      gdk_window_move_resize (gtk_widget_get_window (widget),

                              0, 0,

                              allocation->width,

                              allocation->height);

    }

  gtk_widget_set_allocation (widget, allocation);

  border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));

  child = gtk_bin_get_child (bin);

  if (child != NULL && gtk_widget_get_visible (child))

    {

      GtkAllocation  child_alloc;

      child_alloc.x = border_width;

      child_alloc.y = border_width;

      child_alloc.width = allocation->width - 2 * border_width;

      child_alloc.height = allocation->height - 2 * border_width;

      gtk_widget_size_allocate (child, &child_alloc);

    }

  gtk_widget_queue_draw (widget);

}

static gboolean

gtk_clutter_offscreen_damage (GtkWidget      *widget,

			      GdkEventExpose *event)

{

  GtkClutterOffscreen *offscreen = GTK_CLUTTER_OFFSCREEN (widget);

  _gtk_clutter_actor_update (GTK_CLUTTER_ACTOR (offscreen->actor),

                             event->area.x,

                             event->area.y,

                             event->area.width,

                             event->area.height);

  return TRUE;

}

static void

_gtk_clutter_offscreen_class_init (GtkClutterOffscreenClass *klass)

{

  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);

  GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);

  widget_class->realize = gtk_clutter_offscreen_realize;

  widget_class->unrealize = gtk_clutter_offscreen_unrealize;

  widget_class->get_preferred_width = gtk_clutter_offscreen_get_preferred_width;

  widget_class->get_preferred_height = gtk_clutter_offscreen_get_preferred_height;

  widget_class->size_allocate = gtk_clutter_offscreen_size_allocate;

  container_class->add = gtk_clutter_offscreen_add;

  container_class->remove = gtk_clutter_offscreen_remove;

  container_class->check_resize = gtk_clutter_offscreen_check_resize;

  g_signal_override_class_handler ("damage-event",

				   GTK_CLUTTER_TYPE_OFFSCREEN,

				   G_CALLBACK (gtk_clutter_offscreen_damage));

}

static void

_gtk_clutter_offscreen_init (GtkClutterOffscreen *offscreen)

{

  gtk_widget_set_has_window (GTK_WIDGET (offscreen), TRUE);

  G_GNUC_BEGIN_IGNORE_DEPRECATIONS

  gtk_container_set_resize_mode (GTK_CONTAINER (offscreen), GTK_RESIZE_IMMEDIATE);

  G_GNUC_END_IGNORE_DEPRECATIONS

  offscreen->active = TRUE;

}

GtkWidget *

_gtk_clutter_offscreen_new (ClutterActor *actor)

{

  GtkClutterOffscreen *offscreen;

  offscreen = g_object_new (GTK_CLUTTER_TYPE_OFFSCREEN, NULL);

  offscreen->actor = actor; /* Back pointer, actor owns widget */

  return GTK_WIDGET (offscreen);

}

void

_gtk_clutter_offscreen_set_active (GtkClutterOffscreen *offscreen,

                                   gboolean             active)

{

  GtkWidget *parent;

  active = !!active;

  if (offscreen->active != active)

    {

      offscreen->active = active;

      parent = gtk_widget_get_parent (GTK_WIDGET (offscreen));

      if (parent != NULL)

	_gtk_clutter_embed_set_child_active (GTK_CLUTTER_EMBED (parent),

					     GTK_WIDGET (offscreen),

					     active);

    }

}

void

_gtk_clutter_offscreen_set_in_allocation (GtkClutterOffscreen *offscreen,

                                          gboolean             in_allocation)

{

  in_allocation = !!in_allocation;

  offscreen->in_allocation = in_allocation;

}

cairo_surface_t *

_gtk_clutter_offscreen_get_surface (GtkClutterOffscreen *offscreen)

{

  return gdk_offscreen_window_get_surface (gtk_widget_get_window (GTK_WIDGET (offscreen)));

}