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;
}

/* object init: create a private structure and pack
 * composed ClutterActors into it
 */
static void
cb_button_init (CbButton *self)
{
  CbButtonPrivate *priv;
  ClutterLayoutManager *layout;

  priv = self->priv = CB_BUTTON_GET_PRIVATE (self);

  clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE);

  /* the only child of this actor is a ClutterBox with a
   * ClutterBinLayout: painting and allocation of the actor basically
   * involves painting and allocating this child box
   */
  layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
                                   CLUTTER_BIN_ALIGNMENT_CENTER);

  priv->child = clutter_box_new (layout);

  /* set the parent of the ClutterBox to this instance */
  clutter_actor_set_parent (priv->child,
                            CLUTTER_ACTOR (self));

  /* add text label to the button; see the ClutterText API docs
   * for more information about available properties
   */
  priv->label = g_object_new (CLUTTER_TYPE_TEXT,
                              "line-alignment", PANGO_ALIGN_CENTER,
                              "ellipsize", PANGO_ELLIPSIZE_END,
                              NULL);

  clutter_container_add_actor (CLUTTER_CONTAINER (priv->child),
                               priv->label);

  /* add a ClutterClickAction on this actor, so we can proxy its
   * "clicked" signal into a signal from this actor
   */
  priv->click_action = clutter_click_action_new ();
  clutter_actor_add_action (CLUTTER_ACTOR (self), priv->click_action);

  g_signal_connect (priv->click_action,
                    "clicked",
                    G_CALLBACK (cb_button_clicked),
                    NULL);
}

int
main (int argc, char *argv[])
{
  ClutterActor *actor, *marker, *stage;
  ChamplainMarkerLayer *layer;
  GpsCallbackData callback_data;

  if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
    return 1;

  stage = clutter_stage_new ();
  clutter_actor_set_size (stage, 800, 600);
  g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);

  /* Create the map view */
  actor = champlain_view_new ();
  clutter_actor_set_size (CLUTTER_ACTOR (actor), 800, 600);
  clutter_container_add_actor (CLUTTER_CONTAINER (stage), actor);

  /* Create the marker layer */
  layer = champlain_marker_layer_new_full (CHAMPLAIN_SELECTION_SINGLE);
  clutter_actor_show (CLUTTER_ACTOR (layer));
  champlain_view_add_layer (CHAMPLAIN_VIEW (actor), CHAMPLAIN_LAYER (layer));

  /* Create a marker */
  marker = create_marker ();
  champlain_marker_layer_add_marker (layer, CHAMPLAIN_MARKER (marker));

  /* Finish initialising the map view */
  g_object_set (G_OBJECT (actor), "zoom-level", 12,
      "kinetic-mode", TRUE, NULL);
  champlain_view_center_on (CHAMPLAIN_VIEW (actor), lat, lon);

  /* Create callback that updates the map periodically */
  callback_data.view = CHAMPLAIN_VIEW (actor);
  callback_data.marker = CHAMPLAIN_MARKER (marker);

  g_timeout_add (1000, (GSourceFunc) gps_callback, &callback_data);

  clutter_actor_show (stage);
  clutter_main ();

  return 0;
}

static ClutterActor *
_add_from_sw_item (PengeEverythingPane *pane,
                   SwItem              *item)
{
  ClutterActor *actor;

  actor = g_object_new (PENGE_TYPE_PEOPLE_TILE,
                        "item", item,
                        NULL);

  clutter_container_add_actor (CLUTTER_CONTAINER (pane), actor);

  g_signal_connect (actor,
                    "remove-clicked",
                    (GCallback)_people_tile_remove_clicked_cb,
                    pane);

  return actor;
}

int
main (int     argc,
      char  **argv)
{
  ClutterActor *stage;
  ClutterActor *tile;

  clutter_init (&argc, &argv);

  stage = clutter_stage_get_default ();

  tile = mpd_disk_tile_new ();
  clutter_container_add_actor (CLUTTER_CONTAINER (stage), tile);

  clutter_actor_show_all (stage);
  clutter_main ();

  return EXIT_SUCCESS;
}

static void
setup_standalone (DawatiStatusPanel *status_panel)
{
    ClutterActor *stage, *status;
    Window xwin;

    status = make_status (status_panel);
    clutter_actor_set_size (status, 1000, 600);

    stage = clutter_stage_new ();
    clutter_actor_set_size (stage, 1000, 600);
    clutter_container_add_actor (CLUTTER_CONTAINER (stage), status);

    clutter_actor_realize (stage);
    xwin = clutter_x11_get_stage_window (CLUTTER_STAGE (stage));

    mpl_panel_clutter_setup_events_with_gtk_for_xid (xwin);

    clutter_actor_show (stage);
}

