自学教程：C++ CLUTTER_STAGE函数代码示例

int main (int argc, char **argv){  ClutterActor *stage;  ClutterActor *text;  ClutterAnimation *animation;  ClutterColor red, green, blue;  g_thread_init (NULL);  gst_init (&argc, &argv);  if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)    return 1;  clutter_color_from_string (&red, "red");  clutter_color_from_string (&green, "green");  clutter_color_from_string (&blue, "blue");  stage = clutter_stage_get_default ();  text = g_object_new (CLUTTER_TYPE_TEXT,		       "text", "Red",		       "font-name", "Sans 40px",		       "color", &red,		       NULL);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), text);  animation = clutter_actor_animate (text,				     CLUTTER_EASE_IN_OUT_QUAD,				     3000,				     "x", 320,				     "y", 240,				     NULL);  g_signal_connect (animation, "completed",		    G_CALLBACK (on_animation_completed), NULL);  text = g_object_new (CLUTTER_TYPE_TEXT,		       "text", "Blue",		       "font-name", "Sans 40px",		       "color", &blue,		       "x", 640,		       "y", 0,		       NULL);  clutter_actor_set_anchor_point_from_gravity (text, CLUTTER_GRAVITY_NORTH_EAST);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), text);  animation = clutter_actor_animate (text,				     CLUTTER_EASE_IN_OUT_QUAD,				     3000,				     "x", 320,				     "y", 240,				     NULL);  text = g_object_new (CLUTTER_TYPE_TEXT,		       "text", "Green",		       "font-name", "Sans 40px",		       "color", &green,		       "x", 0,		       "y", 480,		       NULL);  clutter_actor_set_anchor_point_from_gravity (text, CLUTTER_GRAVITY_SOUTH_WEST);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), text);  animation = clutter_actor_animate (text,				     CLUTTER_EASE_IN_OUT_QUAD,				     3000,				     "x", 320,				     "y", 240,				     NULL);  recorder = cinnamon_recorder_new (CLUTTER_STAGE (stage));  cinnamon_recorder_set_filename (recorder, "test-recorder.ogg");  clutter_actor_show (stage);  cinnamon_recorder_record (recorder);  clutter_main ();  return 0;}

voidtest_cogl_vertex_buffer_contiguous (TestUtilsGTestFixture *fixture,		                    void *data){  TestState state;  ClutterActor *stage;  ClutterColor stage_clr = {0x0, 0x0, 0x0, 0xff};  ClutterActor *group;  unsigned int idle_source;  guchar tex_data[] = {    0xff, 0x00, 0x00, 0xff,    0xff, 0x00, 0x00, 0xff,    0x00, 0xff, 0x00, 0xff,    0x00, 0xff, 0x00, 0xff  };  stage = clutter_stage_get_default ();  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_clr);  clutter_actor_get_geometry (stage, &state.stage_geom);  group = clutter_group_new ();  clutter_actor_set_size (group,			  state.stage_geom.width,			  state.stage_geom.height);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), group);  /* We force continuous redrawing incase someone comments out the   * clutter_main_quit and wants visual feedback for the test since we   * wont be doing anything else that will trigger redrawing. */  idle_source = g_idle_add (queue_redraw, stage);  g_signal_connect (group, "paint", G_CALLBACK (on_paint), &state);  state.texture = cogl_texture_new_from_data (2, 2,                                              COGL_TEXTURE_NO_SLICING,                                              COGL_PIXEL_FORMAT_RGBA_8888,                                              COGL_PIXEL_FORMAT_ANY,                                              0, /* auto calc row stride */                                              tex_data);  state.material = cogl_material_new ();  cogl_material_set_color4ub (state.material, 0x00, 0xff, 0x00, 0xff);  cogl_material_set_layer (state.material, 0, state.texture);  {    GLfloat triangle_verts[3][2] =      {	{0.0,	0.0},	{100.0, 100.0},	{0.0,	100.0}      };    GLbyte triangle_colors[3][4] =      {	{0x00, 0x00, 0xff, 0xff}, /* blue */	{0x00, 0x00, 0xff, 0x00}, /* transparent blue */	{0x00, 0x00, 0xff, 0x00}  /* transparent blue */      };    GLfloat triangle_tex_coords[3][2] =      {        {0.0, 0.0},        {1.0, 1.0},        {0.0, 1.0}      };    state.buffer = cogl_vertex_buffer_new (3 /* n vertices */);    cogl_vertex_buffer_add (state.buffer,			    "gl_Vertex",			    2, /* n components */			    GL_FLOAT,			    FALSE, /* normalized */			    0, /* stride */			    triangle_verts);    cogl_vertex_buffer_add (state.buffer,			    "gl_Color::blue",			    4, /* n components */			    GL_UNSIGNED_BYTE,			    FALSE, /* normalized */			    0, /* stride */			    triangle_colors);    cogl_vertex_buffer_add (state.buffer,			    "gl_MultiTexCoord0",			    2, /* n components */			    GL_FLOAT,			    FALSE, /* normalized */			    0, /* stride */			    triangle_tex_coords);    cogl_vertex_buffer_submit (state.buffer);  }  clutter_actor_show_all (stage);  clutter_main ();  cogl_handle_unref (state.buffer);  cogl_handle_unref (state.material);  cogl_handle_unref (state.texture);  g_source_remove (idle_source);//.........这里部分代码省略.........

G_MODULE_EXPORT inttest_paint_wrapper_main (int argc, char *argv[]){    ClutterAlpha *alpha;    ClutterActor *stage;    ClutterColor  stage_color = { 0x61, 0x64, 0x8c, 0xff };    SuperOH      *oh;    gint          i;    GError       *error;    ClutterActor *real_hand;    error = NULL;#ifdef HAVE_CLUTTER_GLX    clutter_x11_set_use_argb_visual (TRUE);#endif    clutter_init_with_args (&argc, &argv,                            NULL,                            super_oh_entries,                            NULL,                            &error);    if (error)    {        g_warning ("Unable to initialise Clutter:/n%s",                   error->message);        g_error_free (error);        return EXIT_FAILURE;    }    stage = clutter_stage_get_default ();    clutter_actor_set_size (stage, 800, 600);    if (use_alpha != 255)    {        clutter_stage_set_use_alpha (CLUTTER_STAGE (stage), TRUE);        clutter_actor_set_opacity (stage, use_alpha);    }    clutter_stage_set_title (CLUTTER_STAGE (stage), "Paint Test");    clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);    oh = g_new(SuperOH, 1);    oh->stage = stage;    /* Create a timeline to manage animation */    oh->timeline = clutter_timeline_new (6000);    clutter_timeline_set_loop (oh->timeline, TRUE);    /* fire a callback for frame change */    g_signal_connect (oh->timeline, "new-frame", G_CALLBACK (frame_cb), oh);    /* Set up some behaviours to handle scaling  */    alpha = clutter_alpha_new_with_func (oh->timeline, my_sine_wave, NULL, NULL);    oh->scaler_1 = clutter_behaviour_scale_new (alpha, 0.5, 0.5, 1.0, 1.0);    oh->scaler_2 = clutter_behaviour_scale_new (alpha, 1.0, 1.0, 0.5, 0.5);    real_hand = clutter_texture_new_from_file (TESTS_DATADIR                G_DIR_SEPARATOR_S                "redhand.png",                &error);    if (real_hand == NULL)    {        g_error ("image load failed: %s", error->message);        return EXIT_FAILURE;    }    /* create a new group to hold multiple actors in a group */    oh->group = clutter_group_new();    oh->hand = g_new (ClutterActor*, n_hands);    oh->stage_width = clutter_actor_get_width (stage);    oh->stage_height = clutter_actor_get_height (stage);    oh->radius = (oh->stage_width + oh->stage_height)                 / n_hands;    for (i = 0; i < n_hands; i++)    {        gint x, y, w, h;        if (i == 0)            oh->hand[i] = real_hand;        else            oh->hand[i] = clutter_clone_new (real_hand);        clutter_actor_set_reactive (oh->hand[i], TRUE);        clutter_actor_set_size (oh->hand[i], 200, 213);        /* Place around a circle */        w = clutter_actor_get_width (oh->hand[i]);        h = clutter_actor_get_height (oh->hand[i]);        x = oh->stage_width / 2            + oh->radius            * cos (i * G_PI / (n_hands / 2))            - w / 2;//.........这里部分代码省略.........

intmain (int argc, char *argv[]){  ClutterActor    *stage;  ClutterColor     stage_color = { 0x00, 0x00, 0x00, 0xff };  ClutterActor    *label;  int              w, h;  int              row, col;  float            scale = 1.0f;  g_setenv ("CLUTTER_VBLANK", "none", FALSE);  g_setenv ("CLUTTER_DEFAULT_FPS", "1000", FALSE);  clutter_init (&argc, &argv);  if (argc != 3)    {      g_printerr ("Usage test-text-perf FONT_SIZE N_CHARS/n");      exit (1);    }  font_size = atoi (argv[1]);  n_chars = atoi (argv[2]);  g_print ("Monospace %dpx, string length = %d/n", font_size, n_chars);  stage = clutter_stage_get_default ();  clutter_actor_set_size (stage, STAGE_WIDTH, STAGE_HEIGHT);  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);  g_signal_connect (stage, "paint", G_CALLBACK (on_paint), NULL);  label = create_label ();  w = clutter_actor_get_width (label);  h = clutter_actor_get_height (label);  /* If the label is too big to fit on the stage then scale it so that     it will fit */  if (w > STAGE_WIDTH || h > STAGE_HEIGHT)    {      float x_scale = STAGE_WIDTH / (float) w;      float y_scale = STAGE_HEIGHT / (float) h;      if (x_scale < y_scale)        {          scale = x_scale;          cols = 1;          rows = STAGE_HEIGHT / (h * scale);        }      else        {          scale = y_scale;          cols = STAGE_WIDTH / (w * scale);          rows = 1;        }      g_print ("Text scaled by %f to fit on the stage/n", scale);    }  else    {      cols = STAGE_WIDTH / w;      rows = STAGE_HEIGHT / h;    }  clutter_actor_destroy (label);  for (row=0; row<rows; row++)    for (col=0; col<cols; col++)      {	label = create_label();        clutter_actor_set_scale (label, scale, scale);	clutter_actor_set_position (label, w * col * scale, h * row * scale);	clutter_container_add_actor (CLUTTER_CONTAINER (stage), label);      }  clutter_actor_show_all (stage);  g_idle_add (queue_redraw, stage);  clutter_main ();  return 0;}

