static GstBusSyncReply
create_window (GstBus * bus, GstMessage * message, gpointer data)
{
GstGLClutterActor **actor = (GstGLClutterActor **) data;
static gint count = 0;
static GMutex mutex;
// ignore anything but 'prepare-window-handle' element messages
if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT)
return GST_BUS_PASS;
if (!gst_is_video_overlay_prepare_window_handle_message (message))
return GST_BUS_PASS;
g_mutex_lock (&mutex);
if (count < N_ACTORS) {
g_message ("adding actor %d", count);
gst_video_overlay_set_window_handle (GST_VIDEO_OVERLAY (GST_MESSAGE_SRC
(message)), actor[count]->win);
clutter_threads_add_idle ((GSourceFunc) create_actor, actor[count]);
count++;
}
g_mutex_unlock (&mutex);
gst_message_unref (message);
return GST_BUS_DROP;
}
static GstBusSyncReply
create_window (GstBus * bus, GstMessage * message, gpointer data)
{
GstGLClutterActor **actor = (GstGLClutterActor **) data;
static gint count = 0;
static GMutex *mutex = NULL;
// ignore anything but 'prepare-xwindow-id' element messages
if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT)
return GST_BUS_PASS;
if (!gst_structure_has_name (message->structure, "prepare-xwindow-id"))
return GST_BUS_PASS;
if (!mutex)
mutex = g_mutex_new ();
g_mutex_lock (mutex);
if (count < N_ACTORS) {
g_message ("adding actor %d", count);
gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (GST_MESSAGE_SRC (message)),
actor[count]->win);
clutter_threads_add_idle ((GSourceFunc) create_actor, actor[count]);
count++;
}
g_mutex_unlock (mutex);
gst_message_unref (message);
return GST_BUS_DROP;
}
/* Object initialization
* Create private structure and set up default values
*/
static void xfdashboard_applications_menu_model_init(XfdashboardApplicationsMenuModel *self)
{
XfdashboardApplicationsMenuModelPrivate *priv;
GType columnTypes[]= {
G_TYPE_UINT, /* XFDASHBOARD_APPLICATIONS_MENU_MODEL_COLUMN_SEQUENCE_ID */
GARCON_TYPE_MENU_ELEMENT, /* XFDASHBOARD_APPLICATIONS_MENU_MODEL_COLUMN_MENU_ELEMENT */
GARCON_TYPE_MENU, /* XFDASHBOARD_APPLICATIONS_MENU_MODEL_COLUMN_PARENT_MENU */
GARCON_TYPE_MENU, /* XFDASHBOARD_APPLICATIONS_MENU_MODEL_COLUMN_SECTION */
G_TYPE_STRING, /* XFDASHBOARD_APPLICATIONS_MENU_MODEL_COLUMN_TITLE */
G_TYPE_STRING /* XFDASHBOARD_APPLICATIONS_MENU_MODEL_COLUMN_DESCRIPTION */
};
const gchar* columnNames[]= {
_("ID"), /* XFDASHBOARD_APPLICATIONS_MENU_MODEL_COLUMN_SEQUENCE_ID */
_("Menu item"), /* XFDASHBOARD_APPLICATIONS_MENU_MODEL_COLUMN_MENU_ELEMENT */
_("Parent menu"), /* XFDASHBOARD_APPLICATIONS_MENU_MODEL_COLUMN_PARENT_MENU */
_("Section"), /* XFDASHBOARD_APPLICATIONS_MENU_MODEL_COLUMN_SECTION */
_("Title"), /* XFDASHBOARD_APPLICATIONS_MENU_MODEL_COLUMN_TITLE */
_("Description"), /* XFDASHBOARD_APPLICATIONS_MENU_MODEL_COLUMN_DESCRIPTION */
};
priv=self->priv=XFDASHBOARD_APPLICATIONS_MENU_MODEL_GET_PRIVATE(self);
/* Set up default values */
priv->rootMenu=NULL;
/* Set up model */
clutter_model_set_types(CLUTTER_MODEL(self), XFDASHBOARD_APPLICATIONS_MENU_MODEL_COLUMN_LAST, columnTypes);
clutter_model_set_names(CLUTTER_MODEL(self), XFDASHBOARD_APPLICATIONS_MENU_MODEL_COLUMN_LAST, columnNames);
/* Defer filling model */
clutter_threads_add_idle(_xfdashboard_applications_menu_model_init_idle, self);
}
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");
}
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;
}
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
actor_pick (void)
{
int y, x;
State state;
state.pass = TRUE;
state.stage = clutter_test_get_stage ();
state.actor_width = STAGE_WIDTH / ACTORS_X;
state.actor_height = STAGE_HEIGHT / ACTORS_Y;
for (y = 0; y < ACTORS_Y; y++)
for (x = 0; x < ACTORS_X; x++)
{
ClutterColor color = { x * 255 / (ACTORS_X - 1),
y * 255 / (ACTORS_Y - 1),
128, 255 };
ClutterActor *rect = clutter_rectangle_new_with_color (&color);
clutter_actor_set_position (rect,
x * state.actor_width,
y * state.actor_height);
clutter_actor_set_size (rect,
state.actor_width,
state.actor_height);
clutter_actor_add_child (state.stage, rect);
state.actors[y * ACTORS_X + x] = rect;
}
clutter_actor_show (state.stage);
clutter_threads_add_idle (on_timeout, &state);
clutter_main ();
g_assert (state.pass);
}
void
test_text_cache (TestConformSimpleFixture *fixture,
gconstpointer _data)
{
CallbackData data;
memset (&data, 0, sizeof (data));
data.stage = clutter_stage_get_default ();
data.label = clutter_text_new_with_text (TEST_FONT, "");
data.test_layout = make_layout_like_label (CLUTTER_TEXT (data.label));
g_signal_connect (data.label, "paint", G_CALLBACK (on_paint), &data);
clutter_container_add (CLUTTER_CONTAINER (data.stage), data.label, NULL);
clutter_actor_show (data.stage);
clutter_threads_add_idle ((GSourceFunc) do_tests, &data);
clutter_main ();
if (g_test_verbose ())
g_print ("\nOverall result: ");
if (g_test_verbose ())
{
if (data.test_failed)
g_print ("FAIL\n");
else
g_print ("pass\n");
}
else
g_assert (data.test_failed != TRUE);
}
int
main (int argc, char *argv[])
{
ClutterActor *stage;
ClutterActor *label;
int w, h;
int row, col;
float scale = 1.0f;
g_setenv ("CLUTTER_VBLANK", "none", FALSE);
g_setenv ("CLUTTER_DEFAULT_FPS", "1000", FALSE);
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
if (argc != 3)
{
g_printerr ("Usage test-text-perf FONT_SIZE N_CHARS\n");
exit (1);
}
font_size = atoi (argv[1]);
n_chars = atoi (argv[2]);
g_print ("Monospace %dpx, string length = %d\n", font_size, n_chars);
stage = clutter_stage_new ();
clutter_actor_set_size (stage, STAGE_WIDTH, STAGE_HEIGHT);
clutter_stage_set_color (CLUTTER_STAGE (stage), CLUTTER_COLOR_Black);
clutter_stage_set_title (CLUTTER_STAGE (stage), "Text Performance");
g_signal_connect (stage, "paint", G_CALLBACK (on_paint), NULL);
label = create_label ();
w = clutter_actor_get_width (label);
h = clutter_actor_get_height (label);
/* If the label is too big to fit on the stage then scale it so that
it will fit */
if (w > STAGE_WIDTH || h > STAGE_HEIGHT)
{
float x_scale = STAGE_WIDTH / (float) w;
float y_scale = STAGE_HEIGHT / (float) h;
if (x_scale < y_scale)
{
scale = x_scale;
cols = 1;
rows = STAGE_HEIGHT / (h * scale);
}
else
{
scale = y_scale;
cols = STAGE_WIDTH / (w * scale);
rows = 1;
}
g_print ("Text scaled by %f to fit on the stage\n", scale);
}
else
{
cols = STAGE_WIDTH / w;
rows = STAGE_HEIGHT / h;
}
clutter_actor_destroy (label);
for (row=0; row<rows; row++)
for (col=0; col<cols; col++)
{
label = create_label();
clutter_actor_set_scale (label, scale, scale);
clutter_actor_set_position (label, w * col * scale, h * row * scale);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), label);
}
clutter_actor_show_all (stage);
clutter_threads_add_idle (queue_redraw, stage);
clutter_main ();
return 0;
}
int
main (int argc, char **argv)
{
glong i;
gdouble angle;
ClutterColor color = { 0x00, 0x00, 0x00, 0xff };
ClutterActor *stage, *rect;
clutter_perf_fps_init ();
if (CLUTTER_INIT_SUCCESS !=
clutter_init_with_args (&argc, &argv,
NULL,
entries,
NULL,
NULL))
{
g_warning ("Failed to initialize clutter");
return -1;
}
stage = clutter_stage_new ();
clutter_actor_set_size (stage, 512, 512);
clutter_stage_set_color (CLUTTER_STAGE (stage), CLUTTER_COLOR_Black);
clutter_stage_set_title (CLUTTER_STAGE (stage), "Picking Performance");
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
printf ("Picking performance test with "
"%d actors and %d events per frame\n",
n_actors,
n_events);
for (i = n_actors - 1; i >= 0; i--)
{
angle = ((2.0 * G_PI) / (gdouble) n_actors) * i;
color.red = (1.0 - ABS ((MAX (0, MIN (n_actors/2.0 + 0, i))) /
(gdouble)(n_actors/4.0) - 1.0)) * 255.0;
color.green = (1.0 - ABS ((MAX (0, MIN (n_actors/2.0 + 0,
fmod (i + (n_actors/3.0)*2, n_actors)))) /
(gdouble)(n_actors/4) - 1.0)) * 255.0;
color.blue = (1.0 - ABS ((MAX (0, MIN (n_actors/2.0 + 0,
fmod ((i + (n_actors/3.0)), n_actors)))) /
(gdouble)(n_actors/4.0) - 1.0)) * 255.0;
rect = clutter_rectangle_new_with_color (&color);
clutter_actor_set_size (rect, 100, 100);
clutter_actor_set_anchor_point_from_gravity (rect,
CLUTTER_GRAVITY_CENTER);
clutter_actor_set_position (rect,
256 + 206 * cos (angle),
256 + 206 * sin (angle));
clutter_actor_set_reactive (rect, TRUE);
g_signal_connect (rect, "motion-event",
G_CALLBACK (motion_event_cb), NULL);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), rect);
}
clutter_actor_show (stage);
clutter_perf_fps_start (CLUTTER_STAGE (stage));
clutter_threads_add_idle (queue_redraw, stage);
clutter_main ();
clutter_perf_fps_report ("test-picking");
return 0;
}
