static void
validate_result (TestState *state)
{
GLubyte pixel[4];
GLint y_off = 90;
/* NB: We ignore the alpha, since we don't know if our render target is
* RGB or RGBA */
#define RED 0
#define GREEN 1
#define BLUE 2
/* Should see a blue pixel */
cogl_read_pixels (10, y_off, 1, 1,
COGL_READ_PIXELS_COLOR_BUFFER,
COGL_PIXEL_FORMAT_RGBA_8888_PRE,
pixel);
if (g_test_verbose ())
g_print ("pixel 0 = %x, %x, %x\n", pixel[RED], pixel[GREEN], pixel[BLUE]);
g_assert (pixel[RED] == 0 && pixel[GREEN] == 0 && pixel[BLUE] != 0);
#undef RED
#undef GREEN
#undef BLUE
/* Comment this out if you want visual feedback of what this test
* paints.
*/
clutter_main_quit ();
}
static void
on_key_press_event (ClutterStage *stage,
ClutterKeyEvent *event,
gpointer user_data)
{
TestThreadData *data;
switch (clutter_key_event_symbol (event))
{
case CLUTTER_s:
clutter_label_set_text (CLUTTER_LABEL (help_label), "Press 'q' to quit");
clutter_timeline_start (timeline);
data = test_thread_data_new ();
data->stage = g_object_ref (stage);
data->label = g_object_ref (count_label);
data->progress = g_object_ref (progress_rect);
data->timeline = g_object_ref (timeline);
g_thread_create (test_thread_func, data, FALSE, NULL);
break;
case CLUTTER_q:
clutter_main_quit ();
break;
}
}
static gboolean
on_input (ClutterActor *stage,
ClutterEvent *event,
gpointer user_data)
{
App *app = user_data;
if (event->type == CLUTTER_KEY_RELEASE)
{
if (clutter_timeline_is_playing(app->timeline))
return FALSE;
switch (clutter_event_get_key_symbol (event))
{
case CLUTTER_Left:
rotate_items (app, -1);
break;
case CLUTTER_Right:
rotate_items (app, 1);
break;
case CLUTTER_Return:
break;
case CLUTTER_q:
clutter_main_quit();
break;
default:
break;
}
}
return FALSE;
}
static void
stop_and_quit (ClutterActor *actor,
ClutterTimeline *timeline)
{
clutter_timeline_stop (timeline);
clutter_main_quit ();
}
static gboolean
input_cb (ClutterActor *stage,
ClutterEvent *event,
gpointer data)
{
SuperOH *oh = data;
if (event->type == CLUTTER_KEY_RELEASE)
{
g_print ("*** key press event (key:%c) ***\n",
clutter_event_get_key_symbol (event));
if (clutter_event_get_key_symbol (event) == CLUTTER_q)
{
clutter_main_quit ();
return TRUE;
}
else if (clutter_event_get_key_symbol (event) == CLUTTER_r)
{
gint i;
for (i = 0; i < n_hands; i++)
clutter_actor_show (oh->hand[i]);
return TRUE;
}
}
return FALSE;
}
static void
quit (gint signale)
{
signal (SIGINT, 0);
clutter_main_quit ();
}
static void
stop_and_quit (ClutterActor *actor,
TestState *state)
{
clutter_timeline_stop (state->timeline);
clutter_main_quit ();
}
gboolean key_press_event(ClutterActor *stage, ClutterEvent *event, gpointer user_data)
{
UNUSED(user_data);
guint keyval = clutter_event_get_key_symbol(event);
ClutterModifierType state = clutter_event_get_state(event);
gboolean ctrl_pressed = (state & CLUTTER_CONTROL_MASK ? TRUE : FALSE);
if (keyval == CLUTTER_KEY_Escape)
{
if (clutter_stage_get_fullscreen(CLUTTER_STAGE(stage)))
clutter_stage_set_fullscreen(CLUTTER_STAGE(stage), FALSE);
else
clutter_stage_set_fullscreen(CLUTTER_STAGE(stage), TRUE);
}
else if (keyval == CLUTTER_KEY_q)
{
// Quit application on ctrl-q, this quits the main loop
// (if there is one)
if (ctrl_pressed)
{
if (option_verbose)
g_print("ctrl-q pressed. quitting.\n");
clutter_main_quit();
}
}
return TRUE;
}
/* gst bus signal watch callback */
void
end_stream_cb (GstBus * bus, GstMessage * msg, gpointer data)
{
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_EOS:
g_print ("End-of-stream\n");
g_print
("For more information, try to run: GST_DEBUG=gldisplay:2 ./cluttershare\n");
break;
case GST_MESSAGE_ERROR:
{
gchar *debug = NULL;
GError *err = NULL;
gst_message_parse_error (msg, &err, &debug);
g_print ("Error: %s\n", err->message);
g_error_free (err);
if (debug) {
g_print ("Debug deails: %s\n", debug);
g_free (debug);
}
break;
}
default:
break;
}
clutter_main_quit ();
}
static void key_event_cb(ClutterActor *actor, ClutterKeyEvent *event, gpointer user_data)
{
App *app = (App *) user_data;
switch (event->keyval)
{
case CLUTTER_Escape:
app->toggleFullscreen();
break;
case CLUTTER_KEY_q:
clutter_main_quit();
break;
case CLUTTER_KEY_Delete:
//app->clearAll(); // FIXME: segfaults
break;
case CLUTTER_KEY_BackSpace:
app->clearLast();
break;
case CLUTTER_KEY_Up:
app->playFaster();
break;
case CLUTTER_KEY_Down:
app->playSlower();
break;
}
}
static void
validate_result (TestState *state)
{
int ypos = 0;
if (g_test_verbose ())
g_print ("Testing onscreen clone...\n");
g_assert (validate_part (state, SOURCE_SIZE, ypos * SOURCE_SIZE, 0));
ypos++;
#if 0 /* this doesn't work */
if (g_test_verbose ())
g_print ("Testing offscreen clone...\n");
g_assert (validate_part (state, SOURCE_SIZE, ypos * SOURCE_SIZE, 0));
#endif
ypos++;
if (g_test_verbose ())
g_print ("Testing onscreen clone with rectangular clip...\n");
g_assert (validate_part (state, SOURCE_SIZE, ypos * SOURCE_SIZE, ~1));
ypos++;
if (g_test_verbose ())
g_print ("Testing onscreen clone with path clip...\n");
g_assert (validate_part (state, SOURCE_SIZE, ypos * SOURCE_SIZE, 1));
ypos++;
/* Comment this out if you want visual feedback of what this test
* paints.
*/
clutter_main_quit ();
}
static void
on_destroy (ClutterActor *actor, gpointer data)
{
GFreenectDevice *device = GFREENECT_DEVICE (data);
gfreenect_device_stop_depth_stream (device, NULL);
gfreenect_device_stop_video_stream (device, NULL);
clutter_main_quit ();
}
static gboolean
destroy_window_cb (ClutterStage *stage,
ClutterEvent *event,
void *user_data)
{
clutter_main_quit ();
return TRUE;
}
static void
stop_and_quit (ClutterActor *actor,
SuperOH *oh)
{
g_signal_handler_disconnect (oh->timeline, oh->frame_id);
clutter_timeline_stop (oh->timeline);
clutter_main_quit ();
}
static void on_stage_destroyed(gpointer *user_data)
{
TempiClutterStageNode *self = (TempiClutterStageNode *) user_data;
(void) self;
clutter_threads_enter();
clutter_main_quit();
clutter_threads_leave();
}
/* input handler */
static gboolean
input_cb (ClutterActor *stage,
ClutterEvent *event,
gpointer data)
{
SuperOH *oh = data;
if (event->type == CLUTTER_BUTTON_PRESS)
{
ClutterButtonEvent *button_event;
ClutterActor *e;
gint x, y;
clutter_event_get_coords (event, &x, &y);
button_event = (ClutterButtonEvent *) event;
g_print ("*** button press event (button:%d) ***\n",
button_event->button);
e = clutter_stage_get_actor_at_pos (CLUTTER_STAGE (stage), x, y);
if (e && (CLUTTER_IS_TEXTURE (e) || CLUTTER_IS_CLONE_TEXTURE (e)))
{
clutter_actor_hide (e);
return TRUE;
}
}
else if (event->type == CLUTTER_KEY_RELEASE)
{
ClutterKeyEvent *kev = (ClutterKeyEvent *) event;
g_print ("*** key press event (key:%c) ***\n",
clutter_key_event_symbol (kev));
if (clutter_key_event_symbol (kev) == CLUTTER_q)
{
clutter_main_quit ();
return TRUE;
}
else if (clutter_key_event_symbol (kev) == CLUTTER_r)
{
gint i;
for (i = 0; i < n_hands; i++)
clutter_actor_show (oh->hand[i]);
return TRUE;
}
}
return FALSE;
}
static gboolean
key_release_cb (ClutterActor *actor,
ClutterEvent *event,
gpointer user_data)
{
guint keysym = clutter_event_get_key_symbol (event);
ClutterModifierType mods = clutter_event_get_state (event);
if (keysym == CLUTTER_KEY_q ||
((mods & CLUTTER_SHIFT_MASK) && keysym == CLUTTER_KEY_q))
clutter_main_quit ();
return CLUTTER_EVENT_STOP;
}
static void key_event_cb(ClutterActor *actor, ClutterKeyEvent *event, gpointer user_data)
{
TempiClutterStageNode *self = (TempiClutterStageNode *) user_data;
(void) self; // TODO: remove this
ClutterModifierType state = clutter_event_get_state((ClutterEvent*) event);
bool ctrl_pressed = (state & CLUTTER_CONTROL_MASK ? true : false);
switch (event->keyval)
{
case CLUTTER_KEY_q:
if (ctrl_pressed)
clutter_main_quit();
break;
}
}
static void key_event_cb(ClutterActor *actor, ClutterKeyEvent *event, gpointer data)
{
Assistant *assistant = (Assistant *) data;
(void) assistant; // unused
switch (event->keyval)
{
case CLUTTER_Escape:
clutter_main_quit();
break;
case CLUTTER_space:
break;
default:
break;
}
}
void xfdashboard_application_quit_forced(void)
{
if(G_LIKELY(application!=NULL))
{
/* Quit also any other running instance */
if(g_application_get_is_remote(G_APPLICATION(application))==TRUE)
{
g_action_group_activate_action(G_ACTION_GROUP(application), "Quit", NULL);
}
/* Quit this instance */
_xfdashboard_application_quit(application, TRUE);
}
else clutter_main_quit();
}
static void key_event_cb(ClutterActor *actor, ClutterKeyEvent *event, gpointer data)
{
UNUSED(actor);
App *self = static_cast<App *>(data);
(void) self;
switch (event->keyval)
{
case CLUTTER_Escape:
clutter_main_quit();
break;
case CLUTTER_space:
break;
default:
break;
}
}
static void
on_destroy (ClutterActor *actor, gpointer data)
{
ClutterContent *content;
GFreenectDevice *device = GFREENECT_DEVICE (data);
content = clutter_actor_get_content (depth_tex);
if (content == depth_canvas)
g_object_unref (depth_image);
else
g_object_unref (depth_canvas);
gfreenect_device_stop_depth_stream (device, NULL);
gfreenect_device_stop_video_stream (device, NULL);
clutter_main_quit ();
}
static void completed (ClutterState *state,
gpointer data)
{
if (g_str_equal (clutter_state_get_state (state), "right"))
{
/* skip straight to left state when reaching right */
clutter_state_warp_to_state (state, "left");
}
else if (g_str_equal (clutter_state_get_state (state), "active"))
clutter_state_set_state (state, "right");
else
{
clutter_state_set_state (state, "active");
}
times --;
if (times <=0)
clutter_main_quit ();
}
static gboolean
stage_key_release_cb (ClutterActor *actor,
ClutterEvent *event,
gpointer data)
{
switch (clutter_event_get_key_symbol (event))
{
case CLUTTER_KEY_q:
case CLUTTER_KEY_Q:
clutter_main_quit ();
break;
case CLUTTER_KEY_m:
toggle_texture_quality (actor);
break;
}
return FALSE;
}
/* Process keyboard/mouse events */
static void input_events_cb(ClutterActor *stage, ClutterEvent *event,
gpointer user_data)
{
/* Only handle keyboard events */
if (event->type != CLUTTER_KEY_PRESS)
return;
guint sym;
sym = clutter_event_get_key_symbol(event);
switch (sym) {
case CLUTTER_Escape:
case CLUTTER_q:
clutter_main_quit();
break;
case CLUTTER_Right:
mozart_next_track();
break;
case CLUTTER_Left:
mozart_prev_track();
break;
case CLUTTER_Down:
mozart_replay_track();
break;
case CLUTTER_space:
mozart_play_pause();
break;
case CLUTTER_r:
toggle_repeat(stage, "single");
break;
case CLUTTER_a:
toggle_repeat(stage, "all");
break;
case CLUTTER_s:
toggle_shuffle(stage);
break;
case CLUTTER_Page_Up:
mozart_player_seek("seek-fwd");
break;
case CLUTTER_Page_Down:
mozart_player_seek("seek-bwd");
break;
}
}
static gboolean
key_release_cb (ClutterActor *stage,
ClutterEvent *event,
ClutterActor *box)
{
ClutterGridLayout *layout;
gboolean toggle;
guint spacing;
layout = CLUTTER_GRID_LAYOUT (clutter_actor_get_layout_manager (box));
switch (clutter_event_get_key_symbol (event))
{
case CLUTTER_KEY_c:
toggle = clutter_grid_layout_get_column_homogeneous (layout);
clutter_grid_layout_set_column_homogeneous (layout, !toggle);
break;
case CLUTTER_KEY_r:
toggle = clutter_grid_layout_get_row_homogeneous (layout);
clutter_grid_layout_set_row_homogeneous (layout, !toggle);
break;
case CLUTTER_KEY_s:
spacing = clutter_grid_layout_get_column_spacing (layout);
if (spacing < 12)
spacing += 1;
else
spacing = 0;
clutter_grid_layout_set_column_spacing (layout, spacing);
clutter_grid_layout_set_row_spacing (layout, spacing);
break;
case CLUTTER_KEY_q:
clutter_main_quit ();
break;
default:
return FALSE;
}
return TRUE;
}
gboolean Platform::stageEvent(ClutterStage * stage, ClutterEvent * event, gpointer ui)
{
g_print("stageEvent\n");
switch (event->type) {
case CLUTTER_KEY_PRESS: {
guint keyval = clutter_event_get_key_symbol (event);
switch(keyval) {
case CLUTTER_q:
case CLUTTER_Escape:
clutter_main_quit ();
return TRUE;
}
break;
}
}
return FALSE;
}
static void
completed_cb (ClutterTimeline *timeline,
TestState *state)
{
state->completion_count++;
if (state->completion_count == 2)
{
if (state->passed)
{
g_test_message ("Passed\n");
clutter_main_quit ();
}
else
{
g_test_message ("Failed\n");
exit (EXIT_FAILURE);
}
}
}
static void
filter_model (ClutterModel *model)
{
ClutterModelIter *iter;
g_print ("\n* Filter function: even rows\n");
clutter_model_set_filter (model, filter_func, NULL, NULL);
iter = clutter_model_get_first_iter (model);
while (!clutter_model_iter_is_last (iter))
{
print_iter (iter, "Filtered Forward Iteration");
iter = clutter_model_iter_next (iter);
}
g_object_unref (iter);
g_print ("\n* Sorting function: reverse alpha\n");
clutter_model_set_sort (model, COLUMN_BAR, sort_func, NULL, NULL);
g_signal_connect (model, "row-changed", G_CALLBACK (on_row_changed), NULL);
iter = clutter_model_get_iter_at_row (model, 0);
clutter_model_iter_set (iter, COLUMN_BAR, "Changed string of 0th row, "
"automatically gets sorted",
-1);
g_object_unref (iter);
clutter_model_foreach (model, foreach_func, NULL);
g_print ("\n* Unset filter\n");
clutter_model_set_filter (model, NULL, NULL, NULL);
while (clutter_model_get_n_rows (model))
clutter_model_remove (model, 0);
clutter_main_quit ();
}
static void
on_key_release_event (ClutterStage *stage,
ClutterEvent *event,
gpointer null)
{
static gint i = 0;
switch (clutter_key_event_symbol ((ClutterKeyEvent*)event))
{
case CLUTTER_Escape:
clutter_main_quit ();
break;
case CLUTTER_Left:
i--;
if (i == 0)
i = 359;
clutter_actor_set_rotation (CLUTTER_ACTOR (stage), CLUTTER_Y_AXIS, i,
CLUTTER_STAGE_WIDTH ()/2,
0,
CLUTTER_STAGE_HEIGHT ());
break;
case CLUTTER_Right:
i++;
if (i == 360)
i = 0;
clutter_actor_set_rotation (CLUTTER_ACTOR (stage), CLUTTER_Y_AXIS, i,
CLUTTER_STAGE_WIDTH ()/2,
0,
CLUTTER_STAGE_HEIGHT ());
break;
case CLUTTER_Up:
if (!clutter_timeline_is_playing (timeline))
clutter_timeline_start (timeline);
break;
default:
break;
}
}