static void moses_overview_dispose(GObject *object){    MosesOverview *overview = MOSES_OVERVIEW(object);    MosesOverviewPrivate* priv = overview->priv;    if (priv->disposed) return;    priv->disposed = TRUE;    g_clear_pointer(&priv->ov_head, g_object_unref);    MetaScreen* screen = meta_plugin_get_screen(priv->plugin);    ClutterActor* stage = meta_get_stage_for_screen(screen);    ClutterActor* to_focus = NULL;    if (priv->selected_actor) {        to_focus = clutter_clone_get_source(CLUTTER_CLONE(priv->selected_actor));    }    for (int i = 0; priv->clones && i < priv->clones->len; i++) {        ClutterActor* clone = g_ptr_array_index(priv->clones, i);        ClutterActor* orig = clutter_clone_get_source(CLUTTER_CLONE(clone));        clutter_actor_show(orig); // FIXME: maybe some actors had not been shown.        clutter_actor_destroy(clone);    }    for (int i = 0; priv->badges && i < priv->badges->len; i++) {        clutter_actor_destroy(CLUTTER_ACTOR(g_ptr_array_index(priv->badges, i)));    }    if (priv->background_actor) {        clutter_actor_show(clutter_clone_get_source(CLUTTER_CLONE(priv->background_actor)));        g_clear_pointer(&priv->background_actor, clutter_actor_destroy);    }    if (priv->modaled) {        meta_plugin_end_modal(priv->plugin, clutter_get_current_event_time());        meta_enable_unredirect_for_screen(screen);        if (priv->selected_workspace) {            meta_workspace_activate(priv->selected_workspace, CLUTTER_CURRENT_TIME);            MetaDisplay* display = meta_screen_get_display(screen);            meta_compositor_switch_workspace(meta_display_get_compositor(display),                    meta_screen_get_active_workspace(screen),                    priv->selected_workspace, META_MOTION_DOWN);        } else if (to_focus) {            clutter_stage_set_key_focus(CLUTTER_STAGE(stage), to_focus);            MetaWindowActor* actor = META_WINDOW_ACTOR(to_focus);            MetaWindow* win = meta_window_actor_get_meta_window(actor);            meta_window_raise(win);            meta_window_focus(win, CLUTTER_CURRENT_TIME);        } else if (priv->previous_focused) {            if (!CLUTTER_IS_STAGE(priv->previous_focused)) {                clutter_stage_set_key_focus(CLUTTER_STAGE(stage), priv->previous_focused);            }        }    }    G_OBJECT_CLASS(moses_overview_parent_class)->dispose(object);}

intmain (int   argc,      char *argv[]){  ClutterActor *stage;  ClutterActor *texture;  gchar *image_path;  GError *error = NULL;  if (argc < 2)    {      g_print ("Usage: %s <path to image file>/n", argv[0]);      exit (EXIT_FAILURE);    }  image_path = argv[1];  if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)    return 1;  stage = clutter_stage_new ();  clutter_actor_set_size (stage, STAGE_SIDE, STAGE_SIDE);  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);  g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);  texture = clutter_texture_new ();  clutter_actor_set_reactive (texture, TRUE);  clutter_actor_set_width (texture, STAGE_SIDE);  clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (texture), TRUE);  clutter_actor_add_action (texture, clutter_drag_action_new ());  g_object_set (G_OBJECT (texture),                "scale-gravity", CLUTTER_GRAVITY_NORTH_WEST,                NULL);  clutter_texture_set_from_file (CLUTTER_TEXTURE (texture), image_path, &error);  if (error != NULL)    {      g_warning ("Error loading %s/n%s", image_path, error->message);      g_error_free (error);      exit (EXIT_FAILURE);    }  clutter_actor_set_y (texture, (STAGE_SIDE - clutter_actor_get_height (texture)) * 0.5);  g_signal_connect (texture,                    "button-release-event",                    G_CALLBACK (clicked_cb),                    NULL);  g_signal_connect_swapped (stage,                            "key-press-event",                            G_CALLBACK (key_press_cb),                            texture);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), texture);  clutter_actor_show (stage);  clutter_main ();  return EXIT_SUCCESS;}

voidmex_epg_grid_add_events (MexEpgGrid *grid,                         MexChannel *channel,                         GPtrArray  *events){  MexEpgGridPrivate *priv;  MexChannelManager *channel_manager;  MxFocusManager *focus_manager;  GPtrArray *row;  gint position;  guint i;  g_return_if_fail (MEX_IS_EPG_GRID (grid));  g_return_if_fail (MEX_IS_CHANNEL (channel));  g_return_if_fail (events);  priv = grid->priv;  channel_manager = mex_channel_manager_get_default ();  position = mex_channel_manager_get_channel_position (channel_manager,                                                       channel);  if (G_UNLIKELY (position == -1))    {      MEX_WARN (EPG, "Could not find position of channel %s",                mex_channel_get_name (channel));      return;    }  /* no events for this channel */  if (G_UNLIKELY (events->len == 0))    {      /* signal that we won't have data for that row */      row_loaded (grid, position);      return;    }  /* we insert tiles in bulk, removing the existing tiles if needed */  row = g_ptr_array_index (priv->rows, position);  /* If we already have data for that row, we assume the caller wants to   * replace the data. If we don't we signal that a new row is loaded */  if (row)    remove_row (grid, position);  else    row_loaded (grid, position);  row = g_ptr_array_new ();  g_ptr_array_set_size (row, events->len);  /* We are adding events, it's a good time to check if we have a valid   * current date */  if (priv->current_date == NULL)    priv->current_date = g_date_time_new_now_local ();  for (i = 0; i < events->len; i++)    {      MexEpgEvent *event = g_ptr_array_index (events, i);      ClutterActor *tile;      tile = mex_epg_tile_new_with_event (event);      g_signal_connect (tile, "clicked",                        G_CALLBACK (on_tile_clicked), grid);      clutter_actor_set_parent (tile, CLUTTER_ACTOR (grid));      g_ptr_array_index (row, i) = tile;#if 0      /* Disabled because we don't need to style differently the events that       * are occuring now in the current design, might come back though */      if (mex_epg_event_is_date_in_between (event, priv->current_date))        mx_stylable_set_style_class (MX_STYLABLE (tile), "EpgTileNow");#endif    }  g_ptr_array_index (priv->rows, position) = row;  /* If the EpgGrid had the focus before we had a chance to add events,   * it's a good time to push the focus to one of the EpgTile */  /* FIXME: default to the channel we are watching, not row 0 */  if (priv->has_focus_but_no_tile && position == 0 && row->len > 0)    {      ClutterActor *focused_tile = g_ptr_array_index (row, 0);      ClutterActor *stage;      stage = clutter_actor_get_stage (focused_tile);      focus_manager = mx_focus_manager_get_for_stage (CLUTTER_STAGE (stage));      mx_focus_manager_push_focus (focus_manager, MX_FOCUSABLE (focused_tile));      g_signal_emit (grid, signals[SIGNAL_ROW_SELECTED], 0, 0);      priv->has_focus_but_no_tile = FALSE;    }  /* We have a new row, relayout */  clutter_actor_queue_relayout (CLUTTER_ACTOR (grid));}

intmain (int argc, char **argv){  glong i;  gdouble angle;  ClutterColor color = { 0x00, 0x00, 0x00, 0xff };  ClutterActor *stage, *rect;  clutter_perf_fps_init ();  if (CLUTTER_INIT_SUCCESS !=        clutter_init_with_args (&argc, &argv,                                NULL,                                entries,                                NULL,                                NULL))    {      g_warning ("Failed to initialize clutter");      return -1;    }  stage = clutter_stage_new ();  clutter_actor_set_size (stage, 512, 512);  clutter_stage_set_color (CLUTTER_STAGE (stage), CLUTTER_COLOR_Black);  clutter_stage_set_title (CLUTTER_STAGE (stage), "Picking Performance");  g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);  printf ("Picking performance test with "          "%d actors and %d events per frame/n",          n_actors,          n_events);  for (i = n_actors - 1; i >= 0; i--)    {      angle = ((2.0 * G_PI) / (gdouble) n_actors) * i;      color.red = (1.0 - ABS ((MAX (0, MIN (n_actors/2.0 + 0, i))) /                  (gdouble)(n_actors/4.0) - 1.0)) * 255.0;      color.green = (1.0 - ABS ((MAX (0, MIN (n_actors/2.0 + 0,                    fmod (i + (n_actors/3.0)*2, n_actors)))) /                    (gdouble)(n_actors/4) - 1.0)) * 255.0;      color.blue = (1.0 - ABS ((MAX (0, MIN (n_actors/2.0 + 0,                   fmod ((i + (n_actors/3.0)), n_actors)))) /                   (gdouble)(n_actors/4.0) - 1.0)) * 255.0;      rect = clutter_rectangle_new_with_color (&color);      clutter_actor_set_size (rect, 100, 100);      clutter_actor_set_anchor_point_from_gravity (rect,                                                   CLUTTER_GRAVITY_CENTER);      clutter_actor_set_position (rect,                                  256 + 206 * cos (angle),                                  256 + 206 * sin (angle));      clutter_actor_set_reactive (rect, TRUE);      g_signal_connect (rect, "motion-event",                        G_CALLBACK (motion_event_cb), NULL);      clutter_container_add_actor (CLUTTER_CONTAINER (stage), rect);    }  clutter_actor_show (stage);  clutter_perf_fps_start (CLUTTER_STAGE (stage));  clutter_threads_add_idle (queue_redraw, stage);  clutter_main ();  clutter_perf_fps_report ("test-picking");  return 0;}

intmain (int argc, char *argv[]){  ClutterActor *stage, *actor;  ClutterContainer *container;  ClutterColor stage_color = { 0xcc, 0xcc, 0xcc, 0xff };  ClutterColor rect_color = { 0, 0, 0, 0xdd };  clutter_init (&argc, &argv);  timeline = clutter_timeline_new_for_duration (5000);  clutter_timeline_set_loop (timeline, TRUE);  tmpl =    clutter_effect_template_new (timeline, CLUTTER_ALPHA_RAMP_INC);  stage = clutter_stage_get_default ();  container = CLUTTER_CONTAINER (stage);  g_signal_connect (stage,                    "button-press-event", G_CALLBACK (clutter_main_quit),                     NULL);  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);  clutter_stage_set_use_fog (CLUTTER_STAGE (stage), TRUE);  clutter_actor_set_size (stage, 800, 600);  clutter_actor_show_all (stage);  actor = clutter_rectangle_new_with_color (&rect_color);  clutter_container_add_actor (container, actor);  clutter_actor_set_size (actor, 50, 50);  clutter_actor_set_position (actor, 50, 10);  clutter_effect_fade (tmpl, actor, 0x22, NULL, NULL);  clutter_actor_show (actor);  actor = clutter_rectangle_new_with_color (&rect_color);  clutter_container_add_actor (container, actor);  clutter_actor_set_size (actor, 50, 50);  clutter_actor_set_position (actor, 750, 70);  clutter_effect_depth (tmpl, actor, -500, NULL, NULL);  clutter_actor_show (actor);  actor = clutter_rectangle_new_with_color (&rect_color);  clutter_container_add_actor (container, actor);  clutter_actor_set_size (actor, 50, 50);  clutter_actor_set_position (actor, 50, 140);  clutter_effect_move (tmpl, actor, 750, 140, NULL, NULL);   clutter_actor_show (actor);  actor = clutter_rectangle_new_with_color (&rect_color);  clutter_container_add_actor (container, actor);  clutter_actor_set_size (actor, 50, 50);  clutter_actor_set_position (actor, 750, 210);  {    ClutterKnot knots[2];    knots[0].x = 750; knots[0].y = 210;    knots[1].x = 350; knots[1].y = 210;    clutter_effect_path (tmpl, actor, knots, 2, NULL, NULL);  }  clutter_actor_show (actor);  actor = clutter_rectangle_new_with_color (&rect_color);  clutter_container_add_actor (container, actor);  clutter_actor_set_size (actor, 50, 50);  clutter_actor_set_position (actor, 50, 280);  clutter_actor_set_anchor_point_from_gravity (actor, CLUTTER_GRAVITY_CENTER);    clutter_effect_scale (tmpl, actor, 2.0, 2.0, NULL, NULL);  clutter_actor_show (actor);  actor = clutter_rectangle_new_with_color (&rect_color);  clutter_container_add_actor (container, actor);  clutter_actor_set_size (actor, 50, 50);  clutter_actor_set_position (actor, 750, 350);  clutter_effect_rotate (tmpl, actor,                         CLUTTER_Z_AXIS, 180.0,                         25, 25, 0,                         CLUTTER_ROTATE_CW,                         NULL, NULL);  clutter_actor_show (actor);  clutter_main ();  g_object_unref (tmpl);  g_object_unref (timeline);  return EXIT_SUCCESS;}

