static void
gml_gtk_widget_create_rect (ClutterActor *parent, JsonObject *obj)
{
GList *l = NULL;
GList *p = NULL;
ClutterColor color = { 0x00, 0x00, 0x00, 0xff };
ClutterActor *rect = clutter_rectangle_new ();
l = json_object_get_members (obj);
for (p = l; p; p = p->next) {
if (!strcmp (p->data, "width")) {
clutter_actor_set_width (rect, (float)json_object_get_int_member (obj, p->data));
} else if (!strcmp (p->data, "height")) {
clutter_actor_set_height (rect, (float)json_object_get_int_member (obj, p->data));
} else if (!strcmp (p->data, "x")) {
clutter_actor_set_x (rect, (float)json_object_get_int_member (obj, p->data));
} else if (!strcmp (p->data, "y")) {
clutter_actor_set_y (rect, (float)json_object_get_int_member (obj, p->data));
} else if (!strcmp (p->data, "color")) {
clutter_color_from_string (&(color), json_object_get_string_member (obj, p->data));
clutter_rectangle_set_color (CLUTTER_RECTANGLE (rect), &color);
} else if (!strcmp (p->data, "border.width")) {
clutter_rectangle_set_border_width (CLUTTER_RECTANGLE (rect), json_object_get_int_member (obj, p->data));
} else if (!strcmp (p->data, "border.color")) {
clutter_color_from_string (&(color), json_object_get_string_member (obj, p->data));
clutter_rectangle_set_border_color (CLUTTER_RECTANGLE (rect), &color);
}
}
clutter_container_add_actor (CLUTTER_CONTAINER (parent), rect);
}
static void
on_drag_begin (ClutterDragAction *action,
ClutterActor *actor,
gfloat event_x,
gfloat event_y,
ClutterModifierType modifiers)
{
gboolean is_copy = (modifiers & CLUTTER_SHIFT_MASK) ? TRUE : FALSE;
ClutterActor *drag_handle = NULL;
if (is_copy)
{
ClutterActor *stage = clutter_actor_get_stage (actor);
drag_handle = clutter_rectangle_new ();
clutter_actor_set_size (drag_handle, 48, 48);
clutter_rectangle_set_color (CLUTTER_RECTANGLE (drag_handle),
CLUTTER_COLOR_DarkSkyBlue);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), drag_handle);
clutter_actor_set_position (drag_handle, event_x, event_y);
}
else
drag_handle = actor;
clutter_drag_action_set_drag_handle (action, drag_handle);
/* fully desaturate the actor */
clutter_actor_animate (actor, CLUTTER_LINEAR, 150,
"@effects.disable.factor", 1.0,
NULL);
}
void
test_realized (TestConformSimpleFixture *fixture,
gconstpointer data)
{
ClutterActor *actor;
ClutterActor *stage;
stage = clutter_stage_get_default ();
actor = clutter_rectangle_new ();
g_assert (!(CLUTTER_ACTOR_IS_REALIZED (actor)));
clutter_actor_hide (actor); /* don't show, so won't map */
clutter_container_add_actor (CLUTTER_CONTAINER (stage),
actor);
clutter_actor_realize (actor);
g_assert (CLUTTER_ACTOR_IS_REALIZED (actor));
g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor)));
g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (actor)));
clutter_actor_destroy (actor);
}
void
test_clone_no_map (TestConformSimpleFixture *fixture,
gconstpointer data)
{
ClutterActor *stage;
ClutterActor *group;
ClutterActor *actor;
ClutterActor *clone;
stage = clutter_stage_get_default ();
group = clutter_group_new ();
actor = clutter_rectangle_new ();
clutter_actor_hide (group);
clutter_container_add_actor (CLUTTER_CONTAINER (group), actor);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), group);
g_assert (!(CLUTTER_ACTOR_IS_MAPPED (group)));
g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor)));
clone = clutter_clone_new (group);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), clone);
g_assert (CLUTTER_ACTOR_IS_MAPPED (clone));
g_assert (!(CLUTTER_ACTOR_IS_MAPPED (group)));
g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor)));
clutter_actor_destroy (CLUTTER_ACTOR (clone));
clutter_actor_destroy (CLUTTER_ACTOR (group));
}
G_MODULE_EXPORT int
test_drag_main (int argc, char *argv[])
{
ClutterActor *stage, *handle;
ClutterAction *action;
GError *error;
error = NULL;
clutter_init_with_args (&argc, &argv,
"test-drag",
entries,
NULL,
&error);
if (error != NULL)
{
g_print ("Unable to run test-drag: %s\n", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
stage = clutter_stage_new ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Drag Test");
clutter_actor_set_size (stage, 800, 600);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
handle = clutter_rectangle_new ();
clutter_rectangle_set_color (CLUTTER_RECTANGLE (handle),
CLUTTER_COLOR_SkyBlue);
clutter_actor_set_size (handle, 128, 128);
clutter_actor_set_position (handle, (800 - 128) / 2, (600 - 128) / 2);
clutter_actor_set_reactive (handle, TRUE);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), handle);
g_signal_connect (handle, "enter-event", G_CALLBACK (on_enter), NULL);
g_signal_connect (handle, "leave-event", G_CALLBACK (on_leave), NULL);
action = clutter_drag_action_new ();
clutter_drag_action_set_drag_threshold (CLUTTER_DRAG_ACTION (action),
x_drag_threshold,
y_drag_threshold);
clutter_drag_action_set_drag_axis (CLUTTER_DRAG_ACTION (action),
get_drag_axis (drag_axis));
g_signal_connect (action, "drag-begin", G_CALLBACK (on_drag_begin), NULL);
g_signal_connect (action, "drag-end", G_CALLBACK (on_drag_end), NULL);
clutter_actor_add_action (handle, action);
clutter_actor_add_effect_with_name (handle, "disable", clutter_desaturate_effect_new (0.0));
clutter_actor_add_effect_with_name (handle, "curl", clutter_page_turn_effect_new (0.0, 45.0, 12.0));
clutter_actor_show (stage);
clutter_main ();
return EXIT_SUCCESS;
}
G_MODULE_EXPORT int
test_clip_main (int argc, char **argv)
{
CallbackData data;
ClutterActor *stub_actor, *label;
gchar *file;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
data.current_clip.type = CLIP_NONE;
data.clips = NULL;
data.stage = clutter_stage_new ();
clutter_stage_set_title (CLUTTER_STAGE (data.stage), "Clipping");
g_signal_connect (data.stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
stub_actor = clutter_rectangle_new ();
clutter_container_add (CLUTTER_CONTAINER (data.stage), stub_actor, NULL);
file = g_build_filename (TESTS_DATADIR, "redhand.png", NULL);
data.hand = cogl_texture_new_from_file (file,
COGL_TEXTURE_NONE,
COGL_PIXEL_FORMAT_ANY,
NULL);
g_free (file);
label = clutter_text_new_with_text ("Sans 12px", instructions);
clutter_text_set_line_wrap (CLUTTER_TEXT (label), TRUE);
clutter_actor_set_width (label, clutter_actor_get_width (data.stage) - 310);
clutter_actor_set_y (label,
clutter_actor_get_height (data.stage)
- clutter_actor_get_height (label));
clutter_container_add (CLUTTER_CONTAINER (data.stage), label, NULL);
g_signal_connect (stub_actor, "paint", G_CALLBACK (on_paint), &data);
g_signal_connect (data.stage, "button-press-event",
G_CALLBACK (on_button_press), &data);
g_signal_connect (data.stage, "button-release-event",
G_CALLBACK (on_button_release), &data);
g_signal_connect (data.stage, "motion-event",
G_CALLBACK (on_motion), &data);
g_signal_connect (data.stage, "key-press-event",
G_CALLBACK (on_key_press), &data);
clutter_actor_show (data.stage);
clutter_main ();
cogl_handle_unref (data.hand);
free_clips (&data);
return 0;
}
void
test_initial_state (TestConformSimpleFixture *fixture,
gconstpointer data)
{
ClutterActor *actor;
actor = clutter_rectangle_new ();
g_assert (!(CLUTTER_ACTOR_IS_REALIZED (actor)));
g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor)));
g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (actor)));
clutter_actor_destroy (actor);
}
static void
add_color_prop_base (ClutterActor *table,
const char *name,
ColorProp *prop,
const ClutterColor *value)
{
int table_y = mx_table_get_row_count (MX_TABLE (table));
ClutterActor *label;
static const char *color_names[] = { "red", "green", "blue" };
int i;
label = mx_label_new_with_text (name);
mx_table_add_actor (MX_TABLE (table), label, table_y, 0);
prop->rect = clutter_rectangle_new ();
clutter_rectangle_set_color (CLUTTER_RECTANGLE (prop->rect), value);
clutter_actor_set_size (prop->rect, 20, 0);
mx_table_add_actor (MX_TABLE (table), prop->rect, table_y++, 1);
for (i = 0; i < G_N_ELEMENTS (color_names); i++)
{
ClutterActor *slider;
char *label_name = g_strconcat (name, " ", color_names[i], NULL);
ColorPropComp *prop_comp = g_slice_new (ColorPropComp);
label = mx_label_new_with_text (label_name);
mx_table_add_actor (MX_TABLE (table), label, table_y, 0);
g_free (label_name);
slider = mx_slider_new ();
mx_table_add_actor (MX_TABLE (table), slider, table_y, 1);
mx_slider_set_value (MX_SLIDER (slider),
((guint8 *) value)[i] / 255.0f);
prop_comp->comp_num = i;
prop_comp->prop = prop;
prop_comp->label = mx_label_new ();
mx_table_add_actor (MX_TABLE (table), prop_comp->label, table_y, 2);
update_prop_comp_label (prop_comp, ((guint8 *) value)[i]);
g_signal_connect_data (slider, "notify::value",
G_CALLBACK (color_prop_value_cb),
prop_comp,
(GClosureNotify) color_prop_comp_free,
0);
table_y++;
}
}
void
test_map_recursive (TestConformSimpleFixture *fixture,
gconstpointer data)
{
ClutterActor *actor, *group;
ClutterActor *stage;
stage = clutter_stage_get_default ();
group = clutter_group_new ();
actor = clutter_rectangle_new ();
clutter_actor_hide (group); /* hide at first */
clutter_actor_show (actor); /* show at first */
g_assert (!(CLUTTER_ACTOR_IS_REALIZED (group)));
g_assert (!(CLUTTER_ACTOR_IS_REALIZED (actor)));
g_assert (!(CLUTTER_ACTOR_IS_MAPPED (group)));
g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor)));
g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (group)));
g_assert ((CLUTTER_ACTOR_IS_VISIBLE (actor)));
clutter_container_add_actor (CLUTTER_CONTAINER (stage),
group);
clutter_container_add_actor (CLUTTER_CONTAINER (group),
actor);
g_assert (!(CLUTTER_ACTOR_IS_REALIZED (group)));
g_assert (!(CLUTTER_ACTOR_IS_REALIZED (actor)));
g_assert (!(CLUTTER_ACTOR_IS_MAPPED (group)));
g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor)));
g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (group)));
g_assert ((CLUTTER_ACTOR_IS_VISIBLE (actor)));
/* show group, which should map and realize both
* group and child.
*/
clutter_actor_show (group);
g_assert (CLUTTER_ACTOR_IS_REALIZED (group));
g_assert (CLUTTER_ACTOR_IS_REALIZED (actor));
g_assert (CLUTTER_ACTOR_IS_MAPPED (group));
g_assert (CLUTTER_ACTOR_IS_MAPPED (actor));
g_assert (CLUTTER_ACTOR_IS_VISIBLE (group));
g_assert (CLUTTER_ACTOR_IS_VISIBLE (actor));
clutter_actor_destroy (group);
}
static
gboolean
action_add_rectangle (ClutterActor *action,
ClutterEvent *event,
gpointer userdata)
{
ClutterActor *group = CLUTTER_ACTOR (userdata);
ClutterActor *box;
box = clutter_rectangle_new ();
clutter_actor_set_size (box, 100, 100);
clutter_actor_set_position (box, event->button.x, event->button.y);
clutter_group_add (CLUTTER_GROUP (group), box);
return FALSE;
}
void
test_shown_not_parented (TestConformSimpleFixture *fixture,
gconstpointer data)
{
ClutterActor *actor;
actor = clutter_rectangle_new ();
clutter_actor_show (actor);
g_assert (!CLUTTER_ACTOR_IS_REALIZED (actor));
g_assert (!CLUTTER_ACTOR_IS_MAPPED (actor));
g_assert (CLUTTER_ACTOR_IS_VISIBLE (actor));
clutter_actor_destroy (actor);
}
void
test_show_on_set_parent (TestConformSimpleFixture *fixture,
gconstpointer data)
{
ClutterActor *actor, *group;
gboolean show_on_set_parent;
ClutterActor *stage;
stage = clutter_stage_get_default ();
group = clutter_group_new ();
g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (group)));
clutter_container_add_actor (CLUTTER_CONTAINER (stage),
group);
actor = clutter_rectangle_new ();
g_object_get (G_OBJECT (actor),
"show-on-set-parent", &show_on_set_parent,
NULL);
g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (actor)));
g_assert (show_on_set_parent == TRUE);
clutter_group_add (group, actor);
g_object_get (G_OBJECT (actor),
"show-on-set-parent", &show_on_set_parent,
NULL);
g_assert (CLUTTER_ACTOR_IS_VISIBLE (actor));
g_assert (show_on_set_parent == TRUE);
g_object_ref (actor);
clutter_actor_unparent (actor);
g_object_get (G_OBJECT (actor),
"show-on-set-parent", &show_on_set_parent,
NULL);
g_assert (!CLUTTER_ACTOR_IS_REALIZED (actor));
g_assert (!CLUTTER_ACTOR_IS_MAPPED (actor));
g_assert (CLUTTER_ACTOR_IS_VISIBLE (actor));
g_assert (show_on_set_parent == TRUE);
clutter_actor_destroy (actor);
clutter_actor_destroy (group);
}
static void
droppable_group_init (DroppableGroup *group)
{
clutter_actor_set_opacity (CLUTTER_ACTOR (group), 128);
group->background = clutter_rectangle_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (group),
group->background);
clutter_rectangle_set_color (CLUTTER_RECTANGLE (group->background),
&default_background_color);
clutter_actor_set_size (group->background, 200, 200);
g_signal_connect (group, "actor-added",
G_CALLBACK (on_actor_added), NULL);
}
static void
glide_theme_preview_actor_add_border (GlideThemePreviewActor *preview)
{
ClutterActor *border = clutter_rectangle_new();
ClutterColor trans = {0x00,0x00,0x00,0x00};
ClutterColor grey = {0xdf,0xdf,0xdf,0xcc};
clutter_rectangle_set_color (CLUTTER_RECTANGLE (border), &trans);
clutter_rectangle_set_border_color (CLUTTER_RECTANGLE (border), &grey);
clutter_rectangle_set_border_width (CLUTTER_RECTANGLE (border), 2);
clutter_actor_set_size (border, 160, 120);
clutter_actor_set_position (border, 0, 0);
preview->priv->border = (ClutterActor *)g_object_ref ((GObject *)border);
}
static void
add_static_box (ClutterActor *group,
gint x,
gint y,
gint width,
gint height)
{
ClutterActor *box;
box = clutter_rectangle_new ();
clutter_actor_set_size (box, width, height);
clutter_actor_set_position (box, x, y);
clutter_group_add (CLUTTER_GROUP (group), box);
clutter_container_child_set (CLUTTER_CONTAINER (group), box,
"mode", CLUTTER_BOX2D_STATIC, NULL);
}
void
test_realize_not_recursive (TestConformSimpleFixture *fixture,
gconstpointer data)
{
ClutterActor *actor, *group;
ClutterActor *stage;
stage = clutter_stage_get_default ();
group = clutter_group_new ();
actor = clutter_rectangle_new ();
clutter_actor_hide (group); /* don't show, so won't map */
clutter_actor_hide (actor); /* don't show, so won't map */
g_assert (!(CLUTTER_ACTOR_IS_REALIZED (group)));
g_assert (!(CLUTTER_ACTOR_IS_REALIZED (actor)));
clutter_container_add_actor (CLUTTER_CONTAINER (stage),
group);
clutter_container_add_actor (CLUTTER_CONTAINER (group),
actor);
clutter_actor_realize (group);
g_assert (CLUTTER_ACTOR_IS_REALIZED (group));
g_assert (!(CLUTTER_ACTOR_IS_MAPPED (group)));
g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (group)));
/* realizing group did not realize the child */
g_assert (!CLUTTER_ACTOR_IS_REALIZED (actor));
g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor)));
g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (actor)));
clutter_actor_destroy (group);
}
static void ease_selection_rectangle_make (EaseSelectionRectangle* self, ClutterRectangle** rect) {
#line 190 "ease-selection-rectangle.c"
ClutterRectangle* _tmp0_;
ClutterColor _tmp1_;
ClutterColor _tmp2_;
#line 65 "ease-selection-rectangle.vala"
g_return_if_fail (self != NULL);
#line 196 "ease-selection-rectangle.c"
if (rect != NULL) {
*rect = NULL;
}
#line 67 "ease-selection-rectangle.vala"
*rect = (_tmp0_ = g_object_ref_sink ((ClutterRectangle*) clutter_rectangle_new ()), _g_object_unref0 (*rect), _tmp0_);
#line 68 "ease-selection-rectangle.vala"
clutter_rectangle_set_color (*rect, (_tmp1_ = EASE_SELECTION_RECTANGLE_INNER_COLOR, &_tmp1_));
#line 69 "ease-selection-rectangle.vala"
clutter_rectangle_set_border_color (*rect, (_tmp2_ = EASE_SELECTION_RECTANGLE_OUTER_COLOR, &_tmp2_));
#line 70 "ease-selection-rectangle.vala"
clutter_rectangle_set_border_width (*rect, (guint) EASE_SELECTION_RECTANGLE_BORDER);
#line 71 "ease-selection-rectangle.vala"
clutter_container_add_actor ((ClutterContainer*) self, (ClutterActor*) (*rect));
#line 210 "ease-selection-rectangle.c"
}
static ClutterActor *
create_source (void)
{
int x, y;
ClutterActor *group = clutter_group_new ();
/* Create a group with a different coloured rectangle at each
corner */
for (y = 0; y < SOURCE_DIVISIONS_Y; y++)
for (x = 0; x < SOURCE_DIVISIONS_X; x++)
{
ClutterActor *rect = clutter_rectangle_new ();
clutter_actor_set_size (rect, DIVISION_WIDTH, DIVISION_HEIGHT);
clutter_actor_set_position (rect,
DIVISION_WIDTH * x,
DIVISION_HEIGHT * y);
clutter_rectangle_set_color (CLUTTER_RECTANGLE (rect),
corner_colors +
(y * SOURCE_DIVISIONS_X + x));
clutter_container_add (CLUTTER_CONTAINER (group), rect, NULL);
}
return group;
}
G_MODULE_EXPORT int
test_behave_main (int argc, char *argv[])
{
ClutterTimeline *timeline;
ClutterAlpha *alpha;
ClutterBehaviour *o_behave, *p_behave;
ClutterActor *stage;
ClutterActor *group, *rect, *hand;
ClutterColor stage_color = { 0xcc, 0xcc, 0xcc, 0xff };
ClutterColor rect_bg_color = { 0x33, 0x22, 0x22, 0xff };
ClutterColor rect_border_color = { 0, 0, 0, 0 };
int i;
path_t path_type = PATH_POLY;
const char *knots_poly = ("M 0, 0 L 0, 300 L 300, 300 "
"L 300, 0 L 0, 0");
/* A spiral created with inkscake */
const char *knots_bspline =
"M 34.285713,35.219326 "
"C 44.026891,43.384723 28.084874,52.378758 20.714286,51.409804 "
"C 0.7404474,48.783999 -4.6171866,23.967448 1.904757,8.0764719 "
"C 13.570984,-20.348756 49.798303,-26.746504 74.999994,-13.352108 "
"C 111.98449,6.3047056 119.56591,55.259271 99.047626,89.505034 "
"C 71.699974,135.14925 9.6251774,143.91924 -33.571422,116.17172 "
"C -87.929934,81.254291 -97.88804,5.8941057 -62.857155,-46.209236 "
"C -20.430061,-109.31336 68.300385,-120.45954 129.2857,-78.114021 "
"C 201.15479,-28.21129 213.48932,73.938876 163.80954,143.79074 "
"C 106.45226,224.43749 -9.1490153,237.96076 -87.85713,180.93363 "
"C -177.29029,116.13577 -192.00272,-12.937817 -127.61907,-100.49494 "
"C -55.390344,-198.72081 87.170553,-214.62275 183.57141,-142.87593 "
"C 290.59464,-63.223369 307.68641,92.835839 228.57145,198.07645";
for (i = 0; i < argc; ++i)
{
if (!strncmp (argv[i], "--path", 6))
{
if (!strncmp (argv[i] + 7, "poly", 4))
path_type = PATH_POLY;
else if (!strncmp (argv[i] + 7, "bspline", 7))
path_type = PATH_BSPLINE;
else if (!strncmp (argv[i] + 7, "ellipse", 7))
path_type = PATH_ELLIPSE;
}
else if (!strncmp (argv[i], "--help", 6))
{
printf ("behave [--path=poly|ellipse|bspline]\n");
exit (0);
}
}
clutter_init (&argc, &argv);
stage = clutter_stage_get_default ();
clutter_stage_hide_cursor (CLUTTER_STAGE (stage));
g_signal_connect (stage, "button-press-event",
G_CALLBACK (button_press_cb),
NULL);
g_signal_connect (stage, "scroll-event",
G_CALLBACK (scroll_event_cb),
NULL);
g_signal_connect (stage, "key-press-event",
G_CALLBACK (clutter_main_quit),
NULL);
clutter_stage_set_color (CLUTTER_STAGE (stage),
&stage_color);
/* Make a hand */
group = clutter_group_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (stage), group);
clutter_actor_show (group);
hand = clutter_texture_new_from_file ("redhand.png", NULL);
if (hand == NULL)
{
g_error("pixbuf load failed");
return 1;
}
clutter_actor_set_position (hand, 0, 0);
clutter_actor_show (hand);
rect = clutter_rectangle_new ();
clutter_actor_set_position (rect, 0, 0);
clutter_actor_set_size (rect,
clutter_actor_get_width (hand),
clutter_actor_get_height (hand));
clutter_rectangle_set_color (CLUTTER_RECTANGLE (rect),
&rect_bg_color);
clutter_rectangle_set_border_width (CLUTTER_RECTANGLE (rect), 10);
clutter_color_from_string (&rect_border_color, "DarkSlateGray");
clutter_rectangle_set_border_color (CLUTTER_RECTANGLE (rect),
&rect_border_color);
clutter_actor_show (rect);
clutter_container_add (CLUTTER_CONTAINER (group), rect, hand, NULL);
/* Make a timeline */
timeline = clutter_timeline_new (4000); /* num frames, fps */
clutter_timeline_set_loop (timeline, TRUE);
g_signal_connect (timeline,
"completed", G_CALLBACK (timeline_completed),
NULL);
/* Set an alpha func to power behaviour - ramp is constant rise */
alpha = clutter_alpha_new_full (timeline, CLUTTER_LINEAR);
/* Create a behaviour for that alpha */
o_behave = clutter_behaviour_opacity_new (alpha, 0X33, 0xff);
/* Apply it to our actor */
clutter_behaviour_apply (o_behave, group);
/* Make a path behaviour and apply that too */
switch (path_type)
{
case PATH_POLY:
{
ClutterPath *path = clutter_path_new ();
clutter_path_set_description (path, knots_poly);
p_behave = clutter_behaviour_path_new (alpha, path);
}
break;
case PATH_ELLIPSE:
p_behave =
clutter_behaviour_ellipse_new (alpha, 200, 200, 400, 300,
CLUTTER_ROTATE_CW,
0.0, 360.0);
clutter_behaviour_ellipse_set_angle_tilt (CLUTTER_BEHAVIOUR_ELLIPSE (p_behave),
CLUTTER_X_AXIS,
45.0);
clutter_behaviour_ellipse_set_angle_tilt (CLUTTER_BEHAVIOUR_ELLIPSE (p_behave),
CLUTTER_Z_AXIS,
45.0);
break;
case PATH_BSPLINE:
{
ClutterPath *path = clutter_path_new ();
clutter_path_set_description (path, knots_bspline);
p_behave = clutter_behaviour_path_new (alpha, path);
}
break;
}
clutter_behaviour_apply (p_behave, group);
/* start the timeline and thus the animations */
clutter_timeline_start (timeline);
clutter_actor_show_all (stage);
clutter_main();
g_object_unref (o_behave);
g_object_unref (p_behave);
return 0;
}
void Cursor::ensurePlatformCursor() const
{
if (m_platformCursor || m_type == Cursor::Pointer)
return;
switch (m_type) {
case Cursor::Pointer:
// A null GdkCursor is the default cursor for the window.
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::Cross:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::Hand:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::IBeam:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::Wait:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::Help:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::Move:
case Cursor::MiddlePanning:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::EastResize:
case Cursor::EastPanning:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::NorthResize:
case Cursor::NorthPanning:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::NorthEastResize:
case Cursor::NorthEastPanning:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::NorthWestResize:
case Cursor::NorthWestPanning:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::SouthResize:
case Cursor::SouthPanning:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::SouthEastResize:
case Cursor::SouthEastPanning:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::SouthWestResize:
case Cursor::SouthWestPanning:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::WestResize:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::NorthSouthResize:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::EastWestResize:
case Cursor::WestPanning:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::NorthEastSouthWestResize:
case Cursor::NorthWestSouthEastResize:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::ColumnResize:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::RowResize:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::VerticalText:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::Cell:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::ContextMenu:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::Alias:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::Progress:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::NoDrop:
case Cursor::NotAllowed:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::Copy:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::None:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::ZoomIn:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::ZoomOut:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::Grab:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::Grabbing:
m_platformCursor = clutter_rectangle_new();
break;
case Cursor::Custom:
m_platformCursor = clutter_rectangle_new();
break;
}
}
void
opt_show_toggle_position (OptShow *show)
{
OptShowPrivate *priv;
ClutterActor *stage;
ClutterGeometry stage_geom;
g_return_if_fail (OPT_IS_SHOW (show));
priv = show->priv;
stage = clutter_stage_get_default ();
clutter_actor_get_geometry (stage, &stage_geom);
if (!priv->position_label)
{
ClutterActor *rect;
ClutterActor *label;
ClutterColor rect_color = { 0x00, 0x00, 0x00, 0x33 };
ClutterColor label_color = { 0xff, 0xff, 0xff, 0xee };
ClutterGeometry rect_geom;
rect = clutter_rectangle_new ();
clutter_rectangle_set_color (CLUTTER_RECTANGLE (rect),
&rect_color);
rect_geom.width = 102;
rect_geom.height = 77;
rect_geom.x = stage_geom.width / 2 - rect_geom.width / 2;
rect_geom.y = stage_geom.height - rect_geom.height - 20;
clutter_actor_set_geometry (rect, &rect_geom);
label = clutter_text_new_with_text ("Sans Bold 20", "0/0");
clutter_text_set_color (CLUTTER_TEXT (label),
&label_color);
clutter_actor_set_position (label, rect_geom.x + 10, rect_geom.y + 10);
clutter_group_add_many (CLUTTER_GROUP (stage),
rect,
label,
NULL);
priv->position_label = label;
priv->position_rect = rect;
priv->position_label_visible = FALSE;
}
if (!priv->position_label_visible)
{
priv->position_label_visible = TRUE;
opt_show_update_position_label (show);
clutter_actor_show (priv->position_rect);
clutter_actor_show (priv->position_label);
}
else
{
clutter_actor_hide (priv->position_label);
clutter_actor_hide (priv->position_rect);
priv->position_label_visible = FALSE;
}
}
void
scene_prismatic_joint (Scene *scene)
{
ClutterActor *ground;
ClutterActor *group;
ClutterActor *prev_hand = NULL;
ClutterActor *first_hand = NULL;
ClutterActor *stage;
stage = clutter_stage_get_default ();
first_hand = ground = clutter_rectangle_new ();
clutter_actor_set_size (ground, 500, 120);
group = clutter_box2d_new ();
clutter_group_add (CLUTTER_GROUP (stage), group);
clutter_group_add (CLUTTER_GROUP (group), ground);
clutter_actor_set_position (ground, clutter_actor_get_width (
ground) * -0.3, 568); /*
this
is
wrong
*/
add_cage (group, TRUE);
ground = clutter_rectangle_new ();
clutter_actor_set_size (ground, 256, 3);
clutter_actor_set_position (ground, -100, 310);
clutter_actor_set_rotation (ground, CLUTTER_Z_AXIS, 30, 128, 16, 0);
clutter_group_add (CLUTTER_GROUP (group), ground);
clutter_container_child_set (CLUTTER_CONTAINER (group), ground,
"mode", CLUTTER_BOX2D_STATIC, NULL);
ground = clutter_rectangle_new ();
clutter_actor_set_size (ground, 256, 3);
clutter_actor_set_position (ground, 200, 200);
clutter_actor_set_rotation (ground, CLUTTER_Z_AXIS, -30, 0, 0, 0);
clutter_group_add (CLUTTER_GROUP (group), ground);
clutter_container_child_set (CLUTTER_CONTAINER (group), ground,
"mode", CLUTTER_BOX2D_STATIC, NULL);
/*add_hand (group, 100, 100);*/
prev_hand = add_hand (group, 200, 100);
if(0){
ClutterVertex anchor1 = { (0),
(0) };
ClutterVertex anchor2 = { (0),
(0) };
ClutterVertex axis = { (100.0),
(20.0) };
clutter_box2d_add_prismatic_joint (CLUTTER_BOX2D (group),
first_hand, prev_hand,
&anchor1, &anchor2,
200.0, 220.0, &axis);
}
clutter_actor_set_depth (group, -600);
clutter_actor_set_position (group, 0, -100);
clutter_actor_set_reactive (group, TRUE);
clutter_box2d_set_simulating (CLUTTER_BOX2D (group), simulating);
scene->group = group;
}
void
scene_pulley_joint (Scene *scene)
{
ClutterActor *stage;
ClutterActor *box2d;
stage = clutter_stage_get_default ();
box2d = clutter_box2d_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (stage), box2d);
scene->group = box2d;
add_cage (box2d, FALSE);
{
ClutterVertex v1, v2, v3;
ClutterActor *joint1, *joint2, *box1, *box2;
/* Create platform 1 */
joint1 = create_circle (10);
clutter_actor_set_position (joint1, 110, 250);
clutter_container_add_actor (CLUTTER_CONTAINER (box2d), joint1);
clutter_box2d_child_set_is_circle (CLUTTER_BOX2D (box2d), joint1, TRUE);
clutter_box2d_child_set_mode (CLUTTER_BOX2D (box2d), joint1,
CLUTTER_BOX2D_DYNAMIC);
clutter_box2d_child_set_manipulatable (CLUTTER_BOX2D (box2d), joint1,
TRUE);
box1 = clutter_rectangle_new ();
clutter_actor_set_size (box1, 200, 20);
clutter_actor_set_position (box1, 10, 350);
clutter_container_add_actor (CLUTTER_CONTAINER (box2d), box1);
clutter_box2d_child_set_mode (CLUTTER_BOX2D (box2d), box1,
CLUTTER_BOX2D_DYNAMIC);
clutter_box2d_child_set_manipulatable (CLUTTER_BOX2D (box2d), box1,
TRUE);
add_hand (box2d, 20, 350 - 62);
add_hand (box2d, 210 - 58, 350 - 62);
v1 = (ClutterVertex){10, 10, 0};
v2 = (ClutterVertex){0, 0, 0};
v3 = (ClutterVertex){200, 0, 0};
clutter_box2d_add_distance_joint (CLUTTER_BOX2D (box2d),
joint1, box1,
&v1, &v2,
150, 0, 0);
clutter_box2d_add_distance_joint (CLUTTER_BOX2D (box2d),
joint1, box1,
&v1, &v3,
150, 0, 0);
/* Create platform 2 */
joint2 = create_circle (10);
clutter_actor_set_position (joint2, 530, 250);
clutter_container_add_actor (CLUTTER_CONTAINER (box2d), joint2);
clutter_box2d_child_set_is_circle (CLUTTER_BOX2D (box2d), joint2, TRUE);
clutter_box2d_child_set_mode (CLUTTER_BOX2D (box2d), joint2,
CLUTTER_BOX2D_DYNAMIC);
clutter_box2d_child_set_manipulatable (CLUTTER_BOX2D (box2d), joint2,
TRUE);
box2 = clutter_rectangle_new ();
clutter_actor_set_size (box2, 200, 20);
clutter_actor_set_position (box2, 430, 350);
clutter_container_add_actor (CLUTTER_CONTAINER (box2d), box2);
clutter_box2d_child_set_mode (CLUTTER_BOX2D (box2d), box2,
CLUTTER_BOX2D_DYNAMIC);
clutter_box2d_child_set_manipulatable (CLUTTER_BOX2D (box2d), box2,
TRUE);
add_hand (box2d, 440, 350 - 62);
add_hand (box2d, 640 - 58, 350 - 62);
clutter_box2d_add_distance_joint (CLUTTER_BOX2D (box2d),
joint2, box2,
&v1, &v2,
150, 0, 0);
clutter_box2d_add_distance_joint (CLUTTER_BOX2D (box2d),
joint2, box2,
&v1, &v3,
150, 0, 0);
/* Create pulley joint */
v1 = (ClutterVertex){ 10, 10, 0 };
v2 = (ClutterVertex){ 120, 50, 0};
v3 = (ClutterVertex){ 540, 50, 0};
clutter_box2d_add_pulley_joint (CLUTTER_BOX2D (box2d),
joint1, joint2,
&v1, &v1,
&v2, &v3,
210, 210,
400, 400,
1.0);
}
clutter_box2d_set_simulating (CLUTTER_BOX2D (box2d), simulating);
}
void
scene_chain (Scene *scene)
{
ClutterActor *stage;
ClutterActor *group;
ClutterActor *box;
stage = clutter_stage_get_default ();
group = clutter_box2d_new ();
clutter_group_add (CLUTTER_GROUP (stage), group);
scene->group = group;
add_cage (group, TRUE);
{
gint i;
gint y;
gint numlinks = 32;
ClutterActor *prev_actor;
y = 50;
box = clutter_rectangle_new ();
clutter_actor_set_size (box, 18, 5);
clutter_actor_set_position (box, clutter_actor_get_width(stage)/2, y);
clutter_group_add (CLUTTER_GROUP (group), box);
clutter_container_child_set (CLUTTER_CONTAINER (group), box,
"mode", CLUTTER_BOX2D_STATIC, NULL);
prev_actor = box;
numlinks = clutter_actor_get_height (stage)/20;
if (clutter_actor_get_width (stage)/20 < numlinks)
{
numlinks = clutter_actor_get_width (stage)/20;
}
for (i = 0; i < numlinks; ++i)
{
box = clutter_rectangle_new ();
clutter_actor_set_size (box, 18, 5);
clutter_actor_set_position (box, 20 + 20 * i, y+=1);
clutter_group_add (CLUTTER_GROUP (group), box);
clutter_container_child_set (CLUTTER_CONTAINER (group), box,
"manipulatable", TRUE,
"mode", CLUTTER_BOX2D_DYNAMIC, NULL);
{
ClutterVertex anchor1 = { (18.0),
(0.0) };
ClutterVertex anchor2 = { (0.0),
(0.0) };
clutter_box2d_add_revolute_joint (CLUTTER_BOX2D (group),
prev_actor, box,
&anchor1,
&anchor2);
}
prev_actor = box;
}
}
clutter_box2d_set_simulating (CLUTTER_BOX2D (group), simulating);
}
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;
}
int
main (int argc, char **argv)
{
const ClutterColor transp = { 0x00, 0x00, 0x00, 0x00 };
const ClutterColor bg_color = { 0xe0, 0xf2, 0xfc, 0xff };
ClutterTimeline *timeline;
ClutterActor *stage;
gint i;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
stage = clutter_stage_new ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Circles");
clutter_stage_set_color (CLUTTER_STAGE (stage), &bg_color);
clutter_actor_set_size (stage, SCREEN_W, SCREEN_H);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
timeline = clutter_timeline_new (5000);
clutter_timeline_set_loop (timeline, TRUE);
for (i = 0; i < N_CIRCLES; i++)
{
gint size;
gdouble *angle;
ClutterActor *actor;
ClutterAlpha *alpha;
ClutterBehaviour *behaviour;
actor = clutter_rectangle_new_with_color (&transp);
size = (i + 1) * (CIRCLE_W + CIRCLE_G) * 2;
clutter_actor_set_size (actor, size, size);
clutter_actor_set_position (actor,
SCREEN_W - size / 2.0,
SCREEN_H - size / 2.0);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), actor);
angle = g_slice_new (gdouble);
*angle = g_random_double_range (0.0, 90.0);
g_object_set_data (G_OBJECT (actor), "angle", angle);
g_signal_connect (actor, "paint", G_CALLBACK (circle_paint_cb), NULL);
/* Animate */
alpha = clutter_alpha_new_full (timeline, CLUTTER_LINEAR);
behaviour = clutter_behaviour_rotate_new (alpha, CLUTTER_Z_AXIS,
(i % 2) ? CLUTTER_ROTATE_CW
: CLUTTER_ROTATE_CCW,
0.0, 0.0);
clutter_behaviour_rotate_set_center (CLUTTER_BEHAVIOUR_ROTATE (behaviour),
size / 2,
size / 2,
0);
clutter_behaviour_apply (behaviour, actor);
}
ClutterActor *actor2 = clutter_group_new();
clutter_container_add_actor (CLUTTER_CONTAINER (stage), actor2);
clutter_actor_set_position(actor2, 10, 10);
ClutterEffect *effect2 = nineslice_effect_new_from_source(source);
clutter_actor_add_effect(actor2, effect2);
ClutterActor *actor = clutter_group_new();
clutter_container_add_actor (CLUTTER_CONTAINER (actor2), actor);
ClutterEffect *effect = nineslice_effect_new_from_source(source);
clutter_actor_add_effect(actor, effect);
ClutterActor *text = clutter_text_new_with_text("Sans 40px","Example Text");
clutter_actor_set_position(text, 0, 0);
clutter_container_add_actor (CLUTTER_CONTAINER (actor), text);
ClutterActor *rect = clutter_rectangle_new();
clutter_actor_set_position(rect, 10, 100);
clutter_actor_set_size(rect, 50, 50);
clutter_container_add_actor (CLUTTER_CONTAINER (actor), rect);
clutter_actor_set_position(actor, 200, 100);
//clutter_actor_set_rotation(actor, CLUTTER_Z_AXIS, 30.0, 130, 50, 0);
/*
GValue cvalue = G_VALUE_INIT;
g_value_init(&cvalue, CLUTTER_TYPE_ACTOR_BOX);
g_value_set_boxed(&cvalue, clutter_actor_box_new(0.0, 0.0, 0.0, 0.0));
GValue ovalue = G_VALUE_INIT;
g_value_init(&ovalue, CLUTTER_TYPE_ACTOR_BOX);
g_value_set_boxed(&ovalue, clutter_actor_box_new(50.0, 50.0, 50.0, 50.0));
ClutterState *transition = clutter_state_new();
clutter_state_set_duration(transition, NULL, NULL, 5000);
clutter_state_set_key (transition, NULL, "close", G_OBJECT(effect), "padding", CLUTTER_LINEAR, &cvalue, 0.0, 0.0);
clutter_state_set_key (transition, NULL, "open", G_OBJECT(effect), "padding", CLUTTER_LINEAR, &ovalue, 0.0, 0.0);
//clutter_state_set(transition, NULL, "close", effect, "padding_right", CLUTTER_LINEAR, 0.0, NULL);
//clutter_state_set(transition, NULL, "open", effect, "padding_right", CLUTTER_LINEAR, 50.0, NULL);
clutter_state_warp_to_state(transition, "close");
clutter_state_set_state(transition, "open");
*/
clutter_actor_animate(rect, CLUTTER_LINEAR, 5000, "height", 200.0, NULL);
clutter_actor_show_all (stage);
clutter_timeline_start (timeline);
clutter_main ();
return 0;
}
EaseWelcomeActor* ease_welcome_actor_construct (GType object_type, EaseTheme* t) {
#line 152 "ease-welcome-actor.c"
EaseWelcomeActor * self;
ClutterRectangle* _tmp0_;
ClutterColor _tmp1_;
ClutterColor _tmp2_;
ClutterRectangle* _tmp3_;
ClutterColor _tmp4_ = {0};
ClutterColor _tmp5_;
ClutterColor _tmp6_;
ClutterText* _tmp7_;
ClutterCairoTexture* _tmp8_;
#line 94 "ease-welcome-actor.vala"
g_return_val_if_fail (t != NULL, NULL);
#line 165 "ease-welcome-actor.c"
self = g_object_newv (object_type, 0, NULL);
#line 96 "ease-welcome-actor.vala"
ease_welcome_actor_set_theme (self, t);
#line 97 "ease-welcome-actor.vala"
clutter_actor_set_reactive ((ClutterActor*) self, TRUE);
#line 100 "ease-welcome-actor.vala"
self->priv->rect = (_tmp0_ = g_object_ref_sink ((ClutterRectangle*) clutter_rectangle_new ()), _g_object_unref0 (self->priv->rect), _tmp0_);
#line 101 "ease-welcome-actor.vala"
clutter_rectangle_set_color (self->priv->rect, (_tmp1_ = EASE_WELCOME_ACTOR_RECT_BG, &_tmp1_));
#line 102 "ease-welcome-actor.vala"
clutter_rectangle_set_border_color (self->priv->rect, (_tmp2_ = EASE_WELCOME_ACTOR_RECT_B_C, &_tmp2_));
#line 103 "ease-welcome-actor.vala"
clutter_rectangle_set_border_width (self->priv->rect, (guint) EASE_WELCOME_ACTOR_RECT_B_W);
#line 104 "ease-welcome-actor.vala"
clutter_actor_set_x ((ClutterActor*) self->priv->rect, (float) (-EASE_WELCOME_ACTOR_RECT_B_W));
#line 105 "ease-welcome-actor.vala"
clutter_actor_set_y ((ClutterActor*) self->priv->rect, (float) (-EASE_WELCOME_ACTOR_RECT_B_W));
#line 106 "ease-welcome-actor.vala"
clutter_container_add_actor ((ClutterContainer*) self, (ClutterActor*) self->priv->rect);
#line 109 "ease-welcome-actor.vala"
self->priv->hilight_rect = (_tmp3_ = g_object_ref_sink ((ClutterRectangle*) clutter_rectangle_new ()), _g_object_unref0 (self->priv->hilight_rect), _tmp3_);
#line 110 "ease-welcome-actor.vala"
clutter_rectangle_set_color (self->priv->hilight_rect, (_tmp5_ = (_tmp4_.red = (guchar) 0, _tmp4_.green = (guchar) 0, _tmp4_.blue = (guchar) 0, _tmp4_.alpha = (guchar) 255, _tmp4_), &_tmp5_));
#line 111 "ease-welcome-actor.vala"
clutter_actor_set_opacity ((ClutterActor*) self->priv->hilight_rect, (guint) 0);
#line 112 "ease-welcome-actor.vala"
clutter_rectangle_set_border_color (self->priv->hilight_rect, (_tmp6_ = EASE_WELCOME_ACTOR_HLRECT_C, &_tmp6_));
#line 113 "ease-welcome-actor.vala"
clutter_rectangle_set_border_width (self->priv->hilight_rect, (guint) EASE_WELCOME_ACTOR_HLRECT_W);
#line 114 "ease-welcome-actor.vala"
clutter_actor_set_x ((ClutterActor*) self->priv->hilight_rect, (float) (-EASE_WELCOME_ACTOR_HLRECT_W));
#line 115 "ease-welcome-actor.vala"
clutter_actor_set_y ((ClutterActor*) self->priv->hilight_rect, (float) (-EASE_WELCOME_ACTOR_HLRECT_W));
#line 116 "ease-welcome-actor.vala"
clutter_container_add_actor ((ClutterContainer*) self, (ClutterActor*) self->priv->hilight_rect);
#line 119 "ease-welcome-actor.vala"
self->priv->text = (_tmp7_ = g_object_ref_sink ((ClutterText*) clutter_text_new_full (EASE_WELCOME_ACTOR_FONT_NAME, self->priv->_theme->title, &EASE_WELCOME_ACTOR_TEXT_COLOR)), _g_object_unref0 (self->priv->text), _tmp7_);
#line 120 "ease-welcome-actor.vala"
clutter_actor_set_height ((ClutterActor*) self->priv->text, EASE_WELCOME_ACTOR_TEXT_HEIGHT);
#line 121 "ease-welcome-actor.vala"
clutter_text_set_line_alignment (self->priv->text, PANGO_ALIGN_RIGHT);
#line 122 "ease-welcome-actor.vala"
clutter_container_add_actor ((ClutterContainer*) self, (ClutterActor*) self->priv->text);
#line 125 "ease-welcome-actor.vala"
self->priv->slide_actor = (_tmp8_ = g_object_ref_sink ((ClutterCairoTexture*) clutter_cairo_texture_new ((guint) 1024, (guint) 768)), _g_object_unref0 (self->priv->slide_actor), _tmp8_);
#line 126 "ease-welcome-actor.vala"
clutter_container_add_actor ((ClutterContainer*) self, (ClutterActor*) self->priv->slide_actor);
#line 129 "ease-welcome-actor.vala"
clutter_actor_set_opacity ((ClutterActor*) self, (guint) 0);
#line 130 "ease-welcome-actor.vala"
clutter_actor_animate ((ClutterActor*) self, (gulong) EASE_WELCOME_ACTOR_FADE_EASE, (guint) EASE_WELCOME_ACTOR_FADE_INIT_TIME, "opacity", 255, NULL);
#line 133 "ease-welcome-actor.vala"
g_signal_connect_object ((ClutterActor*) self, "button-press-event", (GCallback) __lambda55__clutter_actor_button_press_event, self, 0);
#line 219 "ease-welcome-actor.c"
return self;
}
