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; }