G_MODULE_EXPORT ginttest_animator_main (gint    argc,                    gchar **argv){  ClutterActor *stage;  ClutterActor *rects[COUNT];  gint i;  clutter_init (&argc, &argv);  stage = clutter_stage_get_default ();  for (i=0; i<COUNT; i++)    {      rects[i]=new_rect (255 *(i * 1.0/COUNT), 50, 160, 255);      clutter_container_add_actor (CLUTTER_CONTAINER (stage), rects[i]);      clutter_actor_set_anchor_point (rects[i], 64, 64);      clutter_actor_set_position (rects[i], 320.0, 240.0);      clutter_actor_set_opacity (rects[i], 0x70);    }  g_timeout_add (10000, nuke_one, rects[2]);  animator = clutter_animator_new ();  /* Note: when both animations are active for the same actor at the same   * time there is a race, such races should be handled by avoiding   * controlling the same properties from multiple animations. This is   * an intentional design flaw of this test for testing the corner case.   */  clutter_animator_set (animator,         rects[0], "x",       1,                    0.0,  180.0,         rects[0], "x",       CLUTTER_LINEAR,       0.25, 450.0,         rects[0], "x",       CLUTTER_LINEAR,       0.5,  450.0,         rects[0], "x",       CLUTTER_LINEAR,       0.75, 180.0,         rects[0], "x",       CLUTTER_LINEAR,       1.0,  180.0,         rects[0], "y",       -1,                   0.0,   100.0,         rects[0], "y",       CLUTTER_LINEAR,       0.25,  100.0,         rects[0], "y",       CLUTTER_LINEAR,       0.5,   380.0,         rects[0], "y",       CLUTTER_LINEAR,       0.75,  380.0,         rects[0], "y",       CLUTTER_LINEAR,       1.0,   100.0,         rects[3], "x",       0,                    0.0,  180.0,         rects[3], "x",       CLUTTER_LINEAR,       0.25, 180.0,         rects[3], "x",       CLUTTER_LINEAR,       0.5,  450.0,         rects[3], "x",       CLUTTER_LINEAR,       0.75, 450.0,         rects[3], "x",       CLUTTER_LINEAR,       1.0,  180.0,         rects[3], "y",       0,                    0.0,  100.0,         rects[3], "y",       CLUTTER_LINEAR,       0.25, 380.0,         rects[3], "y",       CLUTTER_LINEAR,       0.5,  380.0,         rects[3], "y",       CLUTTER_LINEAR,       0.75, 100.0,         rects[3], "y",       CLUTTER_LINEAR,       1.0,  100.0,         rects[2], "rotation-angle-y",       0,                    0.0,  0.0,         rects[2], "rotation-angle-y",       CLUTTER_LINEAR,       1.0,  360.0,         rects[1], "scale-x", 0,                    0.0,  1.0,         rects[1], "scale-x", CLUTTER_LINEAR,       1.0,  2.0,         rects[1], "scale-y", 0,                    0.0,  1.0,         rects[1], "scale-y", CLUTTER_LINEAR,       1.0,  2.0,         NULL);  clutter_actor_set_scale (rects[0], 1.4, 1.4);  clutter_animator_property_set_ease_in (animator, G_OBJECT (rects[0]), "x",                                         TRUE);  clutter_animator_property_set_ease_in (animator, G_OBJECT (rects[0]), "y",                                         TRUE);  clutter_animator_property_set_interpolation (animator, G_OBJECT (rects[0]),                                               "x", CLUTTER_INTERPOLATION_CUBIC);  clutter_animator_property_set_interpolation (animator, G_OBJECT (rects[0]),                                               "y", CLUTTER_INTERPOLATION_CUBIC);  clutter_stage_hide_cursor(CLUTTER_STAGE (stage));  clutter_actor_show (stage);  clutter_animator_set_duration (animator, 5000);  g_signal_connect (clutter_animator_start (animator),                    "completed", G_CALLBACK (reverse_timeline), NULL);  clutter_main ();  g_object_unref (animator);  return EXIT_SUCCESS;}

G_MODULE_EXPORT ginttest_shader_main (gint argc, gchar *argv[]){  ClutterActor  *actor;  ClutterActor  *stage;  ClutterColor   stage_color = { 0x61, 0x64, 0x8c, 0xff };  ClutterShader *shader;  GError        *error;  gchar         *file;  if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)    return 1;  stage = clutter_stage_new ();  clutter_stage_set_title (CLUTTER_STAGE (stage), "Shaders");  clutter_actor_set_size (stage, 512, 384);  g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);  g_print ("applying shaders[%i] named '%s'/n",           shader_no,           shaders[shader_no].name);  shader = clutter_shader_new ();  error = NULL;  clutter_shader_set_fragment_source (shader, shaders[shader_no].source, -1);  clutter_shader_compile (shader, &error);  if (error)    {      g_print ("unable to load shaders[%d] named '%s': %s/n",               shader_no,               shaders[shader_no].name,               error->message);      g_error_free (error);      return EXIT_FAILURE;    }  clutter_stage_set_title (CLUTTER_STAGE (stage), "Shader Test");  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);  file = g_build_filename (TESTS_DATADIR, "redhand.png", NULL);#ifndef TEST_GROUP  actor = clutter_texture_new_from_file (file, &error);  if (!actor)    g_error("pixbuf load failed: %s", error ? error->message : "Unknown");#else  actor = clutter_group_new ();  {    ClutterActor *child1, *child2, *child3, *child4;    ClutterColor  color = { 0xff, 0x22, 0x66, 0x99 };    child1 = clutter_texture_new_from_file (file, &error);    if (!child1)      g_error("pixbuf load failed: %s", error ? error->message : "Unknown");    child2 = clutter_texture_new_from_file (file, &error);    if (!child2)      g_error("pixbuf load failed: %s", error ? error->message : "Unknown");    child3 = clutter_rectangle_new ();    child4 = clutter_text_new_with_text ("Sans 20px", "Shady stuff");    clutter_rectangle_set_color (CLUTTER_RECTANGLE (child3), &color);    clutter_actor_set_size (child3, 50, 50);    clutter_actor_set_position (child1, 0, 0);    clutter_actor_set_position (child2, 50, 100);    clutter_actor_set_position (child3, 30, -30);    clutter_actor_set_position (child4, -50, 20);    clutter_container_add (CLUTTER_CONTAINER (actor),                           child1,                           child2,                           child3,                           child4,                           NULL);    clutter_actor_show_all (actor);  }#endif /* !TEST_GROUP */  g_free (file);  clutter_actor_set_shader (actor, shader);  clutter_actor_set_position (actor, 100, 100);  g_object_unref (shader);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), actor);  clutter_actor_set_shader_param_int (actor, "tex", 0);  clutter_actor_set_shader_param_float (actor, "brightness", 0.4);  clutter_actor_set_shader_param_float (actor, "contrast", -1.9);  clutter_actor_set_reactive (actor, TRUE);  g_signal_connect (actor, "button-release-event",                    G_CALLBACK (button_release_cb), NULL);//.........这里部分代码省略.........

