int main(int argc, char *argv[])
{
  ClutterColor stage_color = { 0x00, 0x00, 0x00, 0xff };
  ClutterColor rect_color = { 0xff, 0xff, 0xff, 0x99 };

  clutter_init (&argc, &argv);

  /* Get the stage and set its size and color: */
  ClutterActor *stage = clutter_stage_get_default ();
  clutter_actor_set_size (stage, 200, 200);
  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);

  /* Add a rectangle to the stage: */
  rect = clutter_rectangle_new_with_color (&rect_color);
  clutter_actor_set_size (rect, 40, 40);
  clutter_actor_set_position (rect, 10, 10);
  clutter_container_add_actor (CLUTTER_CONTAINER (stage), rect);
  clutter_actor_show (rect);

  /* Show the stage: */
  clutter_actor_show (stage);

  ClutterTimeline *timeline =  clutter_timeline_new(5000 /* milliseconds */);
  clutter_timeline_set_loop(timeline, TRUE);
  clutter_timeline_start(timeline);

  /* Create a clutter alpha for the animation */
  ClutterAlpha* alpha = clutter_alpha_new_with_func (timeline, &on_alpha, NULL, NULL);
  g_object_unref (timeline);

  /* Create an animation to change the properties */
  ClutterAnimation* animation =
    clutter_actor_animate_with_alpha (rect, alpha,
      "x", 150.0,
      "y", 150.0,
      "opacity", 0,
      NULL);

  /* Start the main loop, so we can respond to events: */
  clutter_main ();

  g_object_unref (animation);

  return EXIT_SUCCESS;
}

static void
on_monitors_changed (MetaScreen *screen,
                     MetaPlugin *plugin)
{
  MetaDefaultPlugin *self = META_DEFAULT_PLUGIN (plugin);
  int i, n;
  GRand *rand = g_rand_new_with_seed (123456);

  clutter_actor_destroy_all_children (self->priv->background_group);

  n = meta_screen_get_n_monitors (screen);
  for (i = 0; i < n; i++)
    {
      MetaRectangle rect;
      ClutterActor *background_actor;
      MetaBackground *background;
      ClutterColor color;

      meta_screen_get_monitor_geometry (screen, i, &rect);

      background_actor = meta_background_actor_new (screen, i);

      clutter_actor_set_position (background_actor, rect.x, rect.y);
      clutter_actor_set_size (background_actor, rect.width, rect.height);

      /* Don't use rand() here, mesa calls srand() internally when
         parsing the driconf XML, but it's nice if the colors are
         reproducible.
      */
      clutter_color_init (&color,
                          g_rand_int_range (rand, 0, 255),
                          g_rand_int_range (rand, 0, 255),
                          g_rand_int_range (rand, 0, 255),
                          255);

      background = meta_background_new (screen);
      meta_background_set_color (background, &color);
      meta_background_actor_set_background (META_BACKGROUND_ACTOR (background_actor), background);
      g_object_unref (background);

      clutter_actor_add_child (self->priv->background_group, background_actor);
    }

  g_rand_free (rand);
}

/* Private functions */
static void
astro_contact_row_set_name (AstroContactRow *row, const gchar *name)
{
  AstroContactRowPrivate *priv;

  g_return_if_fail (ASTRO_IS_CONTACT_ROW (row));
  g_return_if_fail (name);
  priv = row->priv;

  if (priv->name)
    g_free (priv->name);
  priv->name = g_strdup (name);

  clutter_label_set_text (CLUTTER_LABEL (priv->label), name);

  clutter_actor_set_position (priv->label, (PADDING*2)+ICON_SIZE, 
                    (ROW_HEIGHT /2)-(clutter_actor_get_height (priv->label)/2));
}

static void
center_controls (UserInterface * ui)
{
  gfloat x, y, ctl_width, ctl_height;

  ctl_width = ui->stage_width * CONTROLS_WIDTH_RATIO;
  ctl_height = ui->stage_height * CONTROLS_HEIGHT_RATIO;

  if (ctl_width / ctl_height > CONTROLS_ASPECT_RATIO) {
    ctl_width = ctl_height * CONTROLS_ASPECT_RATIO;
  } else {
    ctl_height = ctl_width / CONTROLS_ASPECT_RATIO;
  }

  x = (ui->stage_width - ctl_width) / 2.0f;
  y = ui->stage_height * 2.0f / 3.0f;
  clutter_actor_set_position (ui->control_box, x, y);
}