/**
 * clutter_box_pack:
 * @box: a #ClutterBox
 * @actor: a #ClutterActor
 * @first_property: the name of the first property to set, or %NULL
 * @Varargs: a list of property name and value pairs, terminated by %NULL
 *
 * Adds @actor to @box and sets layout properties at the same time,
 * if the #ClutterLayoutManager used by @box has them
 *
 * This function is a wrapper around clutter_container_add_actor()
 * and clutter_layout_manager_child_set()
 *
 * Language bindings should use the vector-based clutter_box_addv()
 * variant instead
 *
 * Since: 1.2
 */
void
clutter_box_pack (ClutterBox   *box,
                  ClutterActor *actor,
                  const gchar  *first_property,
                  ...)
{
  va_list var_args;

  g_return_if_fail (CLUTTER_IS_BOX (box));
  g_return_if_fail (CLUTTER_IS_ACTOR (actor));

  clutter_container_add_actor (CLUTTER_CONTAINER (box), actor);

  if (first_property == NULL || *first_property == '\0')
    return;

  va_start (var_args, first_property);
  clutter_box_set_property_valist (box, actor, first_property, var_args);
  va_end (var_args);
}

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;
}

EasePdfActor* ease_pdf_actor_construct (GType object_type, EasePdfElement* e, EaseActorContext c) {
#line 325 "ease-pdf-actor.c"
	EasePdfActor * self;
	Block9Data* _data9_;
	EasePdfElement* _tmp0_;
	ClutterActor* _tmp1_;
	PopplerDocument* _tmp2_;
#line 34 "ease-pdf-actor.vala"
	g_return_val_if_fail (e != NULL, NULL);
#line 333 "ease-pdf-actor.c"
	_data9_ = g_slice_new0 (Block9Data);
	_data9_->_ref_count_ = 1;
	_data9_->e = _g_object_ref0 (e);
#line 36 "ease-pdf-actor.vala"
	_data9_->self = g_object_ref (self = (EasePdfActor*) ease_actor_construct (object_type, (EaseElement*) _data9_->e, c));
#line 38 "ease-pdf-actor.vala"
	self->priv->pdf_element = (_tmp0_ = _g_object_ref0 (_data9_->e), _g_object_unref0 (self->priv->pdf_element), _tmp0_);
#line 40 "ease-pdf-actor.vala"
	((EaseActor*) self)->contents = (_tmp1_ = (ClutterActor*) g_object_ref_sink ((ClutterGroup*) clutter_group_new ()), _g_object_unref0 (((EaseActor*) self)->contents), _tmp1_);
#line 41 "ease-pdf-actor.vala"
	clutter_actor_set_width (((EaseActor*) self)->contents, ease_element_get_width ((EaseElement*) _data9_->e));
#line 42 "ease-pdf-actor.vala"
	clutter_actor_set_height (((EaseActor*) self)->contents, ease_element_get_height ((EaseElement*) _data9_->e));
#line 43 "ease-pdf-actor.vala"
	clutter_actor_set_x ((ClutterActor*) self, ease_element_get_x ((EaseElement*) _data9_->e));
#line 44 "ease-pdf-actor.vala"
	clutter_actor_set_y ((ClutterActor*) self, ease_element_get_y ((EaseElement*) _data9_->e));
#line 45 "ease-pdf-actor.vala"
	clutter_container_add_actor ((ClutterContainer*) self, ((EaseActor*) self)->contents);
#line 47 "ease-pdf-actor.vala"
	self->priv->current_page = ease_pdf_element_get_displayed_page (_data9_->e);
#line 48 "ease-pdf-actor.vala"
	self->priv->doc = (_tmp2_ = _g_object_ref0 (_data9_->e->pdf_doc), _g_object_unref0 (self->priv->doc), _tmp2_);
#line 49 "ease-pdf-actor.vala"
	ease_pdf_actor_draw_page (self);
#line 52 "ease-pdf-actor.vala"
	g_signal_connect_data ((EaseElement*) _data9_->e, "changed", (GCallback) __lambda55__ease_element_changed, block9_data_ref (_data9_), (GClosureNotify) block9_data_unref, 0);
#line 361 "ease-pdf-actor.c"
	block9_data_unref (_data9_);
	return self;
}