static gbooleanon_timeout (State *state){  int test_num = 0;  int y, x;  ClutterActor *over_actor = NULL;  /* This will cause an unclipped pick redraw that will get buffered.     We'll check below that this buffer is discarded because we also need     to pick non-reactive actors */  clutter_stage_get_actor_at_pos (CLUTTER_STAGE (state->stage),                                  CLUTTER_PICK_REACTIVE, 10, 10);  clutter_stage_get_actor_at_pos (CLUTTER_STAGE (state->stage),                                  CLUTTER_PICK_REACTIVE, 10, 10);  for (test_num = 0; test_num < 5; test_num++)    {      if (test_num == 0)        {          if (g_test_verbose ())            g_print ("No covering actor:/n");        }      if (test_num == 1)        {          static const ClutterColor red = { 0xff, 0x00, 0x00, 0xff };          /* Create an actor that covers the whole stage but that             isn't visible so it shouldn't affect the picking */          over_actor = clutter_rectangle_new_with_color (&red);          clutter_actor_set_size (over_actor, STAGE_WIDTH, STAGE_HEIGHT);          clutter_container_add (CLUTTER_CONTAINER (state->stage),                                 over_actor, NULL);          clutter_actor_hide (over_actor);          if (g_test_verbose ())            g_print ("Invisible covering actor:/n");        }      else if (test_num == 2)        {          /* Make the actor visible but set a clip so that only some             of the actors are accessible */          clutter_actor_show (over_actor);          clutter_actor_set_clip (over_actor,                                  state->actor_width * 2,                                  state->actor_height * 2,                                  state->actor_width * (ACTORS_X - 4),                                  state->actor_height * (ACTORS_Y - 4));          if (g_test_verbose ())            g_print ("Clipped covering actor:/n");        }      else if (test_num == 3)        {          clutter_actor_hide (over_actor);          clutter_actor_add_effect_with_name (CLUTTER_ACTOR (state->stage),                                              "blur",                                              clutter_blur_effect_new ());          if (g_test_verbose ())            g_print ("With blur effect:/n");        }      else if (test_num == 4)        {          clutter_actor_hide (over_actor);          clutter_actor_remove_effect_by_name (CLUTTER_ACTOR (state->stage),                                               "blur");          clutter_actor_add_effect_with_name (CLUTTER_ACTOR (state->stage),            "shift",            g_object_new (TYPE_SHIFT_EFFECT, NULL));          if (g_test_verbose ())            g_print ("With shift effect:/n");        }      for (y = 0; y < ACTORS_Y; y++)        {          if (test_num == 4)            x = 1;          else            x = 0;          for (; x < ACTORS_X; x++)            {              gboolean pass = FALSE;              gfloat pick_x;              ClutterActor *actor;              pick_x = x * state->actor_width + state->actor_width / 2;              if (test_num == 4)                pick_x -= SHIFT_STEP;              actor                = clutter_stage_get_actor_at_pos (CLUTTER_STAGE (state->stage),                                                  CLUTTER_PICK_ALL,                                                  pick_x,                                                  y * state->actor_height                                                  + state->actor_height / 2);//.........这里部分代码省略.........

int main(int argc,char *argv[]){  ClutterColor stage_color = { 0x00, 0x00, 0x00, 0xff };  clutter_init(&argc, &argv);  ClutterActor *stage = clutter_stage_get_default ();  clutter_actor_set_size (stage, 521, 577);  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);  //ClutterActor * _group = clutter_group_new();   _group = clutter_group_new();  clutter_actor_set_position(_group, 0,0);  clutter_container_add_actor(CLUTTER_CONTAINER(stage),_group);  clutter_actor_show(_group);  /** 加载棋盘图片*/  ClutterActor* _board = clutter_texture_new_from_file("./wood/wood.png",NULL);  clutter_actor_set_position(_board,0,0);  //clutter_actor_set_rotation(_board, CLUTTER_Y_AXIS, 20,0,0,0);  //clutter_actor_set_rotation(_board, CLUTTER_X_AXIS, 20,0,0,0);  //clutter_actor_set_rotation(_board, CLUTTER_Z_AXIS, 20,0,0,0);  //clutter_container_add_actor(CLUTTER_CONTAINER(stage),_board);  clutter_container_add_actor(CLUTTER_CONTAINER(_group),_board);  clutter_actor_show(_board);#if 0  load_chess();#else   /** 加载棋子*/  ClutterActor* _rking = clutter_texture_new_from_file("./wood/red_king.png",NULL);  clutter_actor_set_position(_rking,235,8);  clutter_container_add_actor(CLUTTER_CONTAINER(_group),_rking);  clutter_actor_show(_rking);  clutter_actor_set_reactive(_rking,TRUE);  g_signal_connect(_rking, "button-press-event",G_CALLBACK(on_rking_button_press),NULL);  timeline=clutter_timeline_new(3000);  //g_signal_connect(timeline,"new-frame",G_CALLBACK(on_timeline_new_frame),_rking);  clutter_timeline_set_loop(timeline,TRUE);  ClutterAlpha* alpha_ = clutter_alpha_new_full(timeline,         CLUTTER_EASE_IN_OUT_QUAD);//CLUTTER_EASE_IN_SINE);  ClutterBehaviour* behaviour_ = clutter_behaviour_rotate_new(alpha_, 		  CLUTTER_Y_AXIS,		CLUTTER_ROTATE_CW,		0,		360);  clutter_behaviour_rotate_set_center(CLUTTER_BEHAVIOUR_ROTATE(behaviour_), clutter_actor_get_width(_rking)/2,0,0);  clutter_behaviour_apply(behaviour_, _rking);  clutter_actor_set_rotation(_group, CLUTTER_X_AXIS, 40,2,600,0);  //clutter_actor_set_rotation(_group, CLUTTER_Y_AXIS, 40,221,200,0);#endif  clutter_actor_show(stage);  clutter_main();  g_object_unref(timeline);	printf("/n");	return 0;}

G_MODULE_EXPORT inttest_binding_pool_main (int argc, char *argv[]){  ClutterActor *stage, *key_group;  gint group_x, group_y;  if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)    return 1;  stage = clutter_stage_get_default ();  g_signal_connect (stage,                    "button-press-event", G_CALLBACK (clutter_main_quit),                    NULL);  key_group = g_object_new (TYPE_KEY_GROUP, NULL);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), key_group);  /* add three rectangles to the key group */  clutter_container_add (CLUTTER_CONTAINER (key_group),                         g_object_new (CLUTTER_TYPE_RECTANGLE,                                       "color", CLUTTER_COLOR_Red,                                       "width", 50.0,                                       "height", 50.0,                                       "x", 0.0,                                       "y", 0.0,                                       NULL),                         g_object_new (CLUTTER_TYPE_RECTANGLE,                                       "color", CLUTTER_COLOR_Green,                                       "width", 50.0,                                       "height", 50.0,                                       "x", 75.0,                                       "y", 0.0,                                       NULL),                         g_object_new (CLUTTER_TYPE_RECTANGLE,                                       "color", CLUTTER_COLOR_Blue,                                       "width", 50.0,                                       "height", 50.0,                                       "x", 150.0,                                       "y", 0.0,                                       NULL),                         NULL);  g_signal_connect (key_group,                    "activate", G_CALLBACK (on_key_group_activate),                    NULL);  group_x =    (clutter_actor_get_width (stage) - clutter_actor_get_width (key_group))    / 2;  group_y =    (clutter_actor_get_height (stage) - clutter_actor_get_height (key_group))    / 2;  clutter_actor_set_position (key_group, group_x, group_y);  clutter_actor_set_reactive (key_group, TRUE);  clutter_stage_set_key_focus (CLUTTER_STAGE (stage), key_group);  clutter_actor_show (stage);  clutter_main ();  return EXIT_SUCCESS;}

intmain (int argc, char *argv[]){	ClutterActor *stage, *box, *bg, *bg2, *inset, *labelContainer,	             *contentContainer, *labelbg, *fixed, *upper, *lower, *lowerInner;	ClutterLayoutManager *layout, *labelContainer_l, *layoutFixed;	ClutterTimeline *timeline;	ClutterContent *canvas, *canvas1;	ClutterColor color_with_trans = {0,0,0,0};	clutter_x11_set_use_argb_visual (TRUE);	if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)	    return (1);	/* prepare the stage */	stage = clutter_stage_new ();	clutter_stage_set_use_alpha (CLUTTER_STAGE (stage), TRUE);	clutter_stage_set_color (CLUTTER_STAGE (stage), &color_with_trans);	clutter_stage_set_title (CLUTTER_STAGE (stage), "IPLocation Database");	clutter_actor_set_background_color (stage, CLUTTER_COLOR_WHITE);	clutter_actor_set_size (stage, 648, 246);	clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);	clutter_actor_show (stage);	g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);	layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,			CLUTTER_BIN_ALIGNMENT_CENTER);	box = clutter_actor_new ();	clutter_actor_add_constraint (box, clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0.0));	clutter_actor_set_background_color (box, CLUTTER_COLOR_WHITE);	clutter_actor_set_layout_manager (box, layout);	clutter_actor_add_constraint (box, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 1));	clutter_actor_set_name (box, "box");	clutter_actor_add_child (stage, box);	bg = clutter_actor_new ();	//clutter_actor_set_background_color (bg, clutter_color_new (50, 50, 50, 255));	clutter_actor_set_name (bg, "background");	clutter_actor_set_reactive (bg, TRUE);	//clutter_actor_set_x_expand (bg, TRUE);	//clutter_actor_set_y_expand (bg, TRUE);	clutter_actor_set_x_align (bg, CLUTTER_ACTOR_ALIGN_END);	clutter_actor_set_y_align (bg, CLUTTER_ACTOR_ALIGN_FILL);	canvas1 = clutter_canvas_new ();	clutter_canvas_set_size (CLUTTER_CANVAS (canvas1), 300, 300);	clutter_actor_set_content (bg, canvas1);	/*clutter_actor_set_content_scaling_filters (bg2,		 CLUTTER_SCALING_FILTER_TRILINEAR,		 CLUTTER_SCALING_FILTER_LINEAR);*/	g_object_unref (canvas1);	clutter_actor_add_child (box, bg);	bg2 = clutter_actor_new ();	//clutter_actor_set_background_color (bg2, clutter_color_new (0, 100, 100, 255*.5));	clutter_actor_set_name (bg2, "background");	clutter_actor_set_reactive (bg2, TRUE);	clutter_actor_set_size (bg2, 0, 0);	//clutter_actor_set_x_expand (bg2, TRUE);	//clutter_actor_set_y_expand (bg2, TRUE);	clutter_actor_set_x_align (bg2, CLUTTER_ACTOR_ALIGN_END);	clutter_actor_set_y_align (bg2, CLUTTER_ACTOR_ALIGN_FILL);	clutter_actor_set_clip_to_allocation(bg2, TRUE);	clutter_actor_add_child (box, bg2);	clutter_actor_set_layout_manager (bg2, clutter_box_layout_new ());	canvas = clutter_canvas_new ();	clutter_canvas_set_size (CLUTTER_CANVAS (canvas), 300, 300);	clutter_actor_set_content (bg2, canvas);	/*clutter_actor_set_content_scaling_filters (bg2,		 CLUTTER_SCALING_FILTER_TRILINEAR,		 CLUTTER_SCALING_FILTER_LINEAR);*/	g_object_unref (canvas);	inset = clutter_actor_new ();	//clutter_actor_set_background_color (inset, clutter_color_new (255, 0, 0, 255));	clutter_actor_set_name (inset, "inset");	clutter_actor_set_reactive (inset, TRUE);	clutter_actor_set_margin_top (inset, 18);	clutter_actor_set_margin_right (inset, 18);	clutter_actor_set_margin_bottom (inset, 18);	clutter_actor_set_margin_left (inset, 48);	//clutter_actor_set_x_expand (inset, TRUE);	//clutter_actor_set_y_expand (inset, TRUE);	clutter_actor_set_x_align (inset, CLUTTER_ACTOR_ALIGN_FILL);	clutter_actor_set_y_align (inset, CLUTTER_ACTOR_ALIGN_FILL);	clutter_actor_set_clip_to_allocation(inset, TRUE);	clutter_actor_add_child (bg2, inset);	layout = clutter_box_layout_new ();	clutter_box_layout_set_vertical (CLUTTER_BOX_LAYOUT (layout),	                                    TRUE);	clutter_box_layout_set_spacing (CLUTTER_BOX_LAYOUT (layout), 5);	clutter_actor_set_layout_manager (inset, layout);//.........这里部分代码省略.........