static void
clutter_behaviour_ellipse_applied (ClutterBehaviour *behave,
                                   ClutterActor     *actor)
{
    ClutterBehaviourEllipse *e = CLUTTER_BEHAVIOUR_ELLIPSE (behave);
    ClutterBehaviourEllipsePrivate *priv = e->priv;
    knot3d knot = { 0, };

    clutter_behaviour_ellipse_advance (e, priv->angle_start, &knot);

    clutter_actor_set_position (actor, knot.x, knot.y);

    /* the depth should be changed only if there is a tilt on
     * any of the X or the Y axis
     */
    if (priv->angle_tilt_x != 0 || priv->angle_tilt_y != 0)
        clutter_actor_set_depth (actor, knot.z);
}

static void reposition_switcher(MetaSwitcher* self)
{
    MetaSwitcherPrivate* priv = self->priv;
    MetaScreen* screen = meta_plugin_get_screen(priv->plugin);

    gint screen_width = 0, screen_height = 0;
    meta_screen_get_size(screen, &screen_width, &screen_height);

    clutter_actor_save_easing_state(priv->top);
    clutter_actor_set_easing_duration(priv->top, 400);
    clutter_actor_set_easing_mode(priv->top, CLUTTER_LINEAR);

    gfloat w = clutter_actor_get_width(priv->top), h = clutter_actor_get_height(priv->top),
            tx = (screen_width - w)/2, ty = (screen_height - h)/2;
    clutter_actor_set_position(priv->top, tx, ty);

    clutter_actor_restore_easing_state(priv->top);
}

static void
add_static_box (ClutterActor *group,
                gint          x,
                gint          y,
                gint          width,
                gint          height)
{
  ClutterActor *box;
  box = clutter_rectangle_new ();
  clutter_actor_set_size (box, width, height);
  clutter_actor_set_position (box, x, y);
  clutter_group_add (CLUTTER_GROUP (group), box);


  clutter_container_child_set (CLUTTER_CONTAINER (group), box,
                               "mode", CLUTTER_BOX2D_STATIC, NULL);

}

static gboolean
glide_image_motion (ClutterActor *actor,
		    ClutterMotionEvent *mev)
{
  GlideImage *image = GLIDE_IMAGE (actor);
  
  if (image->priv->dragging)
    {
      image->priv->motion_since_press = TRUE;
      clutter_actor_set_position (actor,
				  mev->x - image->priv->drag_center_x,
				  mev->y - image->priv->drag_center_y);
      
      return TRUE;
    }
  
  return FALSE;
}

void
gnibbles_warpmanager_rescale (GnibblesWarpManager *warpmanager, gint tilesize)
{
  int i;
  gfloat x_pos, y_pos;
  GError *err = NULL;

  for (i = 0; i < warpmanager->numwarps; i++) {
    clutter_actor_get_position (warpmanager->warps[i]->actor, &x_pos, &y_pos);
    clutter_actor_set_position (warpmanager->warps[i]->actor,
                                (x_pos / properties->tilesize) * tilesize,
                                (y_pos / properties->tilesize) * tilesize);
    gtk_clutter_texture_set_from_pixbuf
      (CLUTTER_TEXTURE (warpmanager->warps[i]->actor), boni_pixmaps[WARP], &err);
    if (err)
      gnibbles_error (err->message);
  }
}

static
gboolean
action_add_text (ClutterActor *action,
                 ClutterEvent *event,
                 gpointer      userdata)
{
  ClutterActor *group = CLUTTER_ACTOR (userdata);
  ClutterActor *title;
  ClutterColor  color;

  clutter_color_from_string (&color, "#888");

  title = clutter_text_new_full ("Sans 30px", "fnord", &color);

  clutter_actor_set_position (title, event->button.x, event->button.y);
  clutter_group_add (CLUTTER_GROUP (group), title);
  return FALSE;
}

