int main (int argc, char *argv[]) { ClutterActor *stage, *scroll, *info; if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return EXIT_FAILURE; /* create a new stage */ stage = clutter_stage_new (); clutter_stage_set_title (CLUTTER_STAGE (stage), "Pan Action"); clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE); scroll = create_scroll_actor (stage); clutter_actor_add_child (stage, scroll); info = clutter_text_new_with_text (NULL, "Press <space> to reset the image position."); clutter_actor_add_child (stage, info); clutter_actor_set_position (info, 12, 12); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); g_signal_connect (stage, "key-press-event", G_CALLBACK (on_key_press), scroll); clutter_actor_show (stage); clutter_main (); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { ClutterInitError ret = my_clutter_init( argc, argv ); if( ret != CLUTTER_INIT_SUCCESS ) { return EXIT_FAILURE; } ClutterColor stage_color = { 0, 0, 0, 255 }; ClutterActor *stage = clutter_stage_new(); if( stage == NULL ) { errlog( "clutter_stage_new() failed\n" ); return EXIT_FAILURE; } clutter_actor_set_size( stage, 512, 512 ); clutter_actor_set_background_color( stage, &stage_color ); g_signal_connect( stage, "destroy", clutter_main_quit, NULL ); clutter_actor_show( stage ); clutter_main(); return EXIT_SUCCESS; }
void test_cogl_multitexture (TestConformSimpleFixture *fixture, gconstpointer data) { TestState state; ClutterActor *stage; ClutterActor *group; guint idle_source; stage = clutter_stage_new (); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); group = clutter_group_new (); clutter_container_add_actor (CLUTTER_CONTAINER (stage), group); /* We force continuous redrawing incase someone comments out the * clutter_main_quit and wants visual feedback for the test since we * wont be doing anything else that will trigger redrawing. */ idle_source = clutter_threads_add_idle (queue_redraw, stage); g_signal_connect (group, "paint", G_CALLBACK (on_paint), &state); clutter_actor_show_all (stage); clutter_main (); g_source_remove (idle_source); clutter_actor_destroy (stage); if (g_test_verbose ()) g_print ("OK\n"); }
int main (int argc, char *argv[]) { gfloat height; ClutterActor *stage, *statusbar; MxStyle *style; if (!clutter_init (&argc, &argv)) return -1; style = mx_style_get_default (); mx_style_load_from_file (style, THEMEDIR "/mutter-dawati.css", NULL); mx_style_load_from_file (mx_style_get_default (), THEMEDIR "/shared/shared.css", NULL); stage = clutter_stage_new (); clutter_actor_set_size (stage, 1024, 768); clutter_actor_show (stage); statusbar = mnb_statusbar_new (NULL); clutter_actor_get_preferred_height (statusbar, -1, NULL, &height); clutter_actor_set_size (statusbar, clutter_actor_get_width (stage), height); clutter_container_add_actor (CLUTTER_CONTAINER (stage), statusbar); clutter_main (); return 0; }
int main (int argc, char *argv[]) { ClutterActor *stage = NULL; g_set_application_name ("AtkEditableText"); if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; cally_util_a11y_init (&argc, &argv); stage = clutter_stage_new (); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); make_ui (stage); clutter_actor_show_all (stage); test_atk_text (text_actor); test_atk_text (text_editable_actor); clutter_main (); return 0; }
G_MODULE_EXPORT int test_state_script_main (int argc, char *argv[]) { ClutterActor *stage, *button; ClutterScript *script; GError *error = NULL; if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return EXIT_FAILURE; script = clutter_script_new (); clutter_script_load_from_file (script, TEST_STATE_SCRIPT_FILE, &error); if (error != NULL) g_error ("Unable to load '%s': %s\n", TEST_STATE_SCRIPT_FILE, error->message); stage = clutter_stage_new (); clutter_stage_set_title (CLUTTER_STAGE (stage), "State Script"); clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); clutter_actor_show (stage); button = CLUTTER_ACTOR (clutter_script_get_object (script, "button")); clutter_container_add_actor (CLUTTER_CONTAINER (stage), button); clutter_actor_add_constraint (button, clutter_align_constraint_new (stage, CLUTTER_ALIGN_BOTH, 0.5)); clutter_script_connect_signals (script, NULL); clutter_main (); g_object_unref (script); return EXIT_SUCCESS; }
void test_cogl_viewport (TestConformSimpleFixture *fixture, gconstpointer data) { guint idle_source; ClutterActor *stage; stage = clutter_stage_new (); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); /* We force continuous redrawing of the stage, since we need to skip * the first few frames, and we wont be doing anything else that * will trigger redrawing. */ idle_source = g_idle_add (queue_redraw, stage); g_signal_connect_after (stage, "paint", G_CALLBACK (on_paint), NULL); clutter_actor_show (stage); clutter_main (); g_source_remove (idle_source); clutter_actor_destroy (stage); if (g_test_verbose ()) g_print ("OK\n"); }
int main (int argc, char **argv) { ClutterActor *stage; ClutterActor *button; if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) { g_critical ("Could not initialize Clutter"); return EXIT_FAILURE; } /* For the icon-theme only. */ gtk_init (&argc, &argv); stage = clutter_stage_new (); button = g_object_new (MPD_TYPE_FOLDER_BUTTON, "label", "Documents", "uri", "file:///home/robsta/Documents", NULL); g_signal_connect (button, "clicked", G_CALLBACK (_folder_clicked_cb), NULL); clutter_container_add_actor (CLUTTER_CONTAINER (stage), button); clutter_actor_show_all (stage); clutter_main (); clutter_actor_destroy (stage); return EXIT_SUCCESS; }
int main (int argc, char *argv[]) { ClutterActor *stage; ClutterPath *path; ClutterConstraint *constraint; ClutterActor *rectangle; ClutterTimeline *timeline; const ClutterColor *stage_color = clutter_color_new (51, 51, 85, 255); const ClutterColor *red_color = clutter_color_new (255, 0, 0, 255); clutter_init (&argc, &argv); stage = clutter_stage_new (); clutter_actor_set_size (stage, 360, 300); clutter_stage_set_color (CLUTTER_STAGE (stage), stage_color); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); /* create the path */ path = clutter_path_new (); clutter_path_add_move_to (path, 30, 60); /* add a curve round to the top-right of the stage */ clutter_path_add_rel_curve_to (path, 120, 180, 180, 120, 240, 0); /* create a constraint based on the path */ constraint = clutter_path_constraint_new (path, 0.0); /* put a rectangle at the start of the path */ rectangle = clutter_rectangle_new_with_color (red_color); clutter_actor_set_size (rectangle, 60, 60); /* add the constraint to the rectangle */ clutter_actor_add_constraint_with_name (rectangle, "path", constraint); /* add the rectangle to the stage */ clutter_container_add_actor (CLUTTER_CONTAINER (stage), rectangle); /* set up the timeline */ timeline = clutter_timeline_new (1000); clutter_timeline_set_loop (timeline, TRUE); clutter_timeline_set_auto_reverse (timeline, TRUE); clutter_actor_animate_with_timeline (rectangle, CLUTTER_LINEAR, timeline, "@constraints.path.offset", 1.0, NULL); clutter_actor_show (stage); clutter_main (); return EXIT_SUCCESS; }
int main (int argc, char *argv[]) { ClutterActor *stage; ClutterActor *red; ClutterActor *green; if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; stage = clutter_stage_new (); clutter_actor_set_size (stage, 400, 400); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); red = clutter_rectangle_new_with_color (&red_color); clutter_actor_set_size (red, 100, 100); clutter_actor_set_position (red, 50, 150); clutter_actor_set_reactive (red, TRUE); green = clutter_rectangle_new_with_color (&green_color); clutter_actor_set_size (green, 100, 100); clutter_actor_set_position (green, 250, 150); clutter_actor_set_reactive (green, TRUE); g_signal_connect (red, "button-press-event", G_CALLBACK (button_event_cb), NULL); g_signal_connect (red, "button-release-event", G_CALLBACK (button_event_cb), NULL); g_signal_connect (green, "button-press-event", G_CALLBACK (button_event_cb), NULL); g_signal_connect (green, "button-release-event", G_CALLBACK (button_event_cb), NULL); clutter_container_add (CLUTTER_CONTAINER (stage), red, green, NULL); clutter_actor_show (stage); clutter_main (); return EXIT_SUCCESS; }
gint main (gint argc, gchar *argv[]) { ClutterContent *image; ClutterActor *stage; ClutterActor *box; GdkPixbuf *pixbuf; if (clutter_init(&argc, &argv) != CLUTTER_INIT_SUCCESS) { g_printerr("Failed to initialize clutter.\n"); return 1; } stage = clutter_stage_new(); clutter_stage_set_title (CLUTTER_STAGE (stage), "Image Viewer"); clutter_actor_set_size(stage, 1400, 1200); clutter_actor_set_position(stage, 100, 100); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); clutter_actor_show(stage); pixbuf = gdk_pixbuf_new_from_file("testimage_8000.png", NULL); g_assert(pixbuf); image = clutter_image_new(); clutter_image_set_data(CLUTTER_IMAGE(image), gdk_pixbuf_get_pixels(pixbuf), gdk_pixbuf_get_has_alpha(pixbuf) ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888, gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf), gdk_pixbuf_get_rowstride(pixbuf), NULL); g_object_unref(pixbuf); box = clutter_actor_new(); clutter_actor_set_position(box, 0, 0); clutter_actor_set_height(box, 8000); clutter_actor_set_width(box, 1200); //clutter_actor_add_constraint(box, clutter_bind_constraint_new(stage, CLUTTER_BIND_WIDTH, 0.0)); clutter_actor_set_content(box, image); clutter_actor_add_child(stage, box); clutter_actor_show(box); clutter_stage_set_fullscreen(CLUTTER_STAGE(stage), TRUE); clutter_actor_animate(box, CLUTTER_EASE_IN_OUT_QUAD, 4000, "y", -8000.0, NULL); clutter_main(); return 0; }
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; }
int main (int argc, char *argv[]) { ClutterActor *stage; ClutterAction *action1; ClutterAction *action2; ClutterActor *actor1; ClutterActor *actor2; if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; stage = clutter_stage_new (); clutter_actor_set_size (stage, 400, 400); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); actor1 = clutter_actor_new (); clutter_actor_set_name (actor1, "Red Button"); clutter_actor_set_background_color (actor1, CLUTTER_COLOR_Red); clutter_actor_set_size (actor1, 100, 100); clutter_actor_set_reactive (actor1, TRUE); clutter_actor_set_position (actor1, 50, 150); clutter_actor_add_child (stage, actor1); actor2 = clutter_actor_new (); clutter_actor_set_name (actor2, "Blue Button"); clutter_actor_set_background_color (actor2, CLUTTER_COLOR_Blue); clutter_actor_set_size (actor2, 100, 100); clutter_actor_set_position (actor2, 250, 150); clutter_actor_set_reactive (actor2, TRUE); clutter_actor_add_child (stage, actor2); action1 = clutter_click_action_new (); clutter_actor_add_action (actor1, action1); action2 = clutter_click_action_new (); clutter_actor_add_action (actor2, action2); g_signal_connect (action1, "clicked", G_CALLBACK (clicked_cb), NULL); g_signal_connect (action2, "clicked", G_CALLBACK (clicked_cb), NULL); 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; }
int main (int argc, char *argv[]) { ClutterActor *stage; ClutterActor *button; ClutterConstraint *align_x_constraint; ClutterConstraint *align_y_constraint; if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; stage = clutter_stage_new (); clutter_actor_set_size (stage, 400, 400); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); button = cb_button_new (); cb_button_set_text (CB_BUTTON (button), "hello"); /* the following is equivalent to the two lines above: * * button = g_object_new (CB_TYPE_BUTTON, * "text", "winkle", * NULL); * * because we defined a set_property function, which can accept * a PROP_TEXT parameter, GObject can create a button and set one * or more properties with a single call to g_object_new() */ /* note that the size of the button is left to Clutter's size requisition */ cb_button_set_text_color (CB_BUTTON (button), &white_color); cb_button_set_background_color (CB_BUTTON (button), &yellow_color); g_signal_connect (button, "clicked", G_CALLBACK (clicked), NULL); align_x_constraint = clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0.5); align_y_constraint = clutter_align_constraint_new (stage, CLUTTER_ALIGN_Y_AXIS, 0.5); clutter_actor_add_constraint (button, align_x_constraint); clutter_actor_add_constraint (button, align_y_constraint); clutter_actor_add_child (stage, button); clutter_actor_show (stage); clutter_main (); return EXIT_SUCCESS; }
G_MODULE_EXPORT int test_cairo_flowers_main (int argc, char **argv) { Flower *flowers[N_FLOWERS]; ClutterTimeline *timeline; int i; srand (time (NULL)); if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; /* Create a timeline to manage animation */ timeline = clutter_timeline_new (6000); clutter_timeline_set_repeat_count (timeline, -1); stage = clutter_stage_new (); clutter_stage_set_title (CLUTTER_STAGE (stage), "Cairo Flowers"); g_signal_connect (stage, "destroy", G_CALLBACK (stop_and_quit), timeline); clutter_actor_set_background_color (stage, CLUTTER_COLOR_Black); for (i=0; i< N_FLOWERS; i++) { flowers[i] = g_new0(Flower, 1); flowers[i]->ctex = make_flower_actor(); flowers[i]->x = rand() % (int) clutter_actor_get_width (stage) - (PETAL_MIN + PETAL_VAR) * 2; flowers[i]->y = rand() % (int) clutter_actor_get_height (stage); flowers[i]->rv = rand() % 5 + 1; flowers[i]->v = rand() % 10 + 2; clutter_container_add_actor (CLUTTER_CONTAINER (stage), flowers[i]->ctex); clutter_actor_set_position (flowers[i]->ctex, flowers[i]->x, flowers[i]->y); } /* fire a callback for frame change */ g_signal_connect (timeline, "new-frame", G_CALLBACK (tick), flowers); clutter_actor_show (stage); clutter_timeline_start (timeline); g_signal_connect (stage, "key-press-event", G_CALLBACK (clutter_main_quit), NULL); clutter_main(); g_object_unref (timeline); return EXIT_SUCCESS; }
static VALUE rbclt_stage_initialize (VALUE self) { ClutterActor *stage; stage = clutter_stage_new (); rbclt_initialize_unowned (self, stage); return Qnil; }
int main (int argc, char *argv[]) { ClutterActor *stage; g_type_init (); g_thread_init (NULL); if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; clutter_threads_init (); GMainLoop *loop; loop = g_main_loop_new (NULL, FALSE); stage = clutter_stage_new (); clutter_stage_set_title (CLUTTER_STAGE (stage), "message test"); clutter_actor_set_size (stage, 400, 600); clutter_actor_show_all (stage); #if 1 ClutterActor *message; GnomeAppStore *store; store = gnome_app_store_get_default (); gnome_app_store_set_lock_function (store, clutter_threads_enter); gnome_app_store_set_unlock_function (store, clutter_threads_leave); message = CLUTTER_ACTOR (gnome_app_message_new ()); clutter_container_add (CLUTTER_CONTAINER (stage), message, NULL); #else ClutterActor *page, *actor; ClutterScript *script; GError *error; script = clutter_script_new (); error = NULL; clutter_script_load_from_file (script, "/home/dliang/gnome-app-store/ui/message-info-page.json", &error); // clutter_script_load_from_file (script, "/home/dliang/gnome-app-store/ui/test.json", &error); if (error) printf ("error in load %s\n", error->message); clutter_script_get_objects (script, "message-info-page", &page, "sender_label", &actor, NULL); ClutterLayoutManager *layout; layout = clutter_box_get_layout_manager (page); gint col, row; clutter_layout_manager_child_get (layout, page, actor, "column", &col, "row", &row, NULL); printf ("col %d %d\n", col, row); clutter_layout_manager_child_set (layout, page, actor, "column", 2, "row", 1, NULL); clutter_container_add (CLUTTER_CONTAINER (stage), page, NULL); #endif g_main_loop_run (loop); g_main_loop_unref (loop); return EXIT_SUCCESS; }
int main (int argc, char *argv[]) { ClutterActor *stage = NULL; Data data1, data2,data3; guint id_2 = 0; g_set_application_name ("AtkText"); if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; if (cally_util_a11y_init (&argc, &argv) == FALSE) { g_error ("This example requires the accessibility support, " "especifically AtkUtil implementation loaded, " "as it tries to register and remove event listeners"); } data1.value = 10; data2.value = 20; data3.value = 30; /* key event listeners */ atk_add_key_event_listener ((AtkKeySnoopFunc)atk_key_listener, &data1); id_2 = atk_add_key_event_listener ((AtkKeySnoopFunc)atk_key_listener, &data2); atk_add_key_event_listener ((AtkKeySnoopFunc)atk_key_listener, &data3); atk_remove_key_event_listener (id_2); /* event listeners */ atk_add_global_event_listener (window_event_listener, "window:create"); atk_add_global_event_listener (window_event_listener, "window:destroy"); atk_add_global_event_listener (window_event_listener, "window:activate"); atk_add_global_event_listener (window_event_listener, "window:deactivate"); stage = clutter_stage_get_default (); make_ui (stage); clutter_actor_show_all (stage); if (clutter_feature_available (CLUTTER_FEATURE_STAGE_MULTIPLE)) { stage = clutter_stage_new (); make_ui (stage); clutter_actor_show_all (stage); } clutter_main (); return 0; }
Storyboard * storyboard_new (const gchar *snippets_path) { Storyboard *self; ClutterColor bg_color = {200, 200, 200, 255}; self = g_slice_new0 (Storyboard); self->max_knock = DEFAULT_MAX_KNOCK; self->max_salute = DEFAULT_MAX_SALUTE; self->gesture_index = g_random_int_range (0, TOTAL_GESTURES-1); if (g_strstr_len (snippets_path, -1, "file://") != snippets_path) self->snippets_path = g_strdup_printf ("file://%s", snippets_path); else self->snippets_path = g_strdup (snippets_path); self->stage = clutter_stage_new (); clutter_stage_hide_cursor (CLUTTER_STAGE (self->stage)); g_signal_connect (self->stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); g_signal_connect (self->stage, "key-press-event", G_CALLBACK (stage_on_key_pressed), self); clutter_actor_set_size (self->stage, 1920, 1080); clutter_stage_set_fullscreen (CLUTTER_STAGE (self->stage), TRUE); clutter_actor_set_background_color (self->stage, &bg_color); /* transition */ self->transition = transition_new (self->stage, 1000, transition_on_finish, self); /* salut stream */ salut_stream_new (on_salut_stream_ready, self); g_object_unref (self->stage); clutter_actor_show (self->stage); /* initial state */ self->status = STATUS_NONE; return self; }
G_MODULE_EXPORT int test_cogl_vertex_buffer_main (int argc, char *argv[]) { TestState state; ClutterActor *stage; gfloat stage_w, stage_h; gint dummy_width, dummy_height; if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; stage = clutter_stage_new (); clutter_stage_set_title (CLUTTER_STAGE (stage), "Cogl Vertex Buffers"); clutter_stage_set_color (CLUTTER_STAGE (stage), CLUTTER_COLOR_Black); g_signal_connect (stage, "destroy", G_CALLBACK (stop_and_quit), &state); clutter_actor_get_size (stage, &stage_w, &stage_h); dummy_width = MESH_WIDTH * QUAD_WIDTH; dummy_height = MESH_HEIGHT * QUAD_HEIGHT; state.dummy = create_dummy_actor (dummy_width, dummy_height); clutter_container_add_actor (CLUTTER_CONTAINER (stage), state.dummy); clutter_actor_set_position (state.dummy, (stage_w / 2.0) - (dummy_width / 2.0), (stage_h / 2.0) - (dummy_height / 2.0)); state.timeline = clutter_timeline_new (1000); clutter_timeline_set_loop (state.timeline, TRUE); state.frame_id = g_signal_connect (state.timeline, "new-frame", G_CALLBACK (frame_cb), &state); g_signal_connect (state.dummy, "paint", G_CALLBACK (on_paint), &state); init_quad_mesh (&state); clutter_actor_show_all (stage); clutter_timeline_start (state.timeline); clutter_main (); cogl_handle_unref (state.buffer); cogl_handle_unref (state.indices); return 0; }
G_MODULE_EXPORT int test_cogl_shader_arbfp_main (int argc, char *argv[]) { ClutterActor *stage; char *file; GError *error; ClutterColor stage_color = { 0x61, 0x64, 0x8c, 0xff }; if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; stage = clutter_stage_new (); clutter_stage_set_title (CLUTTER_STAGE (stage), "Assembly Shader Test"); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); file = g_build_filename (TESTS_DATADIR, "redhand.png", NULL); error = NULL; redhand = cogl_texture_new_from_file (file, 0, COGL_PIXEL_FORMAT_ANY, &error); if (redhand == COGL_INVALID_HANDLE) g_error ("image load failed: %s", error->message); material = cogl_material_new (); cogl_material_set_layer (material, 0, redhand); set_shader_num (0); g_signal_connect_after (stage, "paint", G_CALLBACK (paint_cb), NULL); clutter_actor_set_reactive (stage, TRUE); g_signal_connect (stage, "button-release-event", G_CALLBACK (button_release_cb), NULL); g_signal_connect (stage, "key-release-event", G_CALLBACK (key_release_cb), NULL); g_signal_connect (stage, "delete-event", G_CALLBACK (destroy_window_cb), NULL); timeout_id = clutter_threads_add_timeout (1000, timeout_cb, NULL); clutter_threads_add_idle (idle_cb, stage); clutter_actor_show (stage); clutter_main (); return EXIT_SUCCESS; }
/** * clutter_test_get_stage: * * Retrieves the #ClutterStage used for testing. * * Return value: (transfer none): the stage used for testing * * Since: 1.18 */ ClutterActor * clutter_test_get_stage (void) { g_assert (test_environ != NULL); if (test_environ->stage == NULL) { /* create a stage, and ensure that it goes away at the end */ test_environ->stage = clutter_stage_new (); clutter_actor_set_name (test_environ->stage, "Test Stage"); g_object_add_weak_pointer (G_OBJECT (test_environ->stage), (gpointer *) &test_environ->stage); } return test_environ->stage; }
int main (int argc, char *argv[]) { ClutterActor *stage = NULL; Data data1, data2,data3; guint id_2 = 0; g_set_application_name ("AtkText"); if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; cally_util_a11y_init (&argc, &argv); data1.value = 10; data2.value = 20; data3.value = 30; /* key event listeners */ atk_add_key_event_listener ((AtkKeySnoopFunc)atk_key_listener, &data1); id_2 = atk_add_key_event_listener ((AtkKeySnoopFunc)atk_key_listener, &data2); atk_add_key_event_listener ((AtkKeySnoopFunc)atk_key_listener, &data3); atk_remove_key_event_listener (id_2); /* event listeners */ atk_add_global_event_listener (window_event_listener, "window:create"); atk_add_global_event_listener (window_event_listener, "window:destroy"); atk_add_global_event_listener (window_event_listener, "window:activate"); atk_add_global_event_listener (window_event_listener, "window:deactivate"); stage = clutter_stage_get_default (); make_ui (stage); clutter_actor_show_all (stage); if (clutter_feature_available (CLUTTER_FEATURE_STAGE_MULTIPLE)) { stage = clutter_stage_new (); make_ui (stage); clutter_actor_show_all (stage); } clutter_main (); return 0; }
int main (int argc, char *argv[]) { ClutterActor *stage; ClutterActor *r1, *r2, *r3; if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; stage = clutter_stage_new (); clutter_actor_set_size (stage, 300, 300); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); r1 = clutter_rectangle_new_with_color (&red); clutter_actor_set_size (r1, 150, 150); clutter_actor_add_constraint (r1, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0.25)); clutter_actor_add_constraint (r1, clutter_align_constraint_new (stage, CLUTTER_ALIGN_Y_AXIS, 0.25)); clutter_actor_set_reactive (r1, TRUE); clutter_actor_set_name (r1, "red"); r2 = clutter_rectangle_new_with_color (&green); clutter_actor_set_size (r2, 150, 150); clutter_actor_add_constraint (r2, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0.5)); clutter_actor_add_constraint (r2, clutter_align_constraint_new (stage, CLUTTER_ALIGN_Y_AXIS, 0.5)); clutter_actor_set_reactive (r2, TRUE); clutter_actor_set_depth (r2, -100); clutter_actor_set_name (r2, "green"); r3 = clutter_rectangle_new_with_color (&blue); clutter_actor_set_size (r3, 150, 150); clutter_actor_add_constraint (r3, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0.75)); clutter_actor_add_constraint (r3, clutter_align_constraint_new (stage, CLUTTER_ALIGN_Y_AXIS, 0.75)); clutter_actor_set_opacity (r3, 125); clutter_actor_set_name (r3, "blue"); clutter_container_add (CLUTTER_CONTAINER (stage), r1, r2, r3, NULL); g_signal_connect (r1, "motion-event", G_CALLBACK (_pointer_motion_cb), NULL); g_signal_connect (r2, "motion-event", G_CALLBACK (_pointer_motion_cb), NULL); clutter_actor_show (stage); clutter_main (); return 0; }
static int lcs_taskbar (int *argc, char ***argv) { gdk_init (argc, argv); lcs_clutter_enable_transparency (TRUE); gtk_init (argc, argv); if (!clutter_init (argc, argv)) { fprintf (stderr, "error initializing clutter"); exit (1); } ClutterActor *stage = clutter_stage_new (); clutter_actor_set_layout_manager ( stage, clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_START, CLUTTER_BIN_ALIGNMENT_START)); clutter_stage_set_use_alpha (CLUTTER_STAGE (stage), TRUE); clutter_actor_set_background_color (stage, clutter_color_new (255, 255, 255, 96)); ClutterActor *taskbar = lcs_taskbar_new (); clutter_actor_set_margin (taskbar, lcs_clutter_margin_new_full (4, 4, 4, 4)); clutter_actor_add_child (stage, taskbar); g_signal_connect (stage, "destroy", G_CALLBACK (on_stage_destroy), NULL); ClutterAction *drag = clutter_drag_action_new (); g_signal_connect (drag, "drag-motion", G_CALLBACK (on_stage_drag_motion), NULL); clutter_actor_add_action_with_name (stage, "drag", drag); clutter_actor_show (stage); long stagexid = lcs_wm_get_stage_xid (CLUTTER_STAGE(stage)); g_object_set_data (G_OBJECT (stage), "xid", GINT_TO_POINTER (stagexid)); lcs_wm_xwindow_set_decorated (stagexid, FALSE); lcs_wm_xwindow_set_above (stagexid); lcs_wm_xwindow_set_dock (stagexid); clutter_main (); return (0); }
int main (int argc, char *argv[]) { ClutterActor *actor, *marker, *stage; ChamplainMarkerLayer *layer; GpsCallbackData callback_data; if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; stage = clutter_stage_new (); clutter_actor_set_size (stage, 800, 600); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); /* Create the map view */ actor = champlain_view_new (); clutter_actor_set_size (CLUTTER_ACTOR (actor), 800, 600); clutter_container_add_actor (CLUTTER_CONTAINER (stage), actor); /* Create the marker layer */ layer = champlain_marker_layer_new_full (CHAMPLAIN_SELECTION_SINGLE); clutter_actor_show (CLUTTER_ACTOR (layer)); champlain_view_add_layer (CHAMPLAIN_VIEW (actor), CHAMPLAIN_LAYER (layer)); /* Create a marker */ marker = create_marker (); champlain_marker_layer_add_marker (layer, CHAMPLAIN_MARKER (marker)); /* Finish initialising the map view */ g_object_set (G_OBJECT (actor), "zoom-level", 12, "kinetic-mode", TRUE, NULL); champlain_view_center_on (CHAMPLAIN_VIEW (actor), lat, lon); /* Create callback that updates the map periodically */ callback_data.view = CHAMPLAIN_VIEW (actor); callback_data.marker = CHAMPLAIN_MARKER (marker); g_timeout_add (1000, (GSourceFunc) gps_callback, &callback_data); clutter_actor_show (stage); clutter_main (); return 0; }
int main (int argc, char *argv[]) { TestState state; ClutterActor *stage; GError *error = NULL; g_setenv ("CLUTTER_VBLANK", "none", FALSE); g_setenv ("CLUTTER_SHOW_FPS", "1", FALSE); if (clutter_init_with_args (&argc, &argv, NULL, entries, NULL, &error) != CLUTTER_INIT_SUCCESS) { g_warning ("Unable to initialise Clutter:\n%s", error->message); g_error_free (error); return EXIT_FAILURE; } state.current_test = 0; state.stage = stage = clutter_stage_new (); clutter_actor_set_size (stage, STAGE_WIDTH, STAGE_HEIGHT); clutter_stage_set_color (CLUTTER_STAGE (stage), CLUTTER_COLOR_White); clutter_stage_set_title (CLUTTER_STAGE (stage), "Cogl Performance Test"); /* We want continuous redrawing of the stage... */ clutter_threads_add_idle (queue_redraw, stage); g_signal_connect_after (stage, "paint", G_CALLBACK (on_paint), &state); clutter_actor_show (stage); clutter_main (); clutter_actor_destroy (stage); return 0; }
static void test_window (void) { GsdOsdDrawContext ctx; ClutterActor *stage, *actor; ClutterContent *canvas; GtkWidgetPath *widget_path; /* create a resizable stage */ stage = clutter_stage_new (); clutter_stage_set_title (CLUTTER_STAGE (stage), "OSD Test"); clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE); clutter_actor_set_background_color (stage, CLUTTER_COLOR_Red); clutter_actor_set_size (stage, 300, 300); clutter_actor_show (stage); /* box canvas */ canvas = clutter_canvas_new (); clutter_canvas_set_size (CLUTTER_CANVAS (canvas), 300, 300); actor = clutter_actor_new (); clutter_actor_add_constraint (actor, clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0)); clutter_actor_set_content (actor, canvas); g_object_unref (canvas); clutter_actor_add_child (stage, actor); memset (&ctx, 0, sizeof(ctx)); widget_path = gtk_widget_path_new (); gtk_widget_path_append_type (widget_path, GTK_TYPE_WINDOW); ctx.style = gtk_style_context_new (); gtk_style_context_set_path (ctx.style, widget_path); ctx.direction = clutter_get_default_text_direction (); ctx.theme = gtk_icon_theme_get_default (); g_signal_connect (canvas, "draw", G_CALLBACK (draw_box), &ctx); clutter_content_invalidate (canvas); g_signal_connect (stage, "destroy", G_CALLBACK (gtk_main_quit), NULL); }
G_MODULE_EXPORT int test_texture_material_main (int argc, char *argv[]) { ClutterActor *stage, *box; ClutterLayoutManager *manager; int i; g_thread_init (NULL); clutter_threads_init (); clutter_init (&argc, &argv); stage = clutter_stage_new (); clutter_stage_set_title (CLUTTER_STAGE (stage), "Texture Material"); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); manager = clutter_flow_layout_new (CLUTTER_FLOW_HORIZONTAL); box = clutter_box_new (manager); clutter_actor_add_constraint (box, clutter_bind_constraint_new (stage, CLUTTER_BIND_WIDTH, -25.0)); clutter_actor_add_constraint (box, clutter_bind_constraint_new (stage, CLUTTER_BIND_HEIGHT, -25.0)); clutter_actor_set_position (box, 25.0, 25.0); clutter_container_add_actor (CLUTTER_CONTAINER (stage), box); for (i = 0; i < 48; i++) { ClutterActor *texture = clutter_texture_new (); clutter_texture_set_load_data_async (CLUTTER_TEXTURE (texture), TRUE); clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (texture), TRUE); clutter_texture_set_from_file (CLUTTER_TEXTURE (texture), TESTS_DATADIR "/redhand.png", NULL); clutter_actor_set_width (texture, 96); clutter_container_add_actor (CLUTTER_CONTAINER (box), texture); } clutter_actor_show (stage); clutter_main (); return EXIT_SUCCESS; }