static voidmake_ui (ClutterActor *stage){  ClutterActor *button      = NULL;  clutter_stage_set_title (CLUTTER_STAGE (stage), "Cally - AtkEditable Test");  clutter_stage_set_color (CLUTTER_STAGE (stage), CLUTTER_COLOR_White);  clutter_actor_set_size (stage, WIDTH, HEIGHT);  /* text */  text_actor = clutter_text_new_full ("Sans Bold 32px",                                      "Lorem ipsum dolor sit amet",                                      CLUTTER_COLOR_Red);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), text_actor);  /* text_editable */  text_editable_actor = clutter_text_new_full ("Sans Bold 32px",                                               "consectetur adipisicing elit",                                               CLUTTER_COLOR_Red);  clutter_actor_set_position (text_editable_actor, 0, 100);  clutter_text_set_editable (CLUTTER_TEXT (text_editable_actor), TRUE);  clutter_text_set_selectable (CLUTTER_TEXT (text_editable_actor), TRUE);  clutter_text_set_selection_color (CLUTTER_TEXT (text_editable_actor),                                    CLUTTER_COLOR_Green);  clutter_text_set_activatable (CLUTTER_TEXT (text_editable_actor),                                TRUE);  clutter_text_set_line_wrap (CLUTTER_TEXT (text_editable_actor), TRUE);  clutter_actor_grab_key_focus (text_editable_actor);  clutter_actor_set_reactive (text_editable_actor, TRUE);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), text_editable_actor);  g_signal_connect (text_editable_actor, "activate",                    G_CALLBACK (activate_cb), NULL);  /* test buttons */  button = _create_button ("Set");  clutter_actor_set_position (button, 100, 200);  g_signal_connect_after (button, "button-press-event",                          G_CALLBACK (set_text_press_cb), NULL);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), button);  button = _create_button ("Delete");  clutter_actor_set_position (button, 100, 250);  g_signal_connect_after (button, "button-press-event",                          G_CALLBACK (delete_text_press_cb), NULL);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), button);  button = _create_button ("Insert");  clutter_actor_set_position (button, 100, 300);  g_signal_connect_after (button, "button-press-event",                          G_CALLBACK (insert_text_press_cb), NULL);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), button);  button = _create_button ("Activate/Deactivate");  clutter_actor_set_position (button, 100, 350);  g_signal_connect_after (button, "button-press-event",                          G_CALLBACK (activate_deactivate_press_cb), NULL);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), button);  button = _create_button ("Cursor position");  clutter_actor_set_position (button, 100, 450);  g_signal_connect_after (button, "button-press-event",                          G_CALLBACK (print_cursor_position_press_cb), NULL);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), button);}

static gbooleanon_timeout (State *state){  int test_num = 0;  int y, x;  ClutterActor *over_actor = NULL;  for (test_num = 0; test_num < 3; test_num++)    {      if (test_num == 0)        {          if (g_test_verbose ())            g_print ("No covering actor:/n");        }      if (test_num == 1)        {          static const ClutterColor red = { 0xff, 0x00, 0x00, 0xff };          /* Create an actor that covers the whole stage but that             isn't visible so it shouldn't affect the picking */          over_actor = clutter_rectangle_new_with_color (&red);          clutter_actor_set_size (over_actor, STAGE_WIDTH, STAGE_HEIGHT);          clutter_container_add (CLUTTER_CONTAINER (state->stage),                                 over_actor, NULL);          clutter_actor_hide (over_actor);          if (g_test_verbose ())            g_print ("Invisible covering actor:/n");        }      else if (test_num == 2)        {          /* Make the actor visible but set a clip so that only some             of the actors are accessible */          clutter_actor_show (over_actor);          clutter_actor_set_clip (over_actor,                                  state->actor_width * 2,                                  state->actor_height * 2,                                  state->actor_width * (ACTORS_X - 4),                                  state->actor_height * (ACTORS_Y - 4));          if (g_test_verbose ())            g_print ("Clipped covering actor:/n");        }      for (y = 0; y < ACTORS_Y; y++)        for (x = 0; x < ACTORS_X; x++)          {            gboolean pass = FALSE;            guint32 gid;            ClutterActor *actor              = clutter_stage_get_actor_at_pos (CLUTTER_STAGE (state->stage),                                                CLUTTER_PICK_ALL,                                                x * state->actor_width                                                + state->actor_width / 2,                                                y * state->actor_height                                                + state->actor_height / 2);            if (g_test_verbose ())              g_print ("% 3i,% 3i / % 4i -> ",                       x, y, (int) state->gids[y * ACTORS_X + x]);            if (actor == NULL)              {                if (g_test_verbose ())                  g_print ("NULL:       FAIL/n");              }            else if (actor == over_actor)              {                if (test_num == 2                    && x >= 2 && x < ACTORS_X - 2                    && y >= 2 && y < ACTORS_Y - 2)                  pass = TRUE;                if (g_test_verbose ())                  g_print ("over_actor: %s/n", pass ? "pass" : "FAIL");              }            else              {                gid = clutter_actor_get_gid (actor);                if (gid == state->gids[y * ACTORS_X + x]                    && (test_num != 2                        || x < 2 || x >= ACTORS_X - 2                        || y < 2 || y >= ACTORS_Y - 2))                  pass = TRUE;                if (g_test_verbose ())                  g_print ("% 10i: %s/n", gid, pass ? "pass" : "FAIL");              }            if (!pass)              state->pass = FALSE;          }    }  clutter_main_quit ();  return FALSE;}

intmain (int argc, char **argv){    AainaLibrary *library;    AainaSource *source;    ClutterActor *stage;    ClutterAlpha *alpha;    ClutterBehaviour *behave;    ClutterColor black = { 0x00, 0x00, 0x00, 0xff };    GError *error = NULL;    g_thread_init (NULL);    g_set_application_name ("Aaina Image Slideshow");    clutter_init_with_args (&argc, &argv,                            " - Aaina Image Slideshow", entries,                            NULL,                            &error);    if (error)    {        g_print ("Unable to run Aaina: %s", error->message);        g_error_free (error);        return EXIT_FAILURE;    }    stage = clutter_stage_get_default ();    clutter_actor_set_size (stage, 720, 480);    clutter_stage_hide_cursor (CLUTTER_STAGE (stage));    if (fullscreen)        clutter_stage_fullscreen (CLUTTER_STAGE (stage));    clutter_stage_set_color (CLUTTER_STAGE (stage), &black);    /* Load the test source */    library = aaina_library_new ();    if (directories && directories[0])    {        gint n_directories, i;        n_directories = g_strv_length (directories);        for (i = 0; i < n_directories; i++)            source = aaina_source_directory_new (library, directories[i]);    }    else if (flickr_tags)        source = aaina_source_flickr_new (library, flickr_tags);    else    {        g_print ("Usage: aaina -d <path>/n"                 "       aaina -t <tag>[,<tag>,....]/n");        return EXIT_FAILURE;    }    show = aaina_slide_show_get_default ();    clutter_group_add (CLUTTER_GROUP (stage), CLUTTER_ACTOR (show));    clutter_actor_set_position (CLUTTER_ACTOR (show), 0, 0);    clutter_actor_set_size (CLUTTER_ACTOR (show),                            CLUTTER_STAGE_WIDTH (),                            CLUTTER_STAGE_HEIGHT ()) ;    clutter_actor_show_all (CLUTTER_ACTOR (show));    g_object_set (G_OBJECT (show), "library", library, NULL);    clutter_actor_show_all (stage);    /*clutter_actor_set_scale (stage, 0.25, 0.25);*/    g_signal_connect (G_OBJECT (stage), "key-release-event",                      G_CALLBACK (on_key_release_event), (gpointer)stage);    timeline = clutter_timeline_new (60, 30);    alpha = clutter_alpha_new_full (timeline,                                    alpha_sine_inc_func,                                    NULL, NULL);    behave = aaina_behave_new (alpha,                               (AainaBehaveAlphaFunc)spin_me,                               (gpointer)stage);    clutter_actor_set_rotation (stage, CLUTTER_Y_AXIS, 0,                                CLUTTER_STAGE_WIDTH ()/2,                                0,                                CLUTTER_STAGE_HEIGHT ());    g_timeout_add (120000, (GSourceFunc)im_spinning_around, timeline);    clutter_main ();    return EXIT_SUCCESS;}

static voidon_new_kinect_device (GObject      *obj,                      GAsyncResult *res,                      gpointer      user_data){  ClutterActor *stage, *instructions;  GError *error = NULL;  gint width = 640;  gint height = 480;  kinect = gfreenect_device_new_finish (res, &error);  if (kinect == NULL)    {      g_debug ("Failed to created kinect device: %s", error->message);      g_error_free (error);      clutter_main_quit ();      return;    }  g_debug ("Kinect device created!");  stage = clutter_stage_get_default ();  clutter_stage_set_title (CLUTTER_STAGE (stage), "Kinect Test");  clutter_actor_set_size (stage, width * 2, height + 200);  clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);  g_signal_connect (stage, "destroy", G_CALLBACK (on_destroy), kinect);  g_signal_connect (stage,                    "key-release-event",                    G_CALLBACK (on_key_release),                    kinect);  depth_tex = clutter_cairo_texture_new (width, height);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), depth_tex);  video_tex = clutter_cairo_texture_new (width, height);  clutter_actor_set_position (video_tex, width, 0.0);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), video_tex);  info_text = clutter_text_new ();  set_info_text ();  clutter_actor_set_position (info_text, 50, height + 20);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), info_text);  instructions = create_instructions ();  clutter_actor_set_position (instructions, 50, height + 70);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), instructions);  clutter_actor_show_all (stage);  skeleton = SKELTRACK_SKELETON (skeltrack_skeleton_new ());  g_signal_connect (kinect,                    "depth-frame",                    G_CALLBACK (on_depth_frame),                    NULL);  g_signal_connect (kinect,                    "video-frame",                    G_CALLBACK (on_video_frame),                    NULL);  g_signal_connect (depth_tex,                    "draw",                    G_CALLBACK (on_texture_draw),                    NULL);  gfreenect_device_set_tilt_angle (kinect, 0, NULL, NULL, NULL);  gfreenect_device_start_depth_stream (kinect,                                       GFREENECT_DEPTH_FORMAT_MM,                                       NULL);  gfreenect_device_start_video_stream (kinect,                                       GFREENECT_RESOLUTION_MEDIUM,                                       GFREENECT_VIDEO_FORMAT_RGB, NULL);}

