void test_timeline_interpolate (TestConformSimpleFixture *fixture, gconstpointer data) { TestState state; state.timeline = clutter_timeline_new (TEST_TIMELINE_DURATION); clutter_timeline_set_loop (state.timeline, TRUE); g_signal_connect (G_OBJECT(state.timeline), "new-frame", G_CALLBACK(new_frame_cb), &state); g_signal_connect (G_OBJECT(state.timeline), "completed", G_CALLBACK(completed_cb), &state); state.completion_count = 0; state.new_frame_counter = 0; state.passed = TRUE; state.expected_frame = 0; g_get_current_time (&state.start_time); clutter_timeline_start (state.timeline); clutter_main(); g_object_unref (state.timeline); }
static void mx_toggle_init (MxToggle *self) { ClutterTimeline *timeline; self->priv = TOGGLE_PRIVATE (self); self->priv->handle = g_object_new (MX_TYPE_TOGGLE_HANDLE, "reactive", TRUE, NULL); clutter_actor_add_child (CLUTTER_ACTOR (self), self->priv->handle); g_object_bind_property (self, "disabled", self->priv->handle, "disabled", G_BINDING_SYNC_CREATE); timeline = clutter_timeline_new (300); g_signal_connect (timeline, "new-frame", G_CALLBACK (mx_toggle_update_position), self); self->priv->alpha = clutter_alpha_new_full (timeline, CLUTTER_EASE_IN_OUT_CUBIC); clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE); clutter_actor_set_reactive (CLUTTER_ACTOR (self->priv->handle), TRUE); self->priv->drag_offset = -1; g_signal_connect (self->priv->handle, "button-press-event", G_CALLBACK (mx_toggle_handle_button_press_event), self); g_signal_connect (self->priv->handle, "button-release-event", G_CALLBACK (mx_toggle_handle_button_release_event), self); g_signal_connect (self->priv->handle, "motion-event", G_CALLBACK (mx_toggle_handle_motion_event), self); }
static void mx_expander_init (MxExpander *self) { MxExpanderPrivate *priv = self->priv = GET_PRIVATE (self); priv->label = clutter_text_new (); clutter_actor_add_child ((ClutterActor *) self, priv->label); priv->arrow = (ClutterActor *) mx_icon_new (); clutter_actor_add_child ((ClutterActor*) self, priv->arrow); clutter_actor_set_name (priv->arrow, "mx-expander-arrow-closed"); /* TODO: make this a style property */ priv->spacing = 10.0f; priv->timeline = clutter_timeline_new (250); clutter_timeline_set_progress_mode (priv->timeline, CLUTTER_EASE_IN_SINE); g_signal_connect (priv->timeline, "new-frame", G_CALLBACK (new_frame), self); g_signal_connect (priv->timeline, "completed", G_CALLBACK (timeline_complete), self); clutter_actor_set_reactive ((ClutterActor *) self, TRUE); g_signal_connect (self, "style-changed", G_CALLBACK (mx_expander_style_changed), NULL); g_signal_connect (self, "actor-added", G_CALLBACK (mx_expander_actor_added), NULL); g_signal_connect (self, "actor-removed", G_CALLBACK (mx_expander_actor_removed), NULL); }
StThemeNodeTransition * st_theme_node_transition_new (StThemeNode *from_node, StThemeNode *to_node, guint duration) { StThemeNodeTransition *transition; g_return_val_if_fail (ST_IS_THEME_NODE (from_node), NULL); g_return_val_if_fail (ST_IS_THEME_NODE (to_node), NULL); duration = st_theme_node_get_transition_duration (to_node); transition = g_object_new (ST_TYPE_THEME_NODE_TRANSITION, NULL); transition->priv->old_theme_node = g_object_ref (from_node); transition->priv->new_theme_node = g_object_ref (to_node); transition->priv->timeline = clutter_timeline_new (duration); transition->priv->timeline_completed_id = g_signal_connect (transition->priv->timeline, "completed", G_CALLBACK (on_timeline_completed), transition); transition->priv->timeline_new_frame_id = g_signal_connect (transition->priv->timeline, "new-frame", G_CALLBACK (on_timeline_new_frame), transition); clutter_timeline_set_progress_mode (transition->priv->timeline, CLUTTER_EASE_IN_OUT_QUAD); clutter_timeline_start (transition->priv->timeline); return transition; }
int main(int argc, char **argv) { TestState state; clutter_init(&argc, &argv); state.timeline = clutter_timeline_new (TEST_TIMELINE_FRAME_COUNT, TEST_TIMELINE_FPS); clutter_timeline_set_loop (state.timeline, TRUE); g_signal_connect (G_OBJECT(state.timeline), "new-frame", G_CALLBACK(new_frame_cb), &state); g_signal_connect (G_OBJECT(state.timeline), "completed", G_CALLBACK(completed_cb), &state); state.prev_frame = -1; state.completion_count = 0; state.passed = TRUE; clutter_timeline_start (state.timeline); clutter_main(); return EXIT_FAILURE; }
int main (int argc, char *argv[]) { ClutterActor *stage; ClutterActor *coglbox; ClutterTimeline *tl; clutter_init(&argc, &argv); tl = clutter_timeline_new (G_N_ELEMENTS (paint_func) * 1000); clutter_timeline_set_loop (tl, TRUE); clutter_timeline_start (tl); stage = clutter_stage_get_default (); clutter_actor_set_size (stage, 400, 400); clutter_stage_set_title (CLUTTER_STAGE (stage), "Cogl Test"); coglbox = clutter_group_new (); clutter_container_add_actor (CLUTTER_CONTAINER (stage), coglbox); g_signal_connect (coglbox, "paint", G_CALLBACK (paint_cb), tl); /* Redraw every frame of the timeline */ g_signal_connect_swapped (tl, "new-frame", G_CALLBACK (clutter_actor_queue_redraw), coglbox); clutter_actor_set_rotation (coglbox, CLUTTER_Y_AXIS, -30, 200, 0, 0); clutter_actor_set_position (coglbox, 0, 100); clutter_actor_show (stage); clutter_main (); g_object_unref (tl); return 0; }
static void fluttr_viewer_init (FluttrViewer *self) { FluttrViewerPrivate *priv; gint width, height; ClutterActor *message; priv = FLUTTR_VIEWER_GET_PRIVATE (self); priv->mini_token = NULL; priv->popping = FALSE; width = CLUTTER_STAGE_WIDTH (); height = CLUTTER_STAGE_HEIGHT (); /* message box */ message = clutter_texture_new (); priv->texture = message; clutter_group_add (CLUTTER_GROUP (self),message); clutter_actor_set_size (message, width, height); clutter_actor_set_position (message, -(width/2),-(height/2)); /* Spinner */ priv->spinner = fluttr_spinner_new (); clutter_group_add (CLUTTER_GROUP (self),priv->spinner); clutter_actor_set_size (priv->spinner, (height/6)-11, (height/6)-11); clutter_actor_set_position (priv->spinner, width-(height/6),height-(height/6)); /* Setup the pixbuf swap */ priv->pixbuf = NULL; priv->swap_time = clutter_timeline_new (40, 40); priv->swap_alpha = clutter_alpha_new_full (priv->swap_time, alpha_linear_inc_func, NULL, NULL); priv->swap_behave = fluttr_behave_new (priv->swap_alpha, fluttr_viewer_swap_alpha_func, (gpointer)self); priv->timeline = clutter_timeline_new (40, 80); priv->alpha = clutter_alpha_new_full (priv->timeline, alpha_sine_inc_func, NULL, NULL); priv->behave = fluttr_behave_new (priv->alpha, fluttr_viewer_alpha_func, (gpointer)self); }
int main(int argc,char *argv[]) { ClutterColor stage_color = { 0x00, 0x00, 0x00, 0xff }; ClutterColor actor_color = { 0xff,0xff,0xff,0x98}; /** 初始化clutter */ clutter_init(&argc, &argv); /** 获取默认的场景stage */ ClutterActor *stage = clutter_stage_get_default(); /** 设置场景大小,注意场景也actor的一种,所以可以使用actor的api设置*/ clutter_actor_set_size(stage,400,400); /** 设置场景背景*/ clutter_stage_set_color(CLUTTER_STAGE(stage), &stage_color); /** 载入一个图像的actor */ //ClutterActor * image = clutter_texture_new_from_file("demo.png",NULL); image = clutter_texture_new_from_file("demo.png",NULL); if(!image){ printf("load image error\n"); exit(-1); } /** 设置actor在场景中的位置*/ clutter_actor_set_position(image, 100,100); /** 缩放图像,这里设置长宽各放大了两倍*/ clutter_actor_set_scale(image,2.0,2.0); /** 设置图像旋转,以y轴旋转,角度20'c */ clutter_actor_set_rotation(image, CLUTTER_Y_AXIS, 120,0,0,0); /** 把actor加入场景中*/ clutter_container_add_actor(CLUTTER_CONTAINER(stage),image); clutter_actor_show(image); /** 打开actor的事件响应*/ clutter_actor_set_reactive(image,TRUE); /** 连接actor的某事件*/ g_signal_connect(image, "button-press-event", G_CALLBACK(on_image_button_press),NULL); /** 加入时间线*/ //ClutterTimeline* timeline = clutter_timeline_new(5000); timeline = clutter_timeline_new(5000); g_signal_connect(timeline, "new-frame",G_CALLBACK(on_timeline_new_frame),NULL); clutter_timeline_set_loop(timeline,TRUE); //clutter_timeline_start(timeline); clutter_actor_show(stage); clutter_main(); g_object_unref(timeline); printf("\n"); return 0; }
G_MODULE_EXPORT int test_viewport_main (int argc, char *argv[]) { ClutterTimeline *timeline; ClutterAlpha *alpha; ClutterBehaviour *r_behave; ClutterActor *stage; ClutterActor *hand; ClutterColor stage_color = { 0xcc, 0xcc, 0xcc, 0xff }; gchar *file; clutter_init (&argc, &argv); stage = clutter_stage_get_default (); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); /* Make a hand */ file = g_build_filename (TESTS_DATADIR, "redhand.png", NULL); hand = clutter_texture_new_from_file (file, NULL); if (!hand) g_error("Unable to load image '%s'", file); g_free (file); clutter_actor_set_position (hand, 300, 200); clutter_actor_set_clip (hand, 20, 21, 132, 170); clutter_actor_set_anchor_point (hand, 86, 125); clutter_actor_show (hand); clutter_container_add_actor (CLUTTER_CONTAINER (stage), hand); /* Make a timeline */ timeline = clutter_timeline_new (7692); clutter_timeline_set_loop (timeline, TRUE); /* Set an alpha func to power behaviour */ alpha = clutter_alpha_new_full (timeline, CLUTTER_LINEAR); /* Create a behaviour for that alpha */ r_behave = clutter_behaviour_rotate_new (alpha, CLUTTER_Z_AXIS, CLUTTER_ROTATE_CW, 0.0, 360.0); /* Apply it to our actor */ clutter_behaviour_apply (r_behave, hand); /* start the timeline and thus the animations */ clutter_timeline_start (timeline); clutter_actor_show_all (stage); clutter_main(); g_object_unref (r_behave); return 0; }
G_MODULE_EXPORT gint test_texture_quality_main (int argc, char *argv[]) { ClutterTimeline *timeline; ClutterAlpha *alpha; ClutterBehaviour *depth_behavior; ClutterActor *stage; ClutterActor *image; ClutterColor stage_color = { 0x12, 0x34, 0x56, 0xff }; ClutterFog stage_fog = { 10.0, -50.0 }; GError *error; clutter_init (&argc, &argv); stage = clutter_stage_get_default (); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); clutter_stage_set_use_fog (CLUTTER_STAGE (stage), TRUE); clutter_stage_set_fog (CLUTTER_STAGE (stage), &stage_fog); g_signal_connect (stage, "button-press-event", G_CALLBACK (clutter_main_quit), NULL); error = NULL; image = clutter_texture_new_from_file (argv[1]?argv[1]:"redhand.png", &error); if (error) g_error ("Unable to load image: %s", error->message); if (!argv[1]) g_print ("Hint: the redhand.png isn't a good test image for this test.\n" "This test can take any clutter loadable image as an argument\n"); /* center the image */ clutter_actor_set_position (image, (clutter_actor_get_width (stage) - clutter_actor_get_width (image))/2, (clutter_actor_get_height (stage) - clutter_actor_get_height (image))/2); clutter_container_add (CLUTTER_CONTAINER (stage), image, NULL); timeline = clutter_timeline_new (5000); g_signal_connect (timeline, "completed", G_CALLBACK (timeline_completed), NULL); alpha = clutter_alpha_new_full (timeline, CLUTTER_LINEAR); depth_behavior = clutter_behaviour_depth_new (alpha, -2500, 400); clutter_behaviour_apply (depth_behavior, image); clutter_actor_show (stage); clutter_timeline_start (timeline); g_timeout_add (10000, change_filter, image); clutter_main (); g_object_unref (depth_behavior); g_object_unref (timeline); return EXIT_SUCCESS; }
int main(int argc, char ** argv) { ClutterColor stage_color = {0x00, 0x00, 0x00, 0xFF}; // Black ClutterColor rect_color = {0x00, 0xFF, 0xFF, 0xFF}; // Purple clutter_init(&argc, &argv); ClutterActor * stage = clutter_stage_get_default(); clutter_actor_set_size(stage, 200, 200); clutter_stage_set_color(CLUTTER_STAGE(stage), &stage_color); rect = clutter_rectangle_new_with_color(&rect_color); clutter_actor_set_size(rect, 70, 70); clutter_actor_set_position(rect, 50, 100); clutter_container_add_actor(CLUTTER_CONTAINER(stage), rect); clutter_actor_show(rect); clutter_actor_show(stage); ClutterScore * score = clutter_score_new(); clutter_score_set_loop(score, TRUE); ClutterTimeline * rtimeline = clutter_timeline_new(10, //frames 120 //fps ); g_signal_connect(rtimeline, "new-frame", G_CALLBACK(on_timeline_rotation_new_frame), NULL); clutter_score_append(score, NULL, rtimeline); ClutterTimeline * mtimeline = clutter_timeline_new(10, //frames 120 //fps ); g_signal_connect(mtimeline, "new-frame", G_CALLBACK(on_timeline_move_new_frame), NULL); clutter_score_append(score, rtimeline, mtimeline); clutter_score_start(score); clutter_main(); g_object_unref(rtimeline); g_object_unref(mtimeline); g_object_unref(score); return EXIT_SUCCESS; }
int main (int argc, char *argv[]) { ClutterActor *stage; ClutterPath *path; ClutterConstraint *constraint; ClutterActor *rectangle; ClutterTimeline *timeline; const ClutterColor *stage_color = clutter_color_new (51, 51, 85, 255); const ClutterColor *red_color = clutter_color_new (255, 0, 0, 255); clutter_init (&argc, &argv); stage = clutter_stage_new (); clutter_actor_set_size (stage, 360, 300); clutter_stage_set_color (CLUTTER_STAGE (stage), stage_color); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); /* create the path */ path = clutter_path_new (); clutter_path_add_move_to (path, 30, 60); /* add a curve round to the top-right of the stage */ clutter_path_add_rel_curve_to (path, 120, 180, 180, 120, 240, 0); /* create a constraint based on the path */ constraint = clutter_path_constraint_new (path, 0.0); /* put a rectangle at the start of the path */ rectangle = clutter_rectangle_new_with_color (red_color); clutter_actor_set_size (rectangle, 60, 60); /* add the constraint to the rectangle */ clutter_actor_add_constraint_with_name (rectangle, "path", constraint); /* add the rectangle to the stage */ clutter_container_add_actor (CLUTTER_CONTAINER (stage), rectangle); /* set up the timeline */ timeline = clutter_timeline_new (1000); clutter_timeline_set_loop (timeline, TRUE); clutter_timeline_set_auto_reverse (timeline, TRUE); clutter_actor_animate_with_timeline (rectangle, CLUTTER_LINEAR, timeline, "@constraints.path.offset", 1.0, NULL); clutter_actor_show (stage); clutter_main (); return EXIT_SUCCESS; }
static void mex_tile_init (MexTile *self) { MexTilePrivate *priv = self->priv = TILE_PRIVATE (self); const ClutterColor opaque = { 0x00, 0x00, 0x00, 0x00 }; ClutterEffect *fade; /* create a template material for the header background from which cheap * copies can be made for each instance */ if (G_UNLIKELY (!template_material)) template_material = cogl_material_new (); priv->material = cogl_material_copy (template_material); /* layout for primary and secondary labels */ priv->box_layout = mx_box_layout_new (); mx_box_layout_set_spacing (MX_BOX_LAYOUT (priv->box_layout), 12); /* add fade effect to the box layout */ fade = (ClutterEffect*) mx_fade_effect_new (); mx_fade_effect_set_border (MX_FADE_EFFECT (fade), 0, 50, 0, 0); mx_fade_effect_set_color (MX_FADE_EFFECT (fade), &opaque); clutter_actor_add_effect_with_name (priv->box_layout, "fade", fade); clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (fade), TRUE); clutter_actor_push_internal (CLUTTER_ACTOR (self)); clutter_actor_set_parent (priv->box_layout, CLUTTER_ACTOR (self)); clutter_actor_pop_internal (CLUTTER_ACTOR (self)); priv->label = clutter_text_new (); priv->secondary_label = clutter_text_new (); clutter_actor_set_opacity (priv->secondary_label, 128); clutter_container_add (CLUTTER_CONTAINER (priv->box_layout), priv->label, priv->secondary_label, NULL); priv->header_visible = TRUE; priv->timeline = clutter_timeline_new (DURATION); priv->important_alpha = clutter_alpha_new_full (priv->timeline, CLUTTER_EASE_OUT_QUAD); g_signal_connect_object (priv->timeline, "new-frame", G_CALLBACK (mex_tile_important_new_frame_cb), self, 0); g_signal_connect_object (priv->timeline, "completed", G_CALLBACK (mex_tile_timeline_completed_cb), self, 0); g_signal_connect (self, "style-changed", G_CALLBACK (mex_tile_style_changed_cb), NULL); g_signal_connect (self, "actor-added", G_CALLBACK (mex_tile_actor_added), NULL); g_signal_connect (self, "actor-removed", G_CALLBACK (mex_tile_actor_removed), NULL); }
int main(int argc, char *argv[]) { GstElement *pipeline, *sink; ClutterTimeline *timeline; ClutterActor *stage, *texture; /* clutter-gst takes care of initializing Clutter and GStreamer */ if (clutter_gst_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) { g_error ("Failed to initialize clutter\n"); return -1; } stage = clutter_stage_get_default (); /* Make a timeline */ timeline = clutter_timeline_new (1000); g_object_set(timeline, "loop", TRUE, NULL); /* Create new texture and disable slicing so the video is properly mapped onto it */ texture = CLUTTER_ACTOR (g_object_new (CLUTTER_TYPE_TEXTURE, "disable-slicing", TRUE, NULL)); g_signal_connect (texture, "size-change", G_CALLBACK (size_change), NULL); /* Build the GStreamer pipeline */ pipeline = gst_parse_launch ("playbin2 uri=http://docs.gstreamer.com/media/sintel_trailer-480p.webm", NULL); /* Instantiate the Clutter sink */ sink = gst_element_factory_make ("autocluttersink", NULL); if (sink == NULL) { /* Revert to the older cluttersink, in case autocluttersink was not found */ sink = gst_element_factory_make ("cluttersink", NULL); } if (sink == NULL) { g_printerr ("Unable to find a Clutter sink.\n"); return -1; } /* Link GStreamer with Clutter by passing the Clutter texture to the Clutter sink*/ g_object_set (sink, "texture", texture, NULL); /* Add the Clutter sink to the pipeline */ g_object_set (pipeline, "video-sink", sink, NULL); /* Start playing */ gst_element_set_state (pipeline, GST_STATE_PLAYING); /* start the timeline */ clutter_timeline_start (timeline); /* Add texture to the stage, and show it */ clutter_group_add (CLUTTER_GROUP (stage), texture); clutter_actor_show_all (stage); clutter_main(); /* Free resources */ gst_element_set_state (pipeline, GST_STATE_NULL); gst_object_unref (pipeline); return 0; }
static void gesture_end (ClutterGestureAction *gesture, ClutterActor *actor) { ClutterPanAction *self = CLUTTER_PAN_ACTION (gesture); ClutterPanActionPrivate *priv = self->priv; gfloat velocity, velocity_x, velocity_y; gfloat delta_x, delta_y; gfloat tau; gint duration; clutter_gesture_action_get_release_coords (CLUTTER_GESTURE_ACTION (self), 0, &priv->release_x, &priv->release_y); if (!priv->should_interpolate) { priv->state = PAN_STATE_INACTIVE; return; } priv->state = PAN_STATE_INTERPOLATING; clutter_gesture_action_get_motion_delta (gesture, 0, &delta_x, &delta_y); velocity = clutter_gesture_action_get_velocity (gesture, 0, &velocity_x, &velocity_y); /* Exponential timing constant v(t) = v(0) * exp(-t/tau) * tau = 1000ms / (frame_per_second * - ln(decay_per_frame)) * with frame_per_second = 60 and decay_per_frame = 0.95, tau ~= 325ms * see http://ariya.ofilabs.com/2011/10/flick-list-with-its-momentum-scrolling-and-deceleration.html */ tau = 1000.0f / (reference_fps * - logf (priv->deceleration_rate)); /* See where the decreasing velocity reaches $min_velocity px/ms * v(t) = v(0) * exp(-t/tau) = min_velocity * t = - tau * ln( min_velocity / |v(0)|) */ duration = - tau * logf (min_velocity / (ABS (velocity) * priv->acceleration_factor)); /* Target point: x(t) = v(0) * tau * [1 - exp(-t/tau)] */ priv->target_x = velocity_x * priv->acceleration_factor * tau * (1 - exp ((float)-duration / tau)); priv->target_y = velocity_y * priv->acceleration_factor * tau * (1 - exp ((float)-duration / tau)); if (ABS (velocity) * priv->acceleration_factor > min_velocity && duration > FLOAT_EPSILON) { priv->interpolated_x = priv->interpolated_y = 0.0f; priv->deceleration_timeline = clutter_timeline_new (duration); clutter_timeline_set_progress_mode (priv->deceleration_timeline, CLUTTER_EASE_OUT_EXPO); g_signal_connect (priv->deceleration_timeline, "new_frame", G_CALLBACK (on_deceleration_new_frame), self); g_signal_connect (priv->deceleration_timeline, "stopped", G_CALLBACK (on_deceleration_stopped), self); clutter_timeline_start (priv->deceleration_timeline); } else { emit_pan_stopped (self, actor); } }
G_MODULE_EXPORT int test_cairo_flowers_main (int argc, char **argv) { Flower *flowers[N_FLOWERS]; ClutterTimeline *timeline; int i; srand (time (NULL)); if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; /* Create a timeline to manage animation */ timeline = clutter_timeline_new (6000); clutter_timeline_set_repeat_count (timeline, -1); stage = clutter_stage_new (); clutter_stage_set_title (CLUTTER_STAGE (stage), "Cairo Flowers"); g_signal_connect (stage, "destroy", G_CALLBACK (stop_and_quit), timeline); clutter_actor_set_background_color (stage, CLUTTER_COLOR_Black); for (i=0; i< N_FLOWERS; i++) { flowers[i] = g_new0(Flower, 1); flowers[i]->ctex = make_flower_actor(); flowers[i]->x = rand() % (int) clutter_actor_get_width (stage) - (PETAL_MIN + PETAL_VAR) * 2; flowers[i]->y = rand() % (int) clutter_actor_get_height (stage); flowers[i]->rv = rand() % 5 + 1; flowers[i]->v = rand() % 10 + 2; clutter_container_add_actor (CLUTTER_CONTAINER (stage), flowers[i]->ctex); clutter_actor_set_position (flowers[i]->ctex, flowers[i]->x, flowers[i]->y); } /* fire a callback for frame change */ g_signal_connect (timeline, "new-frame", G_CALLBACK (tick), flowers); clutter_actor_show (stage); clutter_timeline_start (timeline); g_signal_connect (stage, "key-press-event", G_CALLBACK (clutter_main_quit), NULL); clutter_main(); g_object_unref (timeline); return EXIT_SUCCESS; }
int test_cairo_flowers_main (int argc, char **argv) { int i; ClutterActor *stage; ClutterColor stage_color = { 0x0, 0x0, 0x0, 0xff }; ClutterTimeline *timeline; Flower *flowers[N_FLOWERS]; srand (time (NULL)); if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; stage = clutter_stage_get_default (); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); for (i=0; i< N_FLOWERS; i++) { flowers[i] = g_new0(Flower, 1); flowers[i]->ctex = make_flower_actor(); flowers[i]->x = rand() % (int) clutter_actor_get_width (stage) - (PETAL_MIN + PETAL_VAR) * 2; flowers[i]->y = rand() % (int) clutter_actor_get_height (stage); flowers[i]->rv = rand() % 5 + 1; flowers[i]->v = rand() % 10 + 2; clutter_container_add_actor (CLUTTER_CONTAINER (stage), flowers[i]->ctex); clutter_actor_set_position (flowers[i]->ctex, flowers[i]->x, flowers[i]->y); } /* Create a timeline to manage animation */ timeline = clutter_timeline_new (6000); clutter_timeline_set_loop (timeline, TRUE); /* fire a callback for frame change */ g_signal_connect (timeline, "new-frame", G_CALLBACK (tick), flowers); clutter_actor_show (stage); clutter_timeline_start (timeline); g_signal_connect (stage, "key-press-event", G_CALLBACK (clutter_main_quit), NULL); clutter_main(); return EXIT_SUCCESS; }
/** * mx_adjustment_interpolate: * @adjustment: A #MxAdjustment * @value: A #gdouble * @duration: duration in milliseconds * @mode: A #ClutterAnimationMode * * Interpolate #MxAdjustment:value to the new value specified by @value, using * the mode and duration given. */ void mx_adjustment_interpolate (MxAdjustment *adjustment, gdouble value, guint duration, gulong mode) { MxAdjustmentPrivate *priv = adjustment->priv; g_return_if_fail (isfinite (value)); if (duration <= 1) { stop_interpolation (adjustment); mx_adjustment_set_value (adjustment, value); return; } priv->old_position = priv->value; priv->new_position = value; if (!priv->interpolation) { priv->interpolation = clutter_timeline_new (duration); g_signal_connect (priv->interpolation, "new-frame", G_CALLBACK (interpolation_new_frame_cb), adjustment); g_signal_connect (priv->interpolation, "completed", G_CALLBACK (interpolation_completed_cb), adjustment); } else { /* Extend the animation if it gets interrupted, otherwise frequent calls * to this function will end up with no advancements until the calls * finish (as the animation never gets a chance to start). */ clutter_timeline_set_direction (priv->interpolation, CLUTTER_TIMELINE_FORWARD); clutter_timeline_rewind (priv->interpolation); clutter_timeline_set_duration (priv->interpolation, duration); } if (priv->interpolate_alpha) g_object_unref (priv->interpolate_alpha); priv->interpolate_alpha = clutter_alpha_new_full (priv->interpolation, mode); clutter_timeline_start (priv->interpolation); }
static void mex_column_init (MexColumn *self) { MexColumnPrivate *priv = self->priv = GET_PRIVATE (self); /* Set the column as reactive and enable collapsing */ clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE); priv->collapse = TRUE; /* Create a timeline for the expand animation. The duration is calculated * before the timeline is started. */ priv->expand_timeline = clutter_timeline_new (1); }
G_MODULE_EXPORT int test_cogl_vertex_buffer_main (int argc, char *argv[]) { TestState state; ClutterActor *stage; gfloat stage_w, stage_h; gint dummy_width, dummy_height; if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; stage = clutter_stage_new (); clutter_stage_set_title (CLUTTER_STAGE (stage), "Cogl Vertex Buffers"); clutter_stage_set_color (CLUTTER_STAGE (stage), CLUTTER_COLOR_Black); g_signal_connect (stage, "destroy", G_CALLBACK (stop_and_quit), &state); clutter_actor_get_size (stage, &stage_w, &stage_h); dummy_width = MESH_WIDTH * QUAD_WIDTH; dummy_height = MESH_HEIGHT * QUAD_HEIGHT; state.dummy = create_dummy_actor (dummy_width, dummy_height); clutter_container_add_actor (CLUTTER_CONTAINER (stage), state.dummy); clutter_actor_set_position (state.dummy, (stage_w / 2.0) - (dummy_width / 2.0), (stage_h / 2.0) - (dummy_height / 2.0)); state.timeline = clutter_timeline_new (1000); clutter_timeline_set_loop (state.timeline, TRUE); state.frame_id = g_signal_connect (state.timeline, "new-frame", G_CALLBACK (frame_cb), &state); g_signal_connect (state.dummy, "paint", G_CALLBACK (on_paint), &state); init_quad_mesh (&state); clutter_actor_show_all (stage); clutter_timeline_start (state.timeline); clutter_main (); cogl_handle_unref (state.buffer); cogl_handle_unref (state.indices); return 0; }
static void aisleriot_slot_renderer_init (AisleriotSlotRenderer *self) { AisleriotSlotRendererPrivate *priv; priv = self->priv = AISLERIOT_SLOT_RENDERER_GET_PRIVATE (self); priv->revealed_card = -1; priv->highlight_start = G_MAXINT; priv->animations = g_array_new (FALSE, FALSE, sizeof (AnimationData)); priv->timeline = clutter_timeline_new (500); g_signal_connect_swapped (priv->timeline, "completed", G_CALLBACK (completed_cb), self); }
int main (int argc, char *argv[]) { ClutterActor *stage; ClutterActor *actor; ClutterTimeline *timeline; ClutterAnimator *animator; clutter_init (&argc, &argv); stage = clutter_stage_get_default (); clutter_actor_set_size (stage, 300, 200); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); actor = clutter_rectangle_new_with_color (&red_color); clutter_actor_set_size (actor, 100, 100); clutter_actor_set_position (actor, 150, 50); timeline = clutter_timeline_new (2000); clutter_timeline_set_loop (timeline, TRUE); animator = clutter_animator_new (); clutter_animator_set_timeline (animator, timeline); clutter_animator_set (animator, actor, "x", CLUTTER_LINEAR, 0.0, 150.0, actor, "x", CLUTTER_LINEAR, 0.5, 50.0, actor, "x", CLUTTER_LINEAR, 1.0, 150.0, NULL); clutter_container_add_actor (CLUTTER_CONTAINER (stage), actor); g_signal_connect (stage, "key-press-event", G_CALLBACK (key_pressed_cb), timeline); clutter_actor_show (stage); clutter_main (); g_object_unref (animator); return EXIT_SUCCESS; }
bool StageManager::initStage() { stage_ = clutter_stage_get_default(); float width = (float) getAttribute("size").getInt(0); float height =(float) getAttribute("size").getInt(1); clutter_actor_set_size(stage_, width, height); clutter_stage_set_color(CLUTTER_STAGE(stage_), &black); g_signal_connect(stage_, "destroy", G_CALLBACK(on_stage_destroyed), (gpointer) this); std::string filename = getAttribute("script").getString(0); GError *error = NULL; /* load JSON from a file */ ClutterScript *script = clutter_script_new(); clutter_script_load_from_file(script, filename.c_str(), &error); if (error != NULL) { std::cerr << "Unable to read file: " << error->message << std::endl; g_error_free(error); // TODO: fail g_critical("Could not load GUI"); return false; } ClutterActor *group0 = CLUTTER_ACTOR(clutter_script_get_object(script, "group0")); // TODO: rename to root clutter_container_add_actor(CLUTTER_CONTAINER(stage_), group0); //clutter_script_connect_signals(script, this); clutter_script_connect_signals_full(script, tempi_clutter_connect_signals, this); // timeline to attach a callback for each frame that is rendered ClutterTimeline *timeline; timeline = clutter_timeline_new(60); // ms clutter_timeline_set_loop(timeline, TRUE); clutter_timeline_start(timeline); g_signal_connect(timeline, "new-frame", G_CALLBACK(on_frame_cb), this); g_signal_connect(stage_, "key-press-event", G_CALLBACK(key_event_cb), this); g_object_unref(script); // avoid memory leak clutter_actor_show(stage_); if (CLUTTER_IS_ACTOR(stage_)) return true; else return false; }
static void mex_content_box_init (MexContentBox *self) { MexContentBoxPrivate *priv = self->priv = CONTENT_BOX_PRIVATE (self); ClutterActor *icon; clutter_actor_push_internal (CLUTTER_ACTOR (self)); priv->info_panel = mex_info_panel_new (MEX_INFO_PANEL_MODE_SIMPLE); clutter_actor_set_parent (priv->info_panel, CLUTTER_ACTOR (self)); /* monitor key press events */ g_signal_connect (self, "key-press-event", G_CALLBACK (mex_content_box_key_press_event_cb), NULL); /* Create tile */ icon = mx_icon_new (); priv->tile = mex_content_tile_new (); clutter_actor_set_parent (priv->tile, CLUTTER_ACTOR (self)); g_object_set (G_OBJECT (priv->tile), "thumb-width", DEFAULT_THUMB_WIDTH, "thumb-height", DEFAULT_THUMB_HEIGHT, NULL); mx_stylable_set_style_class (MX_STYLABLE (icon), "Info"); mex_tile_set_secondary_icon (MEX_TILE (priv->tile), icon); clutter_actor_set_reactive (priv->tile, TRUE); g_signal_connect (priv->tile, "button-release-event", G_CALLBACK (mex_content_box_tile_clicked_cb), self); /* Create the action list */ priv->action_list = mex_action_list_new (); clutter_actor_set_parent (priv->action_list, CLUTTER_ACTOR (self)); clutter_actor_pop_internal (CLUTTER_ACTOR (self)); priv->timeline = clutter_timeline_new (200); priv->alpha = clutter_alpha_new_full (priv->timeline, CLUTTER_EASE_OUT_CUBIC); g_signal_connect_swapped (priv->timeline, "new-frame", G_CALLBACK (clutter_actor_queue_relayout), self); g_signal_connect (priv->timeline, "completed", G_CALLBACK (mex_content_box_timeline_completed), self); }
int main(int argc, char *argv[]) { ClutterColor stage_color = { 0x00, 0x00, 0x00, 0xff }; ClutterColor rect_color = { 0xff, 0xff, 0xff, 0x99 }; clutter_init (&argc, &argv); /* Get the stage and set its size and color: */ ClutterActor *stage = clutter_stage_get_default (); clutter_actor_set_size (stage, 200, 200); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); /* Add a rectangle to the stage: */ rect = clutter_rectangle_new_with_color (&rect_color); clutter_actor_set_size (rect, 40, 40); clutter_actor_set_position (rect, 10, 10); clutter_container_add_actor (CLUTTER_CONTAINER (stage), rect); clutter_actor_show (rect); /* Show the stage: */ clutter_actor_show (stage); ClutterTimeline *timeline = clutter_timeline_new(5000 /* milliseconds */); clutter_timeline_set_loop(timeline, TRUE); clutter_timeline_start(timeline); /* Create a clutter alpha for the animation */ ClutterAlpha* alpha = clutter_alpha_new_with_func (timeline, &on_alpha, NULL, NULL); g_object_unref (timeline); /* Create an animation to change the properties */ ClutterAnimation* animation = clutter_actor_animate_with_alpha (rect, alpha, "x", 150.0, "y", 150.0, "opacity", 0, NULL); /* Start the main loop, so we can respond to events: */ clutter_main (); g_object_unref (animation); return EXIT_SUCCESS; }
bool App::launch() { if (osc_recv_port_ == 0) if (verbose_) std::cout << "OSC receiving disabled." << std::endl; else startOSC(); // Poll OSC receiver only when we render a Clutter frame. if (stage_) { std::cerr << "cannot create stage twice" << std::endl; //return false; } stage_ = clutter_stage_get_default(); clutter_actor_set_size(stage_, 1024, 768); ClutterColor black = { 0x00, 0x00, 0x00, 0xff }; clutter_stage_set_color(CLUTTER_STAGE(stage_), &black); g_signal_connect(stage_, "destroy", G_CALLBACK(clutter_main_quit), NULL); clutter_actor_set_reactive(stage_, TRUE); // timeline to attach a callback for each frame that is rendered ClutterTimeline *timeline; timeline = clutter_timeline_new(60); // ms clutter_timeline_set_loop(timeline, TRUE); clutter_timeline_start(timeline); g_signal_connect(timeline, "new-frame", G_CALLBACK(on_frame_cb), this); g_signal_connect(stage_, "key-press-event", G_CALLBACK(key_event_cb), this); g_signal_connect(stage_, "button-press-event", G_CALLBACK(button_press_cb), this); g_signal_connect(stage_, "button-release-event", G_CALLBACK(button_released_cb), this); g_signal_connect(stage_, "motion-event", G_CALLBACK(motion_event_cb), this); if (fullscreen_) { fullscreen_ = false; toggleFullscreen(); } createPalette(); clutter_actor_show(stage_); return true; }
static ClutterAlpha * layout_manager_real_begin_animation (ClutterLayoutManager *manager, guint duration, gulong mode) { ClutterTimeline *timeline; ClutterAlpha *alpha; alpha = g_object_get_qdata (G_OBJECT (manager), quark_layout_alpha); if (alpha != NULL) { clutter_alpha_set_mode (alpha, mode); timeline = clutter_alpha_get_timeline (alpha); clutter_timeline_set_duration (timeline, duration); clutter_timeline_rewind (timeline); return alpha; }; timeline = clutter_timeline_new (duration); alpha = clutter_alpha_new_full (timeline, mode); /* let the alpha take ownership of the timeline */ g_object_unref (timeline); g_signal_connect_swapped (timeline, "completed", G_CALLBACK (clutter_layout_manager_end_animation), manager); g_signal_connect_swapped (timeline, "new-frame", G_CALLBACK (clutter_layout_manager_layout_changed), manager); g_object_set_qdata_full (G_OBJECT (manager), quark_layout_alpha, alpha, (GDestroyNotify) g_object_unref); clutter_timeline_start (timeline); return alpha; }
Preview::Preview(): width(0), height(0), blocknr(-1), color(-1), themeID(0), cell_size(20), cache(NULL), enabled(true) { blocks = new Block*[PREVIEW_WIDTH]; for (int i = 0; i < PREVIEW_WIDTH; i++) { blocks[i] = new Block [PREVIEW_HEIGHT]; } w = gtk_clutter_embed_new(); g_signal_connect (w, "size_allocate", G_CALLBACK (resize), this); /* FIXME: We should scale with the rest of the UI, but that requires * changes to the widget layout - i.e. wrap the preview in an * fixed-aspect box. */ gtk_widget_set_size_request (w, 120, 120); ClutterActor *stage; stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (w)); ClutterColor stage_color = { 0x0, 0x0, 0x0, 0xff }; clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); piece = clutter_group_new (); clutter_group_add (CLUTTER_GROUP (stage), piece); piece_timeline = clutter_timeline_new (180); alpha = clutter_alpha_new_full (piece_timeline, CLUTTER_EASE_IN_OUT_SINE); piece_behav = clutter_behaviour_scale_new (alpha, 0.6, 0.6, 1.0, 1.0); clutter_actor_set_anchor_point (piece, 60, 60); clutter_actor_set_position (CLUTTER_ACTOR(piece), 60, 60); clutter_behaviour_apply (piece_behav, piece); }
void on_call_activate_complete (ClutterActor *actor, gpointer user_data) { ClutterAlpha *alpha; ClutterBehaviour *behave; App *app = (App*)user_data; clutter_actor_hide (app->screen_dialpad); /* Setup the pulsing 'calling..' text if need be */ if (app->dialing_timeline == NULL) { app->dialing_timeline = clutter_timeline_new (1000); clutter_timeline_set_loop (app->dialing_timeline, TRUE); alpha = clutter_alpha_new_full (app->dialing_timeline, ALPHA_SINE); behave = clutter_behaviour_opacity_new (alpha, 0xff, 0); clutter_behaviour_apply (behave, app->dial_label); } clutter_timeline_start (app->dialing_timeline); app->dialing_state = TRUE; }
static void mx_label_init (MxLabel *label) { MxLabelPrivate *priv; const ClutterColor opaque = { 0xff, 0xff, 0xff, 0xff }; label->priv = priv = MX_LABEL_GET_PRIVATE (label); priv->label = g_object_new (CLUTTER_TYPE_TEXT, "ellipsize", PANGO_ELLIPSIZE_END, NULL); clutter_actor_set_parent (priv->label, CLUTTER_ACTOR (label)); priv->fade_effect = mx_fade_effect_new (); mx_fade_effect_set_color (MX_FADE_EFFECT (priv->fade_effect), &opaque); clutter_actor_add_effect (priv->label, priv->fade_effect); clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (priv->fade_effect), FALSE); g_signal_connect (label, "style-changed", G_CALLBACK (mx_label_style_changed), NULL); g_signal_connect (priv->label, "notify::single-line-mode", G_CALLBACK (mx_label_single_line_mode_cb), label); g_signal_connect_swapped (priv->label, "queue-redraw", G_CALLBACK (mx_label_label_changed_cb), label); priv->fade_timeline = clutter_timeline_new (250); priv->fade_alpha = clutter_alpha_new_full (priv->fade_timeline, CLUTTER_EASE_OUT_QUAD); g_signal_connect (priv->fade_timeline, "new-frame", G_CALLBACK (mx_label_fade_new_frame_cb), label); g_signal_connect (priv->fade_timeline, "started", G_CALLBACK (mx_label_fade_started_cb), label); g_signal_connect (priv->fade_timeline, "completed", G_CALLBACK (mx_label_fade_completed_cb), label); }