static ClutterActor *
_add_from_recent_file_event (PengeEverythingPane *pane,
                             ZeitgeistEvent       *event,
                             const gchar         *thumbnail_path)
{
  ClutterActor *actor;

  actor = g_object_new (PENGE_TYPE_RECENT_FILE_TILE,
                        "zg-event", event,
                        "thumbnail-path", thumbnail_path,
                        NULL);

  clutter_container_add_actor (CLUTTER_CONTAINER (pane), actor);

  g_signal_connect (actor,
                    "remove-clicked",
                    (GCallback)_recent_file_tile_remove_clicked_cb,
                    pane);

  return actor;
}

gboolean
cs_selected_lasso_start (ClutterActor  *actor,
                         ClutterEvent  *event)
{
  ClutterModifierType state = event->button.modifier_state;


  g_assert (lasso == NULL);

    {
      ClutterColor lassocolor       = {0xff,0x0,0x0,0x11};
      ClutterColor lassobordercolor = {0xff,0x0,0x0,0x88};
      lasso = clutter_rectangle_new_with_color (&lassocolor);
      clutter_rectangle_set_border_color (CLUTTER_RECTANGLE (lasso), &lassobordercolor);
      clutter_rectangle_set_border_width (CLUTTER_RECTANGLE (lasso), LASSO_BORDER);
      clutter_container_add_actor (CLUTTER_CONTAINER (cs->parasite_root), lasso);
    }
  lx = event->button.x;
  ly = event->button.y;

  clutter_actor_set_position (lasso, lx-LASSO_BORDER, ly-LASSO_BORDER);
  clutter_actor_set_size (lasso, LASSO_BORDER*2, LASSO_BORDER*2);

  manipulate_x = event->button.x;
  manipulate_y = event->button.y;

  g_signal_connect (clutter_actor_get_stage (actor), "captured-event",
                    G_CALLBACK (manipulate_lasso_capture), actor);
  undo = g_string_new ("");
  redo = g_string_new ("");
  SELECT_ACTION_PRE2();

  if (!((state & CLUTTER_SHIFT_MASK) ||
        (state & CLUTTER_CONTROL_MASK)))
    {
      cs_selected_clear ();
    }

  return TRUE;
}

static void
pkg_graph_2d_init (PkgGraph2d *graph)
{
	graph->priv = G_TYPE_INSTANCE_GET_PRIVATE(graph,
	                                          PKG_TYPE_GRAPH_2D,
	                                          PkgGraph2dPrivate);

	graph->priv->texture = clutter_cairo_texture_new(1, 1);
	clutter_container_add_actor(CLUTTER_CONTAINER(graph),
	                            graph->priv->texture);
	clutter_actor_show(graph->priv->texture);

	graph->priv->x_scale = g_object_ref_sink(pkg_scale_linear_new());
	graph->priv->y_scale = g_object_ref_sink(pkg_scale_linear_new());
	graph->priv->x_padding = 25.;
	graph->priv->y_padding = 25.;

	g_signal_connect(graph,
	                 "allocation-changed",
	                 G_CALLBACK(pkg_graph_2d_allocation_changed),
	                 NULL);
}

static void
pkg_graph_2d_real_pack_renderer (PkgGraph    *graph,
                                 PkgRenderer *renderer)
{
	PkgGraph2dPrivate *priv;

	g_return_if_fail(PKG_IS_GRAPH_2D(graph));
	g_return_if_fail(PKG_IS_RENDERER(renderer));

	priv = PKG_GRAPH_2D(graph)->priv;

	if (priv->renderer) {
		g_warning("Renderer already added. "
		          "No support for multiple renderers.");
		return;
	}

	priv->renderer = g_object_ref_sink(renderer);
	clutter_container_add_actor(CLUTTER_CONTAINER(graph),
	                            CLUTTER_ACTOR(renderer));
	pkg_graph_2d_place_child(PKG_GRAPH_2D(graph), renderer);
}

gint
main (gint   argc,   /* IN */
      gchar *argv[]) /* IN */
{
	ClutterActor *stage;
	ClutterActor *graph;

	clutter_init(&argc, &argv);

	stage = clutter_stage_get_default();
	graph = uber_graph_new();
	clutter_container_add_actor(CLUTTER_CONTAINER(stage), graph);
	clutter_actor_set_position(graph, 0, 0);
	clutter_actor_set_size(graph,
	                       clutter_actor_get_width(stage),
	                       clutter_actor_get_height(stage));
	clutter_actor_show(graph);
	clutter_actor_show(stage);
	clutter_main();

	return 0;
}