G_MODULE_EXPORT inttest_scale_main (int argc, char *argv[]){  ClutterActor    *stage, *rect;  ClutterColor     rect_color = { 0xff, 0xff, 0xff, 0x99 };  ClutterTimeline *timeline;  ClutterAlpha    *alpha;  ClutterBehaviour *behave;  if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)    return 1;  stage = clutter_stage_new ();  clutter_stage_set_title (CLUTTER_STAGE (stage), "Scaling");  clutter_actor_set_background_color (stage, CLUTTER_COLOR_Black);  clutter_actor_set_size (stage, 300, 300);  g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);  rect = clutter_rectangle_new_with_color (&rect_color);  clutter_actor_set_size (rect, 100, 100);  clutter_actor_set_position (rect, 100, 100);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), rect);  label = clutter_text_new_with_text ("Sans 20px", "");  clutter_text_set_color (CLUTTER_TEXT (label), CLUTTER_COLOR_White);  clutter_actor_set_position (label,                              clutter_actor_get_x (rect),                              clutter_actor_get_y (rect)                              + clutter_actor_get_height (rect));  clutter_container_add_actor (CLUTTER_CONTAINER (stage), label);  rect_color.alpha = 0xff;  rect = clutter_rectangle_new_with_color (&rect_color);  clutter_actor_set_position (rect, 100, 100);  clutter_actor_set_size (rect, 100, 100);  set_next_gravity (rect);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), rect);  timeline = clutter_timeline_new (750);  alpha    = clutter_alpha_new_with_func (timeline,				          my_ramp_func,				          NULL, NULL);  behave = clutter_behaviour_scale_new (alpha,					0.0, 0.0,  /* scale start */					1.0, 1.0); /* scale end */  clutter_behaviour_apply (behave, rect);  clutter_timeline_set_repeat_count (timeline, -1);  g_signal_connect_swapped (timeline, "completed",                            G_CALLBACK (set_next_gravity), rect);  clutter_timeline_start (timeline);  clutter_actor_show_all (stage);  clutter_main();  g_object_unref (timeline);  g_object_unref (behave);  return EXIT_SUCCESS;}

static gbooleanactor_manipulator_press (ClutterActor *stage,                         ClutterEvent *event,                         gpointer      data){  ClutterActor *actor;  actor = clutter_stage_get_actor_at_pos (CLUTTER_STAGE (stage),                                          CLUTTER_PICK_ALL,                                          event->button.x,                                          event->button.y);  if (actor == stage ||      CLUTTER_IS_GROUP (actor))    {      if (event->button.button == 3)        {          popup_nuke (stage, event->button.x, event->button.y);          popup_add ("+rectangle", "bar", G_CALLBACK (                       action_add_rectangle), scene_get_group ());          popup_add ("+circle", "bar", G_CALLBACK (                       action_add_circle), scene_get_group ());          popup_add ("+triangle", "bar", G_CALLBACK (                       action_add_triangle), scene_get_group ());          popup_add ("+text", "bar", G_CALLBACK (                       action_add_text), scene_get_group ());          popup_add ("+image", "bar", G_CALLBACK (                       action_add_image), scene_get_group ());#if 0          popup_add ("+block-tree", "bar", G_CALLBACK (                       action_add_block_tree), scene_get_group ());#endif          popup_add ("zero gravity", "bar", G_CALLBACK (                       action_zero_gravity), scene_get_group ());        }      return TRUE;    }  if (actor == NULL)    {      return FALSE;    }  if (event->button.button == 3)    {      popup_nuke (stage, event->button.x, event->button.y);      popup_add ("remove", "bar", G_CALLBACK (action_remove), actor);      popup_add ("set linear velocity", "bar", G_CALLBACK (action_set_linear_velocity), actor);      popup_add ("set dynamic", "bar", G_CALLBACK (action_set_dynamic), actor);      popup_add ("set static", "bar", G_CALLBACK (action_set_static), actor);      popup_add_slider ("opacity", "hm", 0.0, 255.0,                        clutter_actor_get_opacity (actor) * 1.0,                        G_CALLBACK (set_opacity), actor);      popup_add_slider ("rotation", "hm", 0.0, 360.0,                        clutter_actor_get_rotation (actor, CLUTTER_Z_AXIS, NULL,                                                    NULL, NULL),                        G_CALLBACK (set_rotation), actor);      popup_add ("ok", "bar", NULL, NULL);      return TRUE;    }  if (!should_be_manipulated (actor))    return FALSE;  manipulated_actor = actor;  clutter_actor_get_position (actor, &orig_x, &orig_y);  orig_rotation = clutter_actor_get_rotation (actor, CLUTTER_Z_AXIS, NULL,                                               NULL,                                               NULL);  start_x =  (event->button.x);  start_y =  (event->button.y);  clutter_actor_transform_stage_point (    clutter_actor_get_parent (manipulated_actor),    start_x, start_y,    &start_x, &start_y);  mode = Direct;#ifdef BOX2D_MANIPULATION  /* Use Box2D manipulation if the actor is dynamic, and the physics   * engine is running   */  if (CLUTTER_IS_BOX2D (scene_get_group ()) &&      clutter_box2d_get_simulating (CLUTTER_BOX2D (scene_get_group ())))    {      ClutterBox2D *box2d  = CLUTTER_BOX2D (scene_get_group ());      /*ClutterVertex target = { start_x, start_y };*/      gint type;            clutter_container_child_get (CLUTTER_CONTAINER (box2d),                                   manipulated_actor, "mode", &type, NULL);      	  //.........这里部分代码省略.........

intmain (int argc, char *argv[]){  gchar *txt;  ClutterActor *rect, *stage, *label0;  int i, rotate_x = 0, rotate_y = 60, rotate_z = 0;  ClutterColor stage_clr = { 0x0, 0x0, 0x0, 0xff },               white     = { 0xff, 0xff, 0xff, 0xff },               blue      = { 0, 0xff, 0xff, 0xff };  for (i = 0; i < argc; ++i)    {      if (!strncmp (argv[i], "--rotate-x", 10))	{	  rotate_x = atoi (argv[i] + 11);	}      else if (!strncmp (argv[i], "--rotate-y", 10))	{	  rotate_y = atoi (argv[i] + 11);	}      else if (!strncmp (argv[i], "--rotate-z", 10))	{	  rotate_z = atoi (argv[i] + 11);	}      else if (!strncmp (argv[i], "--help", 6))	{	  printf ("%s [--rotage-x=degrees] [--rotage-y=degrees] "		  "[--rotage-z=degrees]/n",		  argv[0]);	  exit (0);	}    }  clutter_init (&argc, &argv);  stage = clutter_stage_get_default ();  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_clr);  clutter_actor_set_size (stage, 640, 480);  rect = clutter_rectangle_new_with_color (&white);  clutter_actor_set_size (rect, RECT_W, RECT_H);  clutter_actor_set_position (rect, RECT_L, RECT_T);  clutter_actor_set_rotation (rect, CLUTTER_X_AXIS, rotate_x, 0, 0, 0);  clutter_actor_set_rotation (rect, CLUTTER_Y_AXIS, rotate_y, 0, 0, 0);  clutter_actor_set_rotation (rect, CLUTTER_Z_AXIS, rotate_z, 0, 0, 0);  clutter_group_add (CLUTTER_GROUP (stage), rect);  txt = g_strdup_printf ("Rectangle: L %d, R %d, T %d, B %d/n"			 "Rotation : x %d, y %d, z %d",			 RECT_L, RECT_L + RECT_W,			 RECT_T, RECT_T + RECT_H,			 rotate_x, rotate_y, rotate_z);  label0 = clutter_label_new_with_text ("Mono 8pt", txt);  clutter_label_set_color (CLUTTER_LABEL (label0), &white);  clutter_actor_set_position (label0, 10, 10);  clutter_group_add (CLUTTER_GROUP (stage), label0);  g_free (txt);  label =    clutter_label_new_with_text ("Mono 8pt", "Click around!");  clutter_label_set_color (CLUTTER_LABEL (label), &blue);  clutter_actor_set_position (label, 10, 50);  clutter_group_add (CLUTTER_GROUP (stage), label);  clutter_actor_show_all (stage);  g_signal_connect (stage, "event", G_CALLBACK (on_event), NULL);  clutter_main();  return EXIT_SUCCESS;}

intmain (int argc, char *argv[]){  ClutterActor *video;  /* So we can fade out at the end. */  clutter_x11_set_use_argb_visual (TRUE);  if (clutter_gst_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)    return EXIT_FAILURE;  if (argc < 2)    {      g_print ("Usage: %s [OPTIONS] <video file>/n", argv[0]);      return EXIT_FAILURE;    }  if (!clutter_color_from_string (&bg_color, BG_COLOR))    {      g_warning ("Invalid BG_COLOR");      exit (1);    }  stage = clutter_stage_new ();  /* Clutter's full-screening code does not allow us to   * set both that and _NET_WM_STATE_ABOVE, so do the state   * management ourselves for now. */#if 0  clutter_stage_set_fullscreen (CLUTTER_STAGE (stage), TRUE);#endif  /* Clutter will set maximum size restrictions (meaning not   * full screen) unless I set this. */  clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);  clutter_stage_set_use_alpha (CLUTTER_STAGE (stage), TRUE);  clutter_actor_set_background_color (stage, &bg_color);  clutter_actor_set_layout_manager (stage,                                    clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_FIXED,                                                            CLUTTER_BIN_ALIGNMENT_FIXED));  clutter_actor_realize (stage);  set_above_and_fullscreen ();  video = clutter_gst_video_texture_new ();  clutter_actor_set_x_expand (video, TRUE);  clutter_actor_set_y_expand (video, TRUE);  clutter_actor_set_x_align (video, CLUTTER_ACTOR_ALIGN_CENTER);  clutter_actor_set_y_align (video, CLUTTER_ACTOR_ALIGN_CENTER);  set_idle_material (CLUTTER_GST_VIDEO_TEXTURE (video));  g_signal_connect (video,                    "eos",                    G_CALLBACK (on_video_texture_eos),                    NULL);  g_signal_connect (stage,                    "destroy",                    G_CALLBACK (clutter_main_quit),                    NULL);  clutter_media_set_filename (CLUTTER_MEDIA (video), argv[1]);  clutter_stage_hide_cursor (CLUTTER_STAGE (stage));  clutter_actor_add_child (stage, video);  g_signal_connect (stage, "key-press-event", G_CALLBACK (key_press_cb), NULL);  clutter_media_set_playing (CLUTTER_MEDIA (video), TRUE);  clutter_actor_show (stage);  clutter_main ();  return EXIT_SUCCESS;}

G_MODULE_EXPORT inttest_bin_layout_main (int argc, char *argv[]){  ClutterActor *stage, *box, *rect;  ClutterLayoutManager *layout;  ClutterColor stage_color = { 0xe0, 0xf2, 0xfc, 0xff };  ClutterColor bg_color = { 0xcc, 0xcc, 0xcc, 0x99 };  ClutterColor *color;  clutter_init (&argc, &argv);  stage = clutter_stage_get_default ();  clutter_stage_set_title (CLUTTER_STAGE (stage), "Box test");  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);  clutter_actor_set_size (stage, 640, 480);  layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,                                   CLUTTER_BIN_ALIGNMENT_CENTER);  box = clutter_box_new (layout);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), box);  clutter_actor_set_anchor_point_from_gravity (box, CLUTTER_GRAVITY_CENTER);  clutter_actor_set_position (box, 320, 240);  clutter_actor_set_reactive (box, TRUE);  clutter_actor_set_name (box, "box");  rect = make_background (&bg_color, 200, 200);  /* first method: use clutter_box_pack() */  clutter_box_pack (CLUTTER_BOX (box), rect,                    "x-align", CLUTTER_BIN_ALIGNMENT_FILL,                    "y-align", CLUTTER_BIN_ALIGNMENT_FILL,                    NULL);  clutter_actor_lower_bottom (rect);  clutter_actor_set_name (rect, "background");  {    ClutterActor *tex;    GError *error;    gchar *file;    error = NULL;    file = g_build_filename (TESTS_DATADIR, "redhand.png", NULL);    tex = clutter_texture_new_from_file (file, &error);    if (error)      g_error ("Unable to create texture: %s", error->message);    clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (tex), TRUE);    /* second method: use clutter_bin_layout_add() */    clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (layout), tex,                            CLUTTER_BIN_ALIGNMENT_CENTER,                            CLUTTER_BIN_ALIGNMENT_CENTER);    clutter_actor_raise (tex, rect);    clutter_actor_set_width (tex, 175);    clutter_actor_set_name (tex, "texture");    g_free (file);  }  color = clutter_color_new (g_random_int_range (0, 255),                             g_random_int_range (0, 255),                             g_random_int_range (0, 255),                             224);  rect = clutter_rectangle_new_with_color (color);  /* third method: container_add() and set_alignment() */  clutter_container_add_actor (CLUTTER_CONTAINER (box), rect);  clutter_bin_layout_set_alignment (CLUTTER_BIN_LAYOUT (layout), rect,                                    CLUTTER_BIN_ALIGNMENT_END,                                    CLUTTER_BIN_ALIGNMENT_END);  clutter_actor_set_size (rect, 50, 50);  clutter_actor_set_opacity (rect, 0);  clutter_actor_raise_top (rect);  clutter_actor_set_name (rect, "emblem");  g_signal_connect (box,                    "enter-event", G_CALLBACK (on_box_enter),                    rect);  g_signal_connect (box,                    "leave-event", G_CALLBACK (on_box_leave),                    rect);  clutter_actor_show_all (stage);  clutter_main ();  clutter_color_free (color);  return EXIT_SUCCESS;}

G_MODULE_EXPORT inttest_snap_constraint_main (int   argc,                           char *argv[]){  ClutterActor *stage, *layer_a, *layer_b, *layer_c;  if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)    return 1;  /* the main container */  stage = clutter_stage_new ();  clutter_actor_set_name (stage, "stage");  clutter_stage_set_title (CLUTTER_STAGE (stage), "Snap Constraint");  clutter_stage_set_color (CLUTTER_STAGE (stage), CLUTTER_COLOR_Aluminium1);  clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);  g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);  /* first layer, with a fixed (100, 25) size */  layer_a = clutter_rectangle_new_with_color (CLUTTER_COLOR_ScarletRed);  clutter_actor_set_name (layer_a, "layerA");  clutter_container_add_actor (CLUTTER_CONTAINER (stage), layer_a);  clutter_actor_set_size (layer_a, 100.0, 25.0);  /* the first layer is anchored to the middle of the stage */  clutter_actor_add_constraint (layer_a, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0.5));  clutter_actor_add_constraint (layer_a, clutter_align_constraint_new (stage, CLUTTER_ALIGN_Y_AXIS, 0.5));  /* second layer, with no implicit size */  layer_b = clutter_rectangle_new_with_color (CLUTTER_COLOR_DarkButter);  clutter_actor_set_name (layer_b, "layerB");  clutter_container_add_actor (CLUTTER_CONTAINER (stage), layer_b);  /* the second layer tracks the X coordinate and the width of   * the first layer   */  clutter_actor_add_constraint (layer_b, clutter_bind_constraint_new (layer_a, CLUTTER_BIND_X, 0.0));  clutter_actor_add_constraint (layer_b, clutter_bind_constraint_new (layer_a, CLUTTER_BIND_WIDTH, 0.0));  /* the second layer is snapped between the bottom edge of   * the first layer, and the bottom edge of the stage; a   * spacing of 10 pixels in each direction is added for padding   */  clutter_actor_add_constraint (layer_b,                                clutter_snap_constraint_new (layer_a,                                                             CLUTTER_SNAP_EDGE_TOP,                                                             CLUTTER_SNAP_EDGE_BOTTOM,                                                             10.0));  clutter_actor_add_constraint (layer_b,                                clutter_snap_constraint_new (stage,                                                             CLUTTER_SNAP_EDGE_BOTTOM,                                                             CLUTTER_SNAP_EDGE_BOTTOM,                                                             -10.0));  /* the third layer, with no implicit size */  layer_c = clutter_rectangle_new_with_color (CLUTTER_COLOR_LightChameleon);  clutter_actor_set_name (layer_c, "layerC");  clutter_container_add_actor (CLUTTER_CONTAINER (stage), layer_c);  /* as for the second layer, the third layer tracks the X   * coordinate and width of the first layer   */  clutter_actor_add_constraint (layer_c, clutter_bind_constraint_new (layer_a, CLUTTER_BIND_X, 0.0));  clutter_actor_add_constraint (layer_c, clutter_bind_constraint_new (layer_a, CLUTTER_BIND_WIDTH, 0.0));  /* the third layer is snapped between the top edge of the stage   * and the top edge of the first layer; again, a spacing of   * 10 pixels in each direction is added for padding   */  clutter_actor_add_constraint (layer_c,                                clutter_snap_constraint_new (layer_a,                                                             CLUTTER_SNAP_EDGE_BOTTOM,                                                             CLUTTER_SNAP_EDGE_TOP,                                                             -10.0));  clutter_actor_add_constraint (layer_c,                                clutter_snap_constraint_new (stage,                                                             CLUTTER_SNAP_EDGE_TOP,                                                             CLUTTER_SNAP_EDGE_TOP,                                                             10.0));  clutter_actor_show (stage);  clutter_main ();  return EXIT_SUCCESS;}

intmain (int   argc,      char *argv[]){  ClutterActor *stage;  ClutterActor *texture;  ClutterEffect *effect;  ClutterState *transitions;  GError *error = NULL;  gchar *filename;  if (argc < 2)    {      g_print ("Usage: %s <path to image file>/n", argv[0]);      return EXIT_FAILURE;    }  filename = argv[1];  if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)    return 1;  stage = clutter_stage_new ();  clutter_actor_set_size (stage, 400, 300);  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);  g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);  texture = clutter_texture_new ();  clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (texture), TRUE);  clutter_actor_set_width (texture, 400);  clutter_actor_set_reactive (texture, TRUE);  clutter_texture_set_from_file (CLUTTER_TEXTURE (texture),                                 filename,                                 &error);  if (error != NULL)    {      g_critical ("Error loading texture from file %s; error was:/n%s",                  filename,                  error->message);      return EXIT_FAILURE;    }  /* create the page fold effect instance with destination fold angle   * of 180 degrees and starting period of 0 (no folding)   */  effect = cb_page_fold_effect_new (180.0, 0.0);  /* add the effect to the texture actor */  clutter_actor_add_effect (texture, effect);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), texture);  /* animation for the period property of the effect,   * to animate its value between 0.0 and 1.0 and back   */  transitions = clutter_state_new ();  clutter_state_set_duration (transitions, NULL, NULL, 500);  clutter_state_set_duration (transitions,                              "partially-folded",                              "folded",                              375);  clutter_state_set (transitions, NULL, "folded",                     effect, "period", CLUTTER_LINEAR, 1.0,                     NULL);  clutter_state_set (transitions, NULL, "partially-folded",                     effect, "period", CLUTTER_LINEAR, 0.25,                     NULL);  clutter_state_set (transitions, NULL, "unfolded",                     effect, "period", CLUTTER_LINEAR, 0.0,                     NULL);  clutter_state_warp_to_state (transitions, "partially-folded");  g_signal_connect (texture,                    "button-press-event",                    G_CALLBACK (button_pressed_cb),                    transitions);  clutter_actor_show (stage);  clutter_main ();  g_object_unref (transitions);  return EXIT_SUCCESS;}