ClutterActor *
add_hand (ClutterActor *group,
          gint          x,
          gint          y)
{
  ClutterActor     *actor;

  actor = clutter_texture_new_from_file (ASSETS_DIR "redhand.png", NULL);
  clutter_group_add (CLUTTER_GROUP (group), actor);

  clutter_actor_set_opacity (actor, 1.0 * 255);
  clutter_actor_set_position (actor, x, y);

  clutter_container_child_set (CLUTTER_CONTAINER (group), actor,
                               "manipulatable", TRUE,
                               "mode", CLUTTER_BOX2D_DYNAMIC, NULL);
  return actor;
}

static void manager_event_cursor_set(unsigned short type, void *userdata, void *data)
{
	tuio_cursor_t	*o = (tuio_cursor_t *)data;
	manager_cursor_t	*it;
	ClutterActor *stage;
	unsigned wx, wy;

	for ( it = manager_cursors_list.lh_first; it != NULL; it = it->next.le_next )
		if ( it->id == o->s_id )
			break;

	if ( it == NULL )
		return;

	stage = clutter_stage_get_default ();
	clutter_actor_get_size(stage, &wx, &wy);

	clutter_actor_set_position(it->actor, o->xpos * (float)wx, o->ypos * (float)wy);
}

static void
pkg_graph_2d_place_child (PkgGraph2d  *graph,
                          PkgRenderer *renderer)
{
	PkgGraph2dPrivate *priv = graph->priv;
	gfloat w, h;

	g_debug("renderer place child %p", renderer);

	clutter_actor_get_size(CLUTTER_ACTOR(graph), &w, &h);
	clutter_actor_set_size(CLUTTER_ACTOR(renderer),
	                       w - priv->x_padding,
	                       h - priv->y_padding);
	clutter_actor_set_position(CLUTTER_ACTOR(renderer),
	                           priv->x_padding,
	                           priv->y_padding);
	pkg_graph_2d_paint(graph);
	clutter_actor_queue_redraw(CLUTTER_ACTOR(graph));
}

void
on_timeline_new_frame(ClutterTimeline *timeline,
                      gint frame_num,
                      gpointer data)
{
  HandCar *all = (HandCar *)data;
  gint x, y, actor_width, actor_height;

  
  clutter_actor_get_position(all->label_actor, &x, &y);
  clutter_actor_get_size(all->label_actor, &actor_width, &actor_height);

  if (x < (actor_width * -1))
    x = STAGE_WIDTH;
  else
    x -= 10;
  
  clutter_actor_set_position(all->label_actor, x, y);
}

G_MODULE_EXPORT int
test_texture_material_main (int argc, char *argv[])
{
  ClutterActor *stage, *box;
  ClutterLayoutManager *manager;
  int i;

  g_thread_init (NULL);
  clutter_threads_init ();
  clutter_init (&argc, &argv);

  stage = clutter_stage_new ();
  clutter_stage_set_title (CLUTTER_STAGE (stage), "Texture Material");
  g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);

  manager = clutter_flow_layout_new (CLUTTER_FLOW_HORIZONTAL);
  box = clutter_box_new (manager);
  clutter_actor_add_constraint (box, clutter_bind_constraint_new (stage, CLUTTER_BIND_WIDTH, -25.0));
  clutter_actor_add_constraint (box, clutter_bind_constraint_new (stage, CLUTTER_BIND_HEIGHT, -25.0));
  clutter_actor_set_position (box, 25.0, 25.0);
  clutter_container_add_actor (CLUTTER_CONTAINER (stage), box);

  for (i = 0; i < 48; i++)
    {
      ClutterActor *texture = clutter_texture_new ();

      clutter_texture_set_load_data_async (CLUTTER_TEXTURE (texture), TRUE);
      clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (texture), TRUE);
      clutter_texture_set_from_file (CLUTTER_TEXTURE (texture),
                                     TESTS_DATADIR "/redhand.png",
                                     NULL);
      clutter_actor_set_width (texture, 96);

      clutter_container_add_actor (CLUTTER_CONTAINER (box), texture);
    }

  clutter_actor_show (stage);

  clutter_main ();

  return EXIT_SUCCESS;
}