void Platform::init(int* argc, char*** argv)
{
    if(m_initialized)
        return;

    m_initialized = true;

    if (!g_thread_supported ())
        g_thread_init (NULL);

    clutter_gst_init (argc, argv);

    m_stage = clutter_stage_get_default();
    clutter_actor_set_size(m_stage, (gfloat)960, (gfloat)540);

    m_videoTexture = clutter_texture_new ();
    GstPlaybin::getInstance().init(m_videoTexture);
    clutter_container_add_actor (CLUTTER_CONTAINER (m_stage), m_videoTexture);
    g_signal_connect (CLUTTER_STAGE (m_stage), "fullscreen", G_CALLBACK (Platform::windowSizeChanged), this);
    g_signal_connect (CLUTTER_STAGE (m_stage), "unfullscreen", G_CALLBACK (Platform::windowSizeChanged), this);
//	g_signal_connect (CLUTTER_STAGE (m_stage), "event", G_CALLBACK (Platform::stageEvent), this);
}

static gboolean
restart_game (gpointer data)
{
  int i;

  gnibbles_board_level_new (board, current_level);
  gnibbles_board_level_add_bonus (board, 1);

  for (i = 0; i < properties->numworms; i++) {
    if (!clutter_actor_get_stage (worms[i]->actors))
      clutter_container_add_actor (CLUTTER_CONTAINER (stage), worms[i]->actors);
    gnibbles_worm_show (worms[i]);
  }

  for (i = 0; i < properties->human; i++)
    worms[i]->human = TRUE;

  dummy_id = g_timeout_add_seconds (1, (GSourceFunc) new_game_2_cb, NULL);
  restart_id = 0;

  return FALSE;
}

static void
add_actor (ClutterContainer *container)
{
  ClutterActor *rect;
  ClutterColor color = { 0xff, 0xff, 0xff, 255 };
  static gboolean expand = TRUE;

  clutter_color_from_hls (&color,
                          g_random_double_range (0.0, 360.0), 0.5, 0.5);

  rect = clutter_rectangle_new_with_color (&color);
  clutter_actor_set_size (rect, 32, 64);
  clutter_container_add_actor (container, rect);
  clutter_actor_set_reactive (rect, TRUE);
  g_signal_connect (rect, "enter-event", G_CALLBACK (enter_event), NULL);
  g_signal_connect (rect, "leave-event", G_CALLBACK (leave_event), NULL);
  g_signal_connect (rect, "button-release-event",
                    G_CALLBACK (button_release_event), container);

  clutter_container_child_set (container, rect, "expand", expand, NULL);
  expand = !expand;
}

static void
mpl_panel_clutter_constructed (GObject *self)
{
  MplPanelClutterPrivate *priv = MPL_PANEL_CLUTTER (self)->priv;
  ClutterActor           *stage = NULL;
  ClutterActor           *background;

  if (G_OBJECT_CLASS (mpl_panel_clutter_parent_class)->constructed)
    G_OBJECT_CLASS (mpl_panel_clutter_parent_class)->constructed (self);

  stage = clutter_stage_new ();

  priv->stage = stage;

  /* Load a base style for widgets used in the Mpl panels */
  mpl_panel_clutter_load_base_style ();

  background = (ClutterActor*)mpl_panel_background_new ();
  clutter_container_add_actor (CLUTTER_CONTAINER (stage), background);

  clutter_actor_hide (stage);
}

int
main (int argc, char *argv[])
{
    ClutterActor *actor, *stage;

    if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
        return 1;

    stage = clutter_stage_new ();
    clutter_actor_set_size (stage, 800, 600);
    g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);

    /* Create the map view */
    actor = champlain_view_new ();
    clutter_actor_set_size (CLUTTER_ACTOR (actor), 800, 600);
    clutter_container_add_actor (CLUTTER_CONTAINER (stage), actor);

    clutter_actor_show (stage);
    clutter_main ();

    return 0;
}

int
main (int    argc,
      char **argv)
{
//  GError *error = NULL;
//  gchar *path;
//  MxStyle *style;
  ClutterActor *stage, *avatar;

  clutter_init (&argc, &argv);

//  path = g_build_filename (PKG_DATA_DIR,
//                           "style.css",
//                           NULL);
//
//  style = mx_style_get_default ();
//
//  if (!mx_style_load_from_file (style,
//                                  path,
//                                  &error))
//  {
//    g_warning (G_STRLOC ": Error opening style: %s",
//               error->message);
//    g_clear_error (&error);
//  }
//
//  g_free (path);

  stage = clutter_stage_new ();
  avatar = anerley_tp_user_avatar_new ();

  clutter_container_add_actor (CLUTTER_CONTAINER (stage), avatar);
  clutter_actor_show_all (stage);

  clutter_main ();

  return 0;
}