void
meta_compositor_flash_screen (MetaCompositor *compositor,
MetaScreen *screen)
{
ClutterActor *stage;
ClutterActor *flash;
ClutterTransition *transition;
gfloat width, height;
stage = meta_get_stage_for_screen (screen);
clutter_actor_get_size (stage, &width, &height);
flash = clutter_actor_new ();
clutter_actor_set_background_color (flash, CLUTTER_COLOR_Black);
clutter_actor_set_size (flash, width, height);
clutter_actor_set_opacity (flash, 0);
clutter_actor_add_child (stage, flash);
clutter_actor_save_easing_state (flash);
clutter_actor_set_easing_mode (flash, CLUTTER_EASE_IN_QUAD);
clutter_actor_set_easing_duration (flash, FLASH_TIME_MS);
clutter_actor_set_opacity (flash, 192);
transition = clutter_actor_get_transition (flash, "opacity");
clutter_timeline_set_auto_reverse (CLUTTER_TIMELINE (transition), TRUE);
clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (transition), 2);
g_signal_connect (transition, "stopped",
G_CALLBACK (flash_out_completed), flash);
clutter_actor_restore_easing_state (flash);
}
void
meta_compositor_flash_window (MetaCompositor *compositor,
MetaWindow *window)
{
ClutterActor *window_actor =
CLUTTER_ACTOR (meta_window_get_compositor_private (window));
ClutterActor *flash;
ClutterTransition *transition;
flash = clutter_actor_new ();
clutter_actor_set_background_color (flash, CLUTTER_COLOR_Black);
clutter_actor_set_size (flash, window->rect.width, window->rect.height);
clutter_actor_set_position (flash,
window->custom_frame_extents.left,
window->custom_frame_extents.top);
clutter_actor_set_opacity (flash, 0);
clutter_actor_add_child (window_actor, flash);
clutter_actor_save_easing_state (flash);
clutter_actor_set_easing_mode (flash, CLUTTER_EASE_IN_QUAD);
clutter_actor_set_easing_duration (flash, FLASH_TIME_MS);
clutter_actor_set_opacity (flash, 192);
transition = clutter_actor_get_transition (flash, "opacity");
clutter_timeline_set_auto_reverse (CLUTTER_TIMELINE (transition), TRUE);
clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (transition), 2);
g_signal_connect (transition, "stopped",
G_CALLBACK (window_flash_out_completed), flash);
clutter_actor_restore_easing_state (flash);
}
static void
show_helper_text_title (CalibArea *area)
{
ClutterTransition *transition;
gfloat height = clutter_actor_get_height (area->helper_text_title);
clutter_actor_set_y (area->helper_text_title,
- clutter_actor_get_height (area->helper_text_title));
clutter_actor_show (area->helper_text_title);
transition = clutter_property_transition_new ("y");
clutter_timeline_set_progress_mode (CLUTTER_TIMELINE (transition),
CLUTTER_EASE_OUT);
clutter_timeline_set_duration (CLUTTER_TIMELINE (transition),
HELP_TEXT_ANIMATION_DURATION);
clutter_transition_set_animatable (transition,
CLUTTER_ANIMATABLE (area->helper_text_title));
clutter_transition_set_from (transition, G_TYPE_FLOAT, -height);
clutter_transition_set_to (transition, G_TYPE_FLOAT, 0.0);
g_signal_connect (CLUTTER_TIMELINE (transition),
"completed",
G_CALLBACK (on_helper_text_title_shown),
area);
clutter_timeline_start (CLUTTER_TIMELINE (transition));
g_clear_object (&area->helper_msg_timeline);
area->helper_msg_timeline = transition;
}
static ClutterTransition *
create_fade_out_transition()
{
auto transition = clutter_property_transition_new("opacity");
clutter_transition_set_from(transition, G_TYPE_UINT, 255);
clutter_transition_set_to(transition, G_TYPE_UINT, 0);
clutter_timeline_set_duration(CLUTTER_TIMELINE(transition), FADE_DURATION);
clutter_timeline_set_repeat_count(CLUTTER_TIMELINE(transition), 0);
clutter_timeline_set_progress_mode(CLUTTER_TIMELINE(transition), CLUTTER_EASE_IN_OUT_CUBIC);
return transition;
}
static void
fade_transition_frame_cb (OptTransition *trans,
gint frame_num,
gpointer data)
{
OptSlide *from, *to;
OptTransitionPrivate *priv;
gint opacity;
priv = trans->priv;
from = opt_transition_get_from (trans);
to = opt_transition_get_to (trans);
if (frame_num == 1)
{
clutter_actor_show_all (CLUTTER_ACTOR(to));
clutter_actor_raise_top (CLUTTER_ACTOR(to));
}
opacity = (frame_num * 255 )
/ clutter_timeline_get_n_frames (CLUTTER_TIMELINE(trans));
clutter_actor_set_opacity (CLUTTER_ACTOR(to), opacity);
/* clutter_actor_set_depth (CLUTTER_ACTOR(from), - opacity/10 ); */
}
static void
hide_error_message (CalibArea *area)
{
ClutterTransition *transition;
transition = get_error_message_transition (area);
clutter_transition_set_from (transition, G_TYPE_UINT, 255);
clutter_transition_set_to (transition, G_TYPE_UINT, 0);
g_signal_connect (CLUTTER_TIMELINE (transition),
"completed",
G_CALLBACK (on_error_message_transparent),
area);
clutter_timeline_start (CLUTTER_TIMELINE (transition));
g_clear_object (&area->error_msg_timeline);
area->error_msg_timeline = transition;
}
static void
clutter_timeline_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterTimeline *timeline;
ClutterTimelinePrivate *priv;
timeline = CLUTTER_TIMELINE(object);
priv = timeline->priv;
switch (prop_id)
{
case PROP_LOOP:
g_value_set_boolean (value, priv->loop);
break;
case PROP_DELAY:
g_value_set_uint (value, priv->delay);
break;
case PROP_DURATION:
g_value_set_uint (value, clutter_timeline_get_duration (timeline));
break;
case PROP_DIRECTION:
g_value_set_enum (value, priv->direction);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static ClutterTransition *
get_error_message_transition (CalibArea *area)
{
ClutterTransition *transition;
clutter_actor_show (area->error_text);
transition = clutter_property_transition_new ("opacity");
clutter_timeline_set_progress_mode (CLUTTER_TIMELINE (transition),
CLUTTER_EASE_OUT);
clutter_timeline_set_duration (CLUTTER_TIMELINE (transition),
ERROR_MESSAGE_ANIMATION_DURATION);
clutter_transition_set_animatable (transition,
CLUTTER_ANIMATABLE (area->error_text));
clutter_transition_set_from (transition, G_TYPE_UINT, 0);
clutter_transition_set_to (transition, G_TYPE_UINT, 255);
return transition;
}
static gboolean
on_delete_event (GtkWidget *widget,
GdkEvent *event,
CalibArea *area)
{
clutter_timeline_stop (CLUTTER_TIMELINE (area->clock_timeline));
if (area->error_msg_timeline)
clutter_timeline_stop (CLUTTER_TIMELINE (area->error_msg_timeline));
if (area->helper_msg_timeline)
clutter_timeline_stop (CLUTTER_TIMELINE (area->helper_msg_timeline));
gtk_widget_hide (area->window);
(*area->callback) (area, area->user_data);
return TRUE;
}
static gboolean
red_button_press (ClutterActor *actor,
ClutterButtonEvent *event,
gpointer data)
{
GObject *timeline;
g_print ("[*] Pressed `%s'\n", clutter_get_script_id (G_OBJECT (actor)));
timeline = clutter_script_get_object (script, "main-timeline");
g_assert (CLUTTER_IS_TIMELINE (timeline));
if (!clutter_timeline_is_playing (CLUTTER_TIMELINE (timeline)))
clutter_timeline_start (CLUTTER_TIMELINE (timeline));
else
clutter_timeline_pause (CLUTTER_TIMELINE (timeline));
return TRUE;
}
static void
show_error_message (CalibArea *area)
{
ClutterTransition *transition;
clutter_actor_show (area->error_text);
transition = get_error_message_transition (area);
clutter_timeline_start (CLUTTER_TIMELINE (transition));
g_clear_object (&area->error_msg_timeline);
area->error_msg_timeline = transition;
}
static gboolean
key_pressed_cb (ClutterActor *actor,
ClutterEvent *event,
gpointer user_data)
{
ClutterTimeline *timeline = CLUTTER_TIMELINE (user_data);
if (!clutter_timeline_is_playing (timeline))
clutter_timeline_start (timeline);
return TRUE;
}
static void
clutter_timeline_dispose (GObject *object)
{
ClutterTimeline *self = CLUTTER_TIMELINE(object);
ClutterTimelinePrivate *priv;
priv = self->priv;
if (priv->delay_id)
{
g_source_remove (priv->delay_id);
priv->delay_id = 0;
}
G_OBJECT_CLASS (clutter_timeline_parent_class)->dispose (object);
}
static void
zoom_transition_frame_cb (OptTransition *trans,
gint frame_num,
gpointer data)
{
OptSlide *from, *to;
OptTransitionPrivate *priv;
ClutterActor *stage;
gint n_frames = 0;
priv = trans->priv;
from = opt_transition_get_from (trans);
to = opt_transition_get_to (trans);
stage = clutter_stage_get_default();
n_frames = clutter_timeline_get_n_frames (CLUTTER_TIMELINE(trans));
if (frame_num > n_frames/2)
{
clutter_actor_hide (CLUTTER_ACTOR(from));
clutter_actor_show_all (CLUTTER_ACTOR(to));
clutter_actor_set_depth (CLUTTER_ACTOR(to),
-1 * ((n_frames * 2000) - (frame_num * 2000)));
clutter_actor_set_rotation (CLUTTER_ACTOR(to),
CLUTTER_Z_AXIS,
frame_num * ((360*2)/n_frames),
CLUTTER_STAGE_WIDTH()/2,
CLUTTER_STAGE_HEIGHT()/2,
0);
}
else
{
clutter_actor_hide (CLUTTER_ACTOR(to));
clutter_actor_set_depth (CLUTTER_ACTOR(from), -2000 * frame_num);
clutter_actor_set_rotation (CLUTTER_ACTOR(from),
CLUTTER_Z_AXIS,
frame_num * ((360*2)/n_frames),
CLUTTER_STAGE_WIDTH()/2,
CLUTTER_STAGE_HEIGHT()/2,
0);
}
}
static void
page_transition_frame_cb (OptTransition *trans,
gint frame_num,
gpointer data)
{
OptSlide *from, *to;
ClutterActor *stage;
ClutterColor color = { 0x22, 0x22, 0x22, 0xff };
OptTransitionPrivate *priv;
gint mult, n_frames;
priv = trans->priv;
from = opt_transition_get_from (trans);
to = opt_transition_get_to (trans);
stage = clutter_stage_get_default();
clutter_actor_show_all (CLUTTER_ACTOR(to));
mult = priv->direction ? -1 : 1;
n_frames = clutter_timeline_get_n_frames (CLUTTER_TIMELINE(trans));
if (frame_num > n_frames/2)
{
/* Fix Z ordering */
clutter_actor_lower_bottom (CLUTTER_ACTOR(from));
}
clutter_stage_set_color (CLUTTER_STAGE(stage), &color);
clutter_actor_set_rotation (CLUTTER_ACTOR(from),
CLUTTER_Y_AXIS,
- (float)frame_num * 2 * mult,
CLUTTER_STAGE_WIDTH()*3/2,
0,
-1 * (CLUTTER_STAGE_WIDTH()/2));
clutter_actor_set_rotation (CLUTTER_ACTOR(to),
CLUTTER_Y_AXIS,
(mult * 60) - (frame_num * 2 * mult),
CLUTTER_STAGE_WIDTH()*3/2,
0,
-1 * (CLUTTER_STAGE_WIDTH()/2));
}
static void
clutter_timeline_finalize (GObject *object)
{
ClutterTimeline *self = CLUTTER_TIMELINE (object);
ClutterTimelinePrivate *priv = self->priv;
ClutterMasterClock *master_clock;
if (priv->markers_by_name)
g_hash_table_destroy (priv->markers_by_name);
if (priv->is_playing)
{
master_clock = _clutter_master_clock_get_default ();
_clutter_master_clock_remove_timeline (master_clock, self);
}
G_OBJECT_CLASS (clutter_timeline_parent_class)->finalize (object);
}
static gboolean
mouse_moved(CurrentCallView *self)
{
g_return_val_if_fail(IS_CURRENT_CALL_VIEW(self), FALSE);
auto priv = CURRENT_CALL_VIEW_GET_PRIVATE(self);
priv->time_last_mouse_motion = g_get_monotonic_time();
// since the mouse moved, make sure the controls are shown
if (clutter_timeline_get_direction(CLUTTER_TIMELINE(priv->fade_info)) == CLUTTER_TIMELINE_FORWARD) {
clutter_timeline_set_direction(CLUTTER_TIMELINE(priv->fade_info), CLUTTER_TIMELINE_BACKWARD);
clutter_timeline_set_direction(CLUTTER_TIMELINE(priv->fade_controls), CLUTTER_TIMELINE_BACKWARD);
if (!clutter_timeline_is_playing(CLUTTER_TIMELINE(priv->fade_info))) {
clutter_timeline_rewind(CLUTTER_TIMELINE(priv->fade_info));
clutter_timeline_rewind(CLUTTER_TIMELINE(priv->fade_controls));
clutter_timeline_start(CLUTTER_TIMELINE(priv->fade_info));
clutter_timeline_start(CLUTTER_TIMELINE(priv->fade_controls));
}
}
return FALSE; // propogate event
}
static gboolean
timeout_check_last_motion_event(CurrentCallView *self)
{
g_return_val_if_fail(IS_CURRENT_CALL_VIEW(self), G_SOURCE_REMOVE);
auto priv = CURRENT_CALL_VIEW_GET_PRIVATE(self);
auto current_time = g_get_monotonic_time();
if (current_time - priv->time_last_mouse_motion >= CONTROLS_FADE_TIMEOUT) {
// timeout has passed, hide the controls
if (clutter_timeline_get_direction(CLUTTER_TIMELINE(priv->fade_info)) == CLUTTER_TIMELINE_BACKWARD) {
clutter_timeline_set_direction(CLUTTER_TIMELINE(priv->fade_info), CLUTTER_TIMELINE_FORWARD);
clutter_timeline_set_direction(CLUTTER_TIMELINE(priv->fade_controls), CLUTTER_TIMELINE_FORWARD);
if (!clutter_timeline_is_playing(CLUTTER_TIMELINE(priv->fade_info))) {
clutter_timeline_rewind(CLUTTER_TIMELINE(priv->fade_info));
clutter_timeline_rewind(CLUTTER_TIMELINE(priv->fade_controls));
clutter_timeline_start(CLUTTER_TIMELINE(priv->fade_info));
clutter_timeline_start(CLUTTER_TIMELINE(priv->fade_controls));
}
}
}
return G_SOURCE_CONTINUE;
}
static void
current_call_view_init(CurrentCallView *view)
{
gtk_widget_init_template(GTK_WIDGET(view));
CurrentCallViewPrivate *priv = CURRENT_CALL_VIEW_GET_PRIVATE(view);
/* create video widget and overlay the call info and controls on it */
priv->video_widget = video_widget_new();
gtk_container_add(GTK_CONTAINER(priv->frame_video), priv->video_widget);
gtk_widget_show_all(priv->frame_video);
auto stage = gtk_clutter_embed_get_stage(GTK_CLUTTER_EMBED(priv->video_widget));
auto actor_info = gtk_clutter_actor_new_with_contents(priv->hbox_call_info);
auto actor_controls = gtk_clutter_actor_new_with_contents(priv->hbox_call_controls);
clutter_actor_add_child(stage, actor_info);
clutter_actor_set_x_align(actor_info, CLUTTER_ACTOR_ALIGN_FILL);
clutter_actor_set_y_align(actor_info, CLUTTER_ACTOR_ALIGN_START);
clutter_actor_add_child(stage, actor_controls);
clutter_actor_set_x_align(actor_controls, CLUTTER_ACTOR_ALIGN_CENTER);
clutter_actor_set_y_align(actor_controls, CLUTTER_ACTOR_ALIGN_END);
/* add fade in and out states to the info and controls */
priv->time_last_mouse_motion = g_get_monotonic_time();
priv->fade_info = create_fade_out_transition();
priv->fade_controls = create_fade_out_transition();
clutter_actor_add_transition(actor_info, "fade_info", priv->fade_info);
clutter_actor_add_transition(actor_controls, "fade_controls", priv->fade_controls);
clutter_timeline_set_direction(CLUTTER_TIMELINE(priv->fade_info), CLUTTER_TIMELINE_BACKWARD);
clutter_timeline_set_direction(CLUTTER_TIMELINE(priv->fade_controls), CLUTTER_TIMELINE_BACKWARD);
clutter_timeline_stop(CLUTTER_TIMELINE(priv->fade_info));
clutter_timeline_stop(CLUTTER_TIMELINE(priv->fade_controls));
/* have a timer check every 1 second if the controls should fade out */
priv->timer_fade = g_timeout_add(1000, (GSourceFunc)timeout_check_last_motion_event, view);
/* connect to the mouse motion event to reset the last moved time */
g_signal_connect_swapped(priv->video_widget, "motion-notify-event", G_CALLBACK(mouse_moved), view);
g_signal_connect_swapped(priv->video_widget, "button-press-event", G_CALLBACK(mouse_moved), view);
g_signal_connect_swapped(priv->video_widget, "button-release-event", G_CALLBACK(mouse_moved), view);
/* manually handle the focus of the video widget to be able to focus on the call controls */
g_signal_connect(priv->video_widget, "focus", G_CALLBACK(video_widget_focus), view);
/* toggle whether or not the chat is displayed */
g_signal_connect(priv->togglebutton_chat, "toggled", G_CALLBACK(chat_toggled), view);
/* bind the chat orientation to the gsetting */
priv->settings = g_settings_new_full(get_ring_schema(), NULL, NULL);
g_settings_bind_with_mapping(priv->settings, "chat-pane-horizontal",
priv->paned_call, "orientation",
G_SETTINGS_BIND_GET,
map_boolean_to_orientation,
nullptr, nullptr, nullptr);
g_signal_connect(priv->scalebutton_quality, "value-changed", G_CALLBACK(quality_changed), view);
/* customize the quality button scale */
if (auto scale_box = gtk_scale_button_get_box(GTK_SCALE_BUTTON(priv->scalebutton_quality))) {
priv->checkbutton_autoquality = gtk_check_button_new_with_label(C_("Enable automatic video quality", "Auto"));
gtk_widget_show(priv->checkbutton_autoquality);
gtk_box_pack_start(GTK_BOX(scale_box), priv->checkbutton_autoquality, FALSE, TRUE, 0);
g_signal_connect(priv->checkbutton_autoquality, "toggled", G_CALLBACK(autoquality_toggled), view);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->checkbutton_autoquality), TRUE);
}
if (auto scale = gtk_scale_button_get_scale(GTK_SCALE_BUTTON(priv->scalebutton_quality))) {
g_signal_connect(scale, "button-press-event", G_CALLBACK(quality_button_pressed), view);
g_signal_connect(scale, "button-release-event", G_CALLBACK(quality_button_released), view);
}
}
int
main (int argc, char *argv[])
{
ClutterActor *stage, *actor;
ClutterContent *canvas;
ClutterTransition *transition;
/* initialize Clutter */
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return EXIT_FAILURE;
/* create a stage */
stage = clutter_stage_new ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Rectangle with rounded corners");
clutter_actor_set_background_color (stage, CLUTTER_COLOR_Black);
clutter_actor_set_size (stage, 500, 500);
clutter_actor_show (stage);
/* our 2D canvas, courtesy of Cairo */
canvas = clutter_canvas_new ();
clutter_canvas_set_size (CLUTTER_CANVAS (canvas), 300, 300);
/* the actor that will display the contents of the canvas */
actor = clutter_actor_new ();
clutter_actor_set_content (actor, canvas);
clutter_actor_set_content_gravity (actor, CLUTTER_CONTENT_GRAVITY_CENTER);
clutter_actor_set_content_scaling_filters (actor,
CLUTTER_SCALING_FILTER_TRILINEAR,
CLUTTER_SCALING_FILTER_LINEAR);
clutter_actor_set_pivot_point (actor, 0.5f, 0.5f);
clutter_actor_add_constraint (actor, clutter_align_constraint_new (stage, CLUTTER_ALIGN_BOTH, 0.5));
clutter_actor_set_request_mode (actor, CLUTTER_REQUEST_CONTENT_SIZE);
clutter_actor_add_child (stage, actor);
/* the actor now owns the canvas */
g_object_unref (canvas);
/* create the continuous animation of the actor spinning around its center */
transition = clutter_property_transition_new ("rotation-angle-y");
clutter_transition_set_from (transition, G_TYPE_DOUBLE, 0.0);
clutter_transition_set_to (transition, G_TYPE_DOUBLE, 360.0);
clutter_timeline_set_duration (CLUTTER_TIMELINE (transition), 2000);
clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (transition), -1);
clutter_actor_add_transition (actor, "rotateActor", transition);
/* the actor now owns the transition */
g_object_unref (transition);
/* quit on destroy */
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
/* connect our drawing code */
g_signal_connect (canvas, "draw", G_CALLBACK (draw_content), NULL);
/* invalidate the canvas, so that we can draw before the main loop starts */
clutter_content_invalidate (canvas);
clutter_main ();
return EXIT_SUCCESS;
}
static gboolean
on_button_press_event(ClutterActor *actor,
ClutterButtonEvent *event,
CalibArea *area)
{
gint num_clicks;
gboolean success;
if (area->success)
return FALSE;
if (event->click_count > 1)
return FALSE;
/* Check matching device ID if a device ID was provided */
if (area->device_id > -1)
{
ClutterInputDevice *device;
device = clutter_event_get_source_device ((ClutterEvent *) event);
if (device != NULL && clutter_input_device_get_device_id (device) != area->device_id) {
char *name;
g_object_get (G_OBJECT (device), "name", &name, NULL);
g_debug ("Ignoring input from device %s (%d)",
name,
clutter_input_device_get_device_id (device));
g_free (name);
return FALSE;
}
}
/* Handle click */
clutter_timeline_stop (CLUTTER_TIMELINE (area->clock_timeline));
clutter_timeline_start (CLUTTER_TIMELINE (area->clock_timeline));
success = add_click(&area->calibrator,
(int) event->x,
(int) event->y);
num_clicks = area->calibrator.num_clicks;
if (!success && num_clicks == 0)
show_error_message (area);
else
{
gboolean visible;
g_object_get (area->error_text, "visible", &visible, NULL);
if (visible)
hide_error_message (area);
}
/* Are we done yet? */
if (num_clicks >= 4)
{
set_calibration_status (area);
return FALSE;
}
cc_target_actor_move_center (CC_TARGET_ACTOR (area->target),
area->X[num_clicks],
area->Y[num_clicks]);
return FALSE;
}
void
opt_show_step (OptShow *self, gint step)
{
OptSlide *from, *to;
OptShowPrivate *priv;
OptTransition *trans;
ClutterActor *stage;
priv = self->priv;
/* transition already running */
if (priv->trans_signal_id != 0)
return;
stage = clutter_stage_get_default();
from = g_list_nth_data (priv->slides, priv->current_slide_num);
to = g_list_nth_data (priv->slides, priv->current_slide_num + step);
if (from == NULL)
from = priv->slides->data;
/* Nowhere to go */
if (to == NULL)
return;
/* Add next slide to stage */
clutter_group_add (CLUTTER_GROUP(stage), CLUTTER_ACTOR(to));
trans = opt_slide_get_transition ( step < 0 ? to : from);
/*
* Make sure any textures are loaded before the transitions is started .
*/
clutter_container_foreach (CLUTTER_CONTAINER (to),
(ClutterCallback)clutter_actor_realize,
NULL);
if (trans != NULL)
{
if (step < 0)
opt_transition_set_direction (trans, OPT_TRANSITION_BACKWARD);
else
opt_transition_set_direction (trans, OPT_TRANSITION_FORWARD);
/* Set up transition and start it */
opt_transition_set_to (trans, to);
opt_transition_set_from (trans, from);
priv->trans_signal_id
= g_signal_connect (trans,
"completed",
G_CALLBACK (transition_completed_cb),
self);
/* lower it out of view */
clutter_actor_lower_bottom (CLUTTER_ACTOR(to));
clutter_timeline_start (CLUTTER_TIMELINE(trans));
}
else
{
/* No transition just hide current slide*/
clutter_group_remove (CLUTTER_GROUP(stage), CLUTTER_ACTOR(from));
clutter_actor_hide_all (CLUTTER_ACTOR(from));
}
/* Advance */
priv->current_slide_num += step;
priv->current_slide_num =
CLAMP(priv->current_slide_num, 0, priv->num_slides-1);
if (CLUTTER_ACTOR_IS_VISIBLE (CLUTTER_ACTOR (priv->menu)))
opt_menu_popdown (priv->menu);
opt_menu_set_current_slide (priv->menu, priv->current_slide_num);
}
G_MODULE_EXPORT int
test_keyframe_transition_main (int argc, char *argv[])
{
ClutterActor *stage;
int i;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return EXIT_FAILURE;
stage = clutter_stage_new ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Keyframe Transitions");
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
for (i = 0; i < 3; i++)
{
ClutterTransition *transition, *group;
ClutterActor *rect;
float cur_x, cur_y;
float new_x, new_y;
gchar *name;
cur_x = PADDING;
cur_y = PADDING + ((SIZE + PADDING) * i);
new_x = clutter_actor_get_width (stage) - PADDING - SIZE;
new_y = g_random_double_range (PADDING, clutter_actor_get_height (stage) - PADDING - SIZE);
name = g_strdup_printf ("rect%02d", i);
rect = clutter_actor_new ();
clutter_actor_set_name (rect, name);
clutter_actor_set_background_color (rect, &colors[i]);
clutter_actor_set_size (rect, SIZE, SIZE);
clutter_actor_set_position (rect, PADDING, cur_y);
clutter_actor_add_child (stage, rect);
group = clutter_transition_group_new ();
clutter_timeline_set_duration (CLUTTER_TIMELINE (group), 2000);
clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (group), 1);
clutter_timeline_set_auto_reverse (CLUTTER_TIMELINE (group), TRUE);
transition = clutter_keyframe_transition_new ("x");
clutter_transition_set_from (transition, G_TYPE_FLOAT, cur_x);
clutter_transition_set_to (transition, G_TYPE_FLOAT, new_x);
clutter_keyframe_transition_set (CLUTTER_KEYFRAME_TRANSITION (transition),
G_TYPE_FLOAT, 1,
0.5, new_x / 2.0f, CLUTTER_EASE_OUT_EXPO);
clutter_transition_group_add_transition (CLUTTER_TRANSITION_GROUP (group), transition);
g_object_unref (transition);
transition = clutter_keyframe_transition_new ("y");
clutter_transition_set_from (transition, G_TYPE_FLOAT, cur_y);
clutter_transition_set_to (transition, G_TYPE_FLOAT, cur_y);
clutter_keyframe_transition_set (CLUTTER_KEYFRAME_TRANSITION (transition),
G_TYPE_FLOAT, 1,
0.5, new_y, CLUTTER_EASE_OUT_EXPO);
clutter_transition_group_add_transition (CLUTTER_TRANSITION_GROUP (group), transition);
g_object_unref (transition);
clutter_actor_add_transition (rect, "rectAnimation", group);
g_signal_connect (rect, "transition-stopped",
G_CALLBACK (on_transition_stopped),
NULL);
g_object_unref (group);
g_free (name);
}
clutter_actor_show (stage);
clutter_main ();
return EXIT_SUCCESS;
}
static void
set_up_stage (CalibArea *calib_area, ClutterActor *stage)
{
ClutterPoint anchor;
ClutterColor color;
ClutterContent *success_content;
gfloat height;
gchar *markup;
calib_area->stage = stage;
calib_area->action_layer = clutter_actor_new ();
calib_area->clock = cc_clock_actor_new ();
calib_area->target = cc_target_actor_new ();
calib_area->text_title_holder = clutter_actor_new ();
calib_area->helper_text_title = clutter_text_new ();
calib_area->text_body_holder = clutter_actor_new ();
calib_area->helper_text_body = clutter_text_new ();
calib_area->error_text = clutter_text_new ();
calib_area->success_image = clutter_actor_new ();
clutter_stage_set_use_alpha (CLUTTER_STAGE (stage), TRUE);
clutter_actor_hide (calib_area->target);
/* bind the action layer's geometry to the stage's */
clutter_actor_add_constraint (calib_area->action_layer,
clutter_bind_constraint_new (stage,
CLUTTER_BIND_SIZE,
0));
clutter_actor_add_child (stage, calib_area->action_layer);
g_signal_connect (stage,
"allocation-changed",
G_CALLBACK (on_allocation_changed),
calib_area);
clutter_color_from_string (&color, "#000");
color.alpha = WINDOW_OPACITY * 255;
clutter_actor_set_background_color (stage, &color);
clutter_actor_add_child (calib_area->action_layer, calib_area->clock);
clutter_actor_add_constraint (calib_area->clock,
clutter_align_constraint_new (stage,
CLUTTER_ALIGN_BOTH,
0.5));
clutter_actor_add_child (calib_area->action_layer, calib_area->target);
/* set the helper text */
anchor.x = 0;
g_object_set (calib_area->text_title_holder, "pivot-point", &anchor, NULL);
clutter_actor_add_child (calib_area->action_layer,
calib_area->text_title_holder);
clutter_actor_add_child (calib_area->text_title_holder,
calib_area->helper_text_title);
height = clutter_actor_get_height (calib_area->clock);
clutter_actor_add_constraint (calib_area->text_title_holder,
clutter_bind_constraint_new (calib_area->clock,
CLUTTER_BIND_Y,
height * 1.5));
clutter_actor_add_constraint (calib_area->text_title_holder,
clutter_align_constraint_new (stage,
CLUTTER_ALIGN_X_AXIS,
.5));
clutter_text_set_line_alignment (CLUTTER_TEXT (calib_area->helper_text_title),
PANGO_ALIGN_CENTER);
color.red = COLOR_GRAY;
color.green = COLOR_GRAY;
color.blue = COLOR_GRAY;
color.alpha = 255;
markup = g_strdup_printf ("<big><b>%s</b></big>",
_(HELP_TEXT_TITLE));
clutter_text_set_markup (CLUTTER_TEXT (calib_area->helper_text_title), markup);
clutter_text_set_color (CLUTTER_TEXT (calib_area->helper_text_title), &color);
g_free (markup);
g_object_set (calib_area->text_body_holder, "pivot-point", &anchor, NULL);
clutter_actor_add_child (calib_area->action_layer,
calib_area->text_body_holder);
clutter_actor_add_child (calib_area->text_body_holder,
calib_area->helper_text_body);
height = clutter_actor_get_height (calib_area->helper_text_title);
clutter_actor_add_constraint (calib_area->text_body_holder,
clutter_bind_constraint_new (calib_area->text_title_holder,
CLUTTER_BIND_Y,
height * 1.2));
clutter_actor_add_constraint (calib_area->text_body_holder,
clutter_align_constraint_new (stage,
CLUTTER_ALIGN_X_AXIS,
.5));
clutter_text_set_line_alignment (CLUTTER_TEXT (calib_area->helper_text_body),
PANGO_ALIGN_CENTER);
markup = g_strdup_printf ("<span foreground=\"white\"><big>%s</big></span>",
_(HELP_TEXT_MAIN));
clutter_text_set_markup (CLUTTER_TEXT (calib_area->helper_text_body), markup);
g_free (markup);
/* set the error text */
g_object_set (calib_area->error_text, "pivot-point", &anchor, NULL);
clutter_actor_add_child (calib_area->action_layer, calib_area->error_text);
height = clutter_actor_get_height (calib_area->helper_text_body);
clutter_actor_add_constraint (calib_area->error_text,
clutter_bind_constraint_new (calib_area->text_title_holder,
CLUTTER_BIND_Y,
height * 3));
clutter_actor_add_constraint (calib_area->error_text,
clutter_align_constraint_new (stage,
CLUTTER_ALIGN_X_AXIS,
.5));
clutter_text_set_line_alignment (CLUTTER_TEXT (calib_area->error_text),
PANGO_ALIGN_CENTER);
markup = g_strdup_printf ("<span foreground=\"white\"><big>"
"<b>%s</b></big></span>",
ERROR_MESSAGE);
clutter_text_set_markup (CLUTTER_TEXT (calib_area->error_text), markup);
g_free (markup);
clutter_actor_hide (calib_area->error_text);
/* configure success image */
success_content = clutter_image_new ();
clutter_actor_set_content (calib_area->success_image,
success_content);
g_object_unref (success_content);
clutter_actor_add_child (stage, calib_area->success_image);
clutter_actor_add_constraint (calib_area->success_image,
clutter_align_constraint_new (stage,
CLUTTER_ALIGN_BOTH,
.5));
/* animate clock */
calib_area->clock_timeline = clutter_property_transition_new ("angle");
clutter_timeline_set_progress_mode (CLUTTER_TIMELINE (calib_area->clock_timeline),
CLUTTER_LINEAR);
clutter_timeline_set_duration (CLUTTER_TIMELINE (calib_area->clock_timeline),
MAX_TIME);
clutter_transition_set_animatable (calib_area->clock_timeline,
CLUTTER_ANIMATABLE (calib_area->clock));
clutter_transition_set_from (calib_area->clock_timeline, G_TYPE_FLOAT, .0);
clutter_transition_set_to (calib_area->clock_timeline, G_TYPE_FLOAT, 360.0);
clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (calib_area->clock_timeline),
-1);
clutter_timeline_start (CLUTTER_TIMELINE (calib_area->clock_timeline));
g_signal_connect (CLUTTER_TIMELINE (calib_area->clock_timeline),
"completed",
G_CALLBACK (on_timeout),
calib_area);
g_signal_connect (stage,
"button-press-event",
G_CALLBACK (on_button_press_event),
calib_area);
g_signal_connect (stage,
"key-release-event",
G_CALLBACK (on_key_release_event),
calib_area);
}