Preview::Preview():
	width(0),
	height(0),
	blocknr(-1),
	color(-1),
	themeID(0),
	cell_size(20),
	cache(NULL),
	enabled(true)
{
	blocks = new Block*[PREVIEW_WIDTH];
	for (int i = 0; i < PREVIEW_WIDTH; i++) {
		blocks[i] = new Block [PREVIEW_HEIGHT];
	}

	w = gtk_clutter_embed_new();

	g_signal_connect (w, "size_allocate", G_CALLBACK (resize), this);

	/* FIXME: We should scale with the rest of the UI, but that requires
	 * changes to the widget layout - i.e. wrap the preview in an
	 * fixed-aspect box. */
	gtk_widget_set_size_request (w, 120, 120);
	ClutterActor *stage;
	stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (w));

	ClutterColor stage_color = { 0x0, 0x0, 0x0, 0xff };
	clutter_stage_set_color (CLUTTER_STAGE (stage),
				 &stage_color);
	piece = clutter_group_new ();
	clutter_group_add (CLUTTER_GROUP (stage),
			   piece);

	piece_timeline = clutter_timeline_new (180);
	alpha = clutter_alpha_new_full (piece_timeline,
			CLUTTER_EASE_IN_OUT_SINE);
	piece_behav = clutter_behaviour_scale_new (alpha,
			0.6, 0.6, 1.0, 1.0);
	clutter_actor_set_anchor_point (piece, 60, 60);
	clutter_actor_set_position (CLUTTER_ACTOR(piece), 60, 60);
	clutter_behaviour_apply (piece_behav, piece);
}

static void
add_clutter_actor (ClutterActor *actor,
		   ClutterActor *container,
		   int           i)
{
  float x, y, w, h;

  /* Add to our group group */
  clutter_actor_add_child (container, actor);

  /* Place around a circle */
  w = clutter_actor_get_width (widgets[0]);
  h = clutter_actor_get_height (widgets[0]);

  x = WINWIDTH / 2  + RADIUS * cosf (i * 2 * M_PI / (MAX_NWIDGETS)) - w / 2;
  y = WINHEIGHT / 2 + RADIUS * sinf (i * 2 * M_PI / (MAX_NWIDGETS)) - h / 2;

  clutter_actor_set_position (actor, x, y);
  clutter_actor_set_pivot_point (actor, 0.5, 0.5);
}

static void
key_focus_in_cb (ClutterActor *actor,
		 gpointer      data)
{
  ClutterActor *focus_box = CLUTTER_ACTOR (data);  

  if (CLUTTER_IS_STAGE (actor))
    clutter_actor_hide (focus_box);
  else
    {
      clutter_actor_set_position (focus_box,
				  clutter_actor_get_x (actor) - 5,
				  clutter_actor_get_y (actor) - 5);

      clutter_actor_set_size (focus_box,
			      clutter_actor_get_width (actor) + 10,
			      clutter_actor_get_height (actor) + 10);
      clutter_actor_show (focus_box);
    }
}

void show_image(XImage *img)
{
	ClutterActor *stage, *actor;
	
	// init stage
	clutter_init(0, NULL);
	stage = clutter_stage_get_default(); // XX TODO: use root window?
	
	// init actor
	actor = clutter_texture_new();
	clutter_texture_set_from_rgb_data(CLUTTER_TEXTURE(actor), img->data, False, img->width, img->height, img->bytes_per_line, 4, (ClutterTextureFlags)0, NULL);
	clutter_container_add(CLUTTER_CONTAINER(stage), actor, NULL);
  clutter_actor_set_position(actor, 10, 10);
  
  g_signal_connect(stage, "button-press-event", clutter_main_quit, NULL);
  
  // show and wait for exit
  clutter_actor_show(stage);
  clutter_main();
}

static gboolean
create_actor (GstGLClutterActor * actor)
{
  static gint xpos = 0;
  static gint ypos = 0;
  actor->texture = g_object_new (CLUTTER_X11_TYPE_TEXTURE_PIXMAP,
      "window", actor->win, "automatic-updates", TRUE, NULL);
  clutter_container_add_actor (CLUTTER_CONTAINER (actor->stage),
      actor->texture);
  clutter_actor_set_position (actor->texture, xpos, ypos);

  if (xpos > (COLS - 1) * W) {
    xpos = 0;
    ypos += H + 1;
  } else
    xpos += W + 1;
  clutter_actor_show (actor->texture);

  return FALSE;
}