intmain (int argc, char *argv[]){  ClutterActor    *stage;  ClutterColor     stage_color = { 0x34, 0x39, 0x39, 0xff };  ClutterColor     white = { 0x72, 0x9f, 0xcf, 0xff };  gint             i = 0;  Item            *item;  App             *app;  gdouble          ang = 0.0;  ClutterBehaviour *behave;  clutter_init (&argc, &argv);  stage = clutter_stage_get_default ();  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);  clutter_actor_set_size (stage, 800, 600);  app = g_new0(App, 1);  app->off = 0.0;  app->timeline = clutter_timeline_new (300);  app->alpha_sine_inc    = clutter_alpha_new_full (app->timeline, CLUTTER_EASE_OUT_SINE);  app->alpha_ramp    = clutter_alpha_new_with_func (app->timeline, label_opacity_alpha_func,                                   NULL, NULL);  for (i=0; i<N_ITEMS; i++)    {      item = g_new0 (Item, 1);      item->actor = clutter_texture_new_from_file (ItemDetails[i].img, NULL);      if (!item->actor)	g_error ("Unable to load '%s'", ItemDetails[i].img);      clutter_group_add (CLUTTER_GROUP(stage), item->actor);      item->ellipse_behave	= clutter_behaviour_ellipse_new (app->alpha_sine_inc,					 CSW()/4,   /* center x */					 CSH() - (CSH()/3),   /* center y */					 CSW()/2,   /* width */					 CSH() - (CSH()/4),   /* height */					 CLUTTER_ROTATE_CW,					 ang,					 ang + STEP);      item->opacity_behave	= clutter_behaviour_opacity_new (app->alpha_sine_inc, 0x66, 0x66);      item->scale_behave	= clutter_behaviour_scale_new (app->alpha_sine_inc,				       0.6, 0.6, 0.6, 0.6);      clutter_behaviour_apply (item->ellipse_behave, item->actor);      clutter_behaviour_apply (item->opacity_behave, item->actor);      clutter_behaviour_apply (item->scale_behave, item->actor);      app->items = g_slist_append (app->items, item);      ang += STEP;    }  app->label = clutter_text_new_full ("Bitstream Vera Sans 60px", "", &white);  clutter_actor_set_position (app->label, CSW()/2 - 30, CSH()/3 - 40);  clutter_group_add (CLUTTER_GROUP(stage), app->label);  behave = clutter_behaviour_opacity_new (app->alpha_ramp, 0xff, 0);  clutter_behaviour_apply (behave, app->label);  g_signal_connect (app->timeline,		    "new-frame",		    G_CALLBACK(on_timeline_new_frame),		    app);  g_signal_connect (stage,		    "event",		    G_CALLBACK (on_input),		    app);  introduce_items (app);  clutter_actor_show_all (stage);  clutter_main();  return 0;}

intmain (int argc, char *argv[]){  GError *error = NULL;  /* UI */  ClutterActor *stage;  ClutterLayoutManager *layout;  ClutterActor *box;  ClutterActor *top, *bottom;  ClutterState *transitions;  clutter_init_with_args (&argc, &argv,                          " - cross-fade", entries,                          NULL,                          NULL);  if (source == NULL || target == NULL)    {      g_print ("Usage: %s -s <source> -t <target> [-d <duration>]/n", argv[0]);      exit (EXIT_FAILURE);    }  clutter_init (&argc, &argv);  stage = clutter_stage_get_default ();  clutter_stage_set_title (CLUTTER_STAGE (stage), "cross-fade");  clutter_actor_set_size (stage, 400, 300);  clutter_actor_show (stage);  g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);  layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,                                   CLUTTER_BIN_ALIGNMENT_CENTER);  box = clutter_box_new (layout);  clutter_actor_set_size (box, 400, 300);  bottom = clutter_texture_new ();  top = clutter_texture_new ();  clutter_container_add_actor (CLUTTER_CONTAINER (box), bottom);  clutter_container_add_actor (CLUTTER_CONTAINER (box), top);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), box);  /* load the first image into the bottom */  load_image (CLUTTER_TEXTURE (bottom), source);  /* load the second image into the top */  load_image (CLUTTER_TEXTURE (top), target);  /* animations */  transitions = clutter_state_new ();  clutter_state_set (transitions, NULL, "show-bottom",                     top, "opacity", CLUTTER_LINEAR, 0,                     bottom, "opacity", CLUTTER_LINEAR, 255,                     NULL);  clutter_state_set (transitions, NULL, "show-top",                     top, "opacity", CLUTTER_EASE_IN_CUBIC, 255,                     bottom, "opacity", CLUTTER_EASE_IN_CUBIC, 0,                     NULL);  clutter_state_set_duration (transitions, NULL, NULL, duration);  /* make the bottom opaque and top transparent */  clutter_state_warp_to_state (transitions, "show-bottom");  /* on key press, fade in the top texture and fade out the bottom texture */  g_signal_connect (stage,                    "key-press-event",                    G_CALLBACK (start_animation),                    transitions);  clutter_actor_show (stage);  clutter_main ();  g_object_unref (transitions);  if (error != NULL)    g_error_free (error);  return EXIT_SUCCESS;}

intmain (int argc, char *argv[]){  GstPipeline *pipeline;  GstBus *bus;  GstElement *srcbin;  GstElement *tee;  GstElement *queue[N_ACTORS], *sink[N_ACTORS];  GstElement *upload[N_ACTORS];/*  GstElement *effect[N_ACTORS];*/  ClutterActor *stage;  GstGLClutterActor *actor[N_ACTORS];  Display *disp;  Window stage_win;  const gchar *desc;  gint i;  gint ok = FALSE;  ClutterInitError clutter_err = CLUTTER_INIT_ERROR_UNKNOWN;  clutter_err = clutter_init (&argc, &argv);  if (clutter_err != CLUTTER_INIT_SUCCESS)    g_warning ("Failed to initalize clutter: %d/n", clutter_err);  gst_init (&argc, &argv);  disp = clutter_x11_get_default_display ();  if (!clutter_x11_has_composite_extension ()) {    g_error ("XComposite extension missing");  }  stage = clutter_stage_get_default ();  clutter_actor_set_size (CLUTTER_ACTOR (stage),      W * COLS + (COLS - 1), H * ROWS + (ROWS - 1));  stage_win = clutter_x11_get_stage_window (CLUTTER_STAGE (stage));  XCompositeRedirectSubwindows (disp, stage_win, CompositeRedirectManual);  for (i = 0; i < N_ACTORS; i++) {    actor[i] = g_new0 (GstGLClutterActor, 1);    actor[i]->stage = stage;    actor[i]->win = XCreateSimpleWindow (disp, stage_win, 0, 0, W, H, 0, 0, 0);    XMapRaised (disp, actor[i]->win);    XSync (disp, FALSE);  }/*  desc = g_strdup_printf ("v4l2src ! "                          "video/x-raw, width=640, height=480, framerate=30/1 ! "                          "videoscale !"                          "video/x-raw, width=%d, height=%d ! "                          "identity", W, H);*/  desc = g_strdup_printf ("videotestsrc ! "      "video/x-raw, format=RGB, width=%d, height=%d !" "identity", W, H);  pipeline = GST_PIPELINE (gst_pipeline_new (NULL));  srcbin = gst_parse_bin_from_description (desc, TRUE, NULL);  if (!srcbin)    g_error ("Source bin creation failed");  tee = gst_element_factory_make ("tee", NULL);  gst_bin_add_many (GST_BIN (pipeline), srcbin, tee, NULL);  for (i = 0; i < N_ACTORS; i++) {    queue[i] = gst_element_factory_make ("queue", NULL);    upload[i] = gst_element_factory_make ("glupload", NULL);/*      effect[i] = gst_element_factory_make ("gleffects", NULL); */    sink[i] = gst_element_factory_make ("glimagesink", NULL);/*    gst_bin_add_many (GST_BIN (pipeline),        queue[i], upload[i], effect[i], sink[i], NULL); */    gst_bin_add_many (GST_BIN (pipeline), queue[i], upload[i], sink[i], NULL);  }  gst_element_link_many (srcbin, tee, NULL);  for (i = 0; i < N_ACTORS; i++) {    ok |=//        gst_element_link_many (tee, queue[i], upload[i], effect[i], sink[i],        gst_element_link_many (tee, queue[i], upload[i], sink[i], NULL);  }  if (!ok)    g_error ("Failed to link one or more elements");/*  for (i = 0; i < N_ACTORS; i++) {    g_message ("setting effect %d on %s", i + 1,        gst_element_get_name (effect[i]));    g_object_set (G_OBJECT (effect[i]), "effect", i + 1, NULL);  }*/  bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));  gst_bus_set_sync_handler (bus, (GstBusSyncHandler) create_window, actor,      NULL);  gst_object_unref (bus);//.........这里部分代码省略.........

int main(int argc, char *argv[]){  ClutterColor stage_color = { 0x61, 0x64, 0x8c, 0xff };  /* Call gtk_clutter_init() to init both clutter and gtk+ */  if (gtk_clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)    g_error ("Unable to initialize GtkClutter");  if (argc != 2)    g_error ("Usage: example <image file>");    /* Create a toplevel window: */  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);  gtk_window_set_default_size (GTK_WINDOW (window), 640, 480);  g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);  /* Create a table to hold the scrollbars and the ClutterEmbed widget: */  GtkWidget *table = gtk_table_new (2, 2, FALSE);  gtk_container_add (GTK_CONTAINER (window), table);  gtk_widget_show (table);  /* Create ClutterEmbed widget for the stage: */  GtkWidget *embed = gtk_clutter_embed_new ();  gtk_table_attach (GTK_TABLE (table), embed,    0, 1,    0, 1,    GTK_EXPAND | GTK_FILL,    GTK_EXPAND | GTK_FILL,    0, 0);  gtk_widget_show (embed);  /* Init the stage: */  ClutterActor *stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (embed));  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);  clutter_actor_set_size (stage, 640, 480);  /* Create a viewport actor to be able to scroll actor. By passing NULL it   * will create new GtkAdjustments. */  ClutterActor *viewport = gtk_clutter_viewport_new (NULL, NULL, NULL);  clutter_container_add_actor (CLUTTER_CONTAINER (stage), viewport);  /* Load image from first command line argument and add it to viewport: */  ClutterActor *texture = clutter_texture_new_from_file (argv[1], NULL);  clutter_container_add_actor (CLUTTER_CONTAINER (viewport), texture);  clutter_actor_set_position (texture, 0, 0);  clutter_actor_set_position (texture, 0, 0);  clutter_actor_set_position (viewport, 0, 0);  clutter_actor_set_size (viewport, 640, 480);  /* Create scrollbars and connect them to viewport: */  GtkAdjustment *h_adjustment = NULL;  GtkAdjustment *v_adjustment = NULL;  gtk_clutter_scrollable_get_adjustments (GTK_CLUTTER_SCROLLABLE (viewport),    &h_adjustment, &v_adjustment);  GtkWidget *scrollbar = gtk_vscrollbar_new (v_adjustment);  gtk_table_attach (GTK_TABLE (table), scrollbar,    1, 2,    0, 1,    0, GTK_EXPAND | GTK_FILL,    0, 0);  gtk_widget_show (scrollbar);    scrollbar = gtk_hscrollbar_new (h_adjustment);  gtk_table_attach (GTK_TABLE (table), scrollbar,    0, 1,    1, 2,    GTK_EXPAND | GTK_FILL, 0,    0, 0);  gtk_widget_show (scrollbar);  gtk_widget_show (window);  gtk_main();	return EXIT_SUCCESS;}