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; }
void test_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); if (g_test_verbose ()) g_print ("OK\n"); }
G_MODULE_EXPORT int test_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; y = oh->stage_height / 2 + oh->radius * sin (i * G_PI / (n_hands / 2)) - h / 2; clutter_actor_set_position (oh->hand[i], x, y); clutter_actor_move_anchor_point_from_gravity (oh->hand[i], CLUTTER_GRAVITY_CENTER); g_signal_connect (oh->hand[i], "button-press-event", G_CALLBACK (on_button_press_event), oh); /* paint something before each hand */ g_signal_connect (oh->hand[i], "paint", G_CALLBACK (hand_pre_paint), oh); /* paint something after each hand */ g_signal_connect_after (oh->hand[i], "paint", G_CALLBACK (hand_post_paint), oh); /* Add to our group group */ clutter_container_add_actor (CLUTTER_CONTAINER (oh->group), oh->hand[i]); if (i % 2) clutter_behaviour_apply (oh->scaler_1, oh->hand[i]); else clutter_behaviour_apply (oh->scaler_2, oh->hand[i]); } oh->paint_guards = g_malloc0 (sizeof (gboolean) * n_hands); /* Add the group to the stage */ clutter_container_add_actor (CLUTTER_CONTAINER (stage), CLUTTER_ACTOR (oh->group)); /* Show everying ( and map window ) */ clutter_actor_show (stage); g_signal_connect (stage, "key-release-event", G_CALLBACK (input_cb), oh); /* and start it */ clutter_timeline_start (oh->timeline); clutter_main (); g_object_unref (oh->scaler_1); g_object_unref (oh->scaler_2); g_object_unref (oh->timeline); g_free (oh->paint_guards); g_free (oh->hand); g_free (oh); return 0; }
int main (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); }
int main (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; }
void mex_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)); }
int main (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; }
int main (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 gint test_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 gint test_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); #ifdef COGL_HAS_GLES2 /* On an embedded platform it is difficult to right click so we will cycle through the shaders automatically */ g_timeout_add_seconds (3, timeout_cb, actor); #endif /* Show everying ( and map window ) */ clutter_actor_show_all (stage); clutter_main (); return EXIT_SUCCESS; }
static gboolean on_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); if (g_test_verbose ()) g_print ("% 3i,% 3i / %p -> ", x, y, state->actors[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 { if (actor == state->actors[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 ("%p: %s\n", actor, pass ? "pass" : "FAIL"); } if (!pass) state->pass = FALSE; } } } clutter_main_quit (); return FALSE; }
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 int test_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; }
int main (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); labelContainer = clutter_actor_new (); clutter_actor_set_size (labelContainer, 0, 35); //clutter_actor_set_background_color (labelContainer, clutter_color_new (34, 134, 158, 255)); clutter_actor_set_name (labelContainer, "labelContainer"); clutter_actor_set_reactive (labelContainer, TRUE); //clutter_actor_set_x_expand (labelContainer, TRUE); //clutter_actor_set_y_expand (labelContainer, TRUE); clutter_actor_add_child (inset, labelContainer); labelContainer_l = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER, CLUTTER_BIN_ALIGNMENT_CENTER); clutter_actor_set_layout_manager (labelContainer, labelContainer_l); labelbg = clutter_actor_new (); clutter_actor_set_background_color (labelbg, clutter_color_new (34, 134, 158, 255)); clutter_actor_set_name (labelbg, "labelbg"); //clutter_actor_set_x_expand (labelbg, TRUE); clutter_actor_set_size (labelbg, 0, 35); clutter_actor_set_x_align (labelbg, CLUTTER_ACTOR_ALIGN_START); clutter_actor_set_y_align (labelbg, CLUTTER_ACTOR_ALIGN_FILL); clutter_actor_add_child (labelContainer, labelbg); contentContainer = clutter_actor_new (); clutter_actor_set_size (contentContainer, 0, 0); clutter_actor_set_background_color (contentContainer, clutter_color_new (0.290196*255, 0.427451*255, 0.462745*255, 255)); clutter_actor_set_name (contentContainer, "labelContainer"); //clutter_actor_set_x_expand (contentContainer, TRUE); //clutter_actor_set_y_expand (contentContainer, TRUE); clutter_actor_set_layout_manager (contentContainer, clutter_fixed_layout_new ()); clutter_actor_add_child (inset, contentContainer); fixed = clutter_actor_new (); clutter_actor_set_background_color (fixed, clutter_color_new (9, 53, 71, 255)); clutter_actor_set_name (fixed, "fixed"); clutter_actor_set_size (fixed, 582, 210-40); clutter_actor_set_position (fixed, 582, 0); layoutFixed = clutter_box_layout_new (); clutter_box_layout_set_vertical (CLUTTER_BOX_LAYOUT (layoutFixed), TRUE); clutter_box_layout_set_spacing (CLUTTER_BOX_LAYOUT (layoutFixed), 8); clutter_actor_set_layout_manager (fixed, layoutFixed); clutter_actor_add_child (contentContainer, fixed); //------------------------------------------------------------------------// lower = clutter_actor_new (); clutter_actor_set_size (lower, 0, 0); clutter_actor_set_name (lower, "lower"); //clutter_actor_set_x_expand (lower, TRUE); //clutter_actor_set_y_expand (lower, TRUE); clutter_actor_set_margin_right (lower, 8); clutter_actor_set_margin_top (lower, 8); clutter_actor_set_margin_left (lower, 8); clutter_actor_set_layout_manager (lower, clutter_fixed_layout_new ()); clutter_actor_set_clip_to_allocation(lower, TRUE); clutter_actor_add_child (fixed, lower); lowerInner = clutter_actor_new (); clutter_actor_set_background_color (lowerInner, clutter_color_new (255, 255, 255, 30)); clutter_actor_set_name (lowerInner, "fixed"); clutter_actor_set_size (lowerInner, 566, 113); clutter_actor_set_position (lowerInner, 566, 0); clutter_actor_add_child (lower, lowerInner); upper = clutter_actor_new (); clutter_actor_set_size (upper, 0, 33); clutter_actor_set_name (upper, "upper"); clutter_actor_set_x_expand (upper, TRUE); //clutter_actor_set_y_expand (upper, TRUE); clutter_actor_set_margin_bottom (upper, 8); clutter_actor_set_margin_right (upper, 8); clutter_actor_set_margin_left (upper, 8); //clutter_actor_set_layout_manager (upper, clutter_fixed_layout_new ()); clutter_actor_add_child (fixed, upper); timeline = clutter_timeline_new (57/24.*1000); clutter_timeline_add_marker_at_time(timeline, "first", (40-35)/24.*1000); clutter_timeline_add_marker_at_time(timeline, "second", (46-35)/24.*1000); clutter_timeline_add_marker_at_time(timeline, "third", (51-35)/24.*1000); clutter_timeline_add_marker_at_time(timeline, "fourth", (52-35)/24.*1000); clutter_timeline_add_marker_at_time(timeline, "fifth", (58-35)/24.*1000); g_signal_connect (timeline, "marker-reached::first", G_CALLBACK (plate1anim), bg); g_signal_connect (timeline, "marker-reached::second", G_CALLBACK (plate2anim), bg2); g_signal_connect (timeline, "marker-reached::third", G_CALLBACK (plate3anim), labelbg); g_signal_connect (timeline, "marker-reached::fourth", G_CALLBACK (plate4anim), fixed); g_signal_connect (timeline, "marker-reached::fifth", G_CALLBACK (plate5anim), lowerInner); g_signal_connect (canvas1, "draw", G_CALLBACK (draw_1), NULL); g_signal_connect (bg, "paint", G_CALLBACK (on_actor_resize), canvas); g_signal_connect (canvas, "draw", G_CALLBACK (draw), NULL); g_signal_connect (bg2, "paint", G_CALLBACK (on_actor_resize), canvas); clutter_content_invalidate (canvas); clutter_timeline_start (timeline); clutter_main (); return (EXIT_SUCCESS); }
static void make_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 gboolean on_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; }
int main (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 void on_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 int test_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 gboolean actor_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); if (type == CLUTTER_BOX2D_DYNAMIC) { #if 0 mouse_joint = clutter_box2d_add_mouse_joint (CLUTTER_BOX2D ( scene_get_group ()), manipulated_actor, &target); #endif mode = None; /*Box2D;*/ manipulated_actor = NULL; return FALSE; } } #endif clutter_set_motion_events_enabled (FALSE); return TRUE; }
int main (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; }
int main (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 int test_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 int test_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; }
int main (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; }
int main (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; }
int main (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; }
int main (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); gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PLAYING); clutter_actor_show_all (stage); clutter_main (); gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_NULL); gst_object_unref (pipeline); return 0; }
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; }