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;
}
void App::toggleFullscreen()
{
fullscreen_ = ! fullscreen_;
if (verbose_)
std::cout << "App::" << __FUNCTION__ << ": " << fullscreen_ << std::endl;
if (fullscreen_)
clutter_stage_set_fullscreen(CLUTTER_STAGE(stage_), TRUE);
else
clutter_stage_set_fullscreen(CLUTTER_STAGE(stage_), FALSE);
}
static void
toggle_fullscreen (UserInterface * ui)
{
if (ui->fullscreen) {
clutter_stage_set_fullscreen (CLUTTER_STAGE (ui->stage), FALSE);
ui->fullscreen = FALSE;
} else {
clutter_stage_set_fullscreen (CLUTTER_STAGE (ui->stage), TRUE);
ui->fullscreen = TRUE;
}
}
G_MODULE_EXPORT int
test_fullscreen_main (int argc, char *argv[])
{
ClutterActor *stage;
clutter_init (&argc, &argv);
stage = clutter_stage_get_default ();
g_signal_connect (stage,
"fullscreen", G_CALLBACK (on_fullscreen),
NULL);
g_signal_connect (stage,
"unfullscreen", G_CALLBACK (on_unfullscreen),
NULL);
clutter_stage_set_fullscreen (CLUTTER_STAGE (stage), TRUE);
clutter_actor_show (stage);
g_debug ("stage size: %.2fx%.2f, mapped: %s",
clutter_actor_get_width (stage),
clutter_actor_get_height (stage),
CLUTTER_ACTOR_IS_MAPPED (stage) ? "true" : "false");
g_timeout_add (1000, toggle_fullscreen, NULL);
clutter_main ();
return EXIT_SUCCESS;
}
static void
fullscreen_cb (MxToggle *toggle,
GParamSpec *pspec,
ClutterStage *stage)
{
clutter_stage_set_fullscreen (stage, mx_toggle_get_active (toggle));
}
void
show_message (void)
{
ClutterActor *stage, *label;
ClutterColor black = { 0, 0, 0, 255 };
ClutterColor white = { 255, 255, 255, 255 };
clutter_init (NULL, NULL);
stage = clutter_stage_get_default ();
clutter_stage_set_color (CLUTTER_STAGE (stage), &black);
clutter_stage_set_fullscreen (CLUTTER_STAGE (stage), TRUE);
label = clutter_text_new_with_text ("Sans 20",
"Cannot find suitable screen mode\n"
"Media Explorer requires a 720p screen");
clutter_text_set_line_wrap (CLUTTER_TEXT (label), TRUE);
clutter_text_set_color (CLUTTER_TEXT (label), &white);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), label);
/* Put the label in the middle */
clutter_actor_add_constraint
(label, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0.5));
clutter_actor_add_constraint
(label, clutter_align_constraint_new (stage, CLUTTER_ALIGN_Y_AXIS, 0.5));
clutter_actor_show (stage);
clutter_main ();
}
ClutterActor *
new_stage(void){
static const ClutterColor black = {0, 0, 0, 255};
ClutterActor *stage = clutter_stage_get_default();
clutter_stage_set_color(CLUTTER_STAGE(stage), &black);
clutter_stage_set_fullscreen(CLUTTER_STAGE(stage), TRUE);
clutter_stage_hide_cursor(CLUTTER_STAGE(stage));
return stage;
}
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;
}
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;
}
static gboolean
blue_button_cb (ClutterActor *actor,
ClutterEvent *event,
gpointer data)
{
ClutterActor *stage;
stage = clutter_actor_get_stage (actor);
if (IsFullScreen)
IsFullScreen = FALSE;
else
IsFullScreen = TRUE;
clutter_stage_set_fullscreen (CLUTTER_STAGE (stage), IsFullScreen);
g_print ("*** Fullscreen %s ***\n",
IsFullScreen ? "enabled" : "disabled");
return FALSE;
}
static gboolean
toggle_fullscreen (gpointer dummy)
{
ClutterActor *stage = clutter_stage_get_default ();
gboolean is_fullscreen = FALSE;
g_object_get (G_OBJECT (stage), "fullscreen-set", &is_fullscreen, NULL);
switch (state)
{
case START:
g_debug ("start: is_fullscreen := %s", is_fullscreen ? "true" : "false");
clutter_actor_hide (stage);
state = HIDE;
return TRUE;
case HIDE:
g_debug ("hide: is_fullscreen := %s", is_fullscreen ? "true" : "false");
clutter_actor_show (stage);
state = SHOW;
return TRUE;
case SHOW:
g_debug ("show: is_fullscreen := %s", is_fullscreen ? "true" : "false");
clutter_stage_set_fullscreen (CLUTTER_STAGE (stage), FALSE);
state = DONE;
return TRUE;
case DONE:
g_debug ("done: is_fullscreen := %s", is_fullscreen ? "true" : "false");
clutter_main_quit ();
break;
}
return FALSE;
}
int main(int argc, char *argv[])
{
ClutterTimeline *timeline;
ClutterActor *stage;
if (argc < 1)
{
g_error ("Usage: %s", argv[0]);
return EXIT_FAILURE;
}
else
{
GError *error = NULL;
GOptionContext *context;
context = g_option_context_new (PROGRAM_DESC);
g_option_context_add_main_entries (context, entries, NULL); //GETTEXT_PACKAGE);
//g_option_context_add_group (context, gtk_get_option_group (TRUE));
if (! g_option_context_parse (context, &argc, &argv, &error))
{
g_print ("option parsing failed: %s\n", error->message);
return EXIT_FAILURE; // exit (1);
}
}
if (option_version)
{
g_print("contextize version %s\n", PACKAGE_VERSION);
return 0;
}
g_thread_init(NULL); // to load images asynchronously. must be called before clutter_init
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
{
g_error ("Failed to initialize clutter\n");
return EXIT_FAILURE;
}
gst_init (&argc, &argv);
stage = clutter_stage_get_default ();
clutter_actor_set_size(stage, STAGE_WIDTH, STAGE_HEIGHT);
clutter_stage_set_color(CLUTTER_STAGE(stage), &black);
clutter_stage_set_title(CLUTTER_STAGE(stage), STAGE_TITLE);
/* Make a timeline */
timeline = clutter_timeline_new (1000);
g_object_set(timeline, "loop", TRUE, NULL);
ClutterActor *texture_live = setup_camera_texture(stage);
// create the layout
ClutterLayoutManager *layout;
ClutterActor *box;
layout = clutter_bin_layout_new(CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_BIN_ALIGNMENT_CENTER);
box = clutter_box_new(layout); /* then the container */
clutter_actor_set_name(box, BOX_ACTOR);
/* we can use the layout object to add actors */
clutter_bin_layout_add(CLUTTER_BIN_LAYOUT(layout), texture_live,
CLUTTER_BIN_ALIGNMENT_FILL,
CLUTTER_BIN_ALIGNMENT_FILL);
clutter_container_add_actor(CLUTTER_CONTAINER(stage), box);
clutter_actor_set_size(box, STAGE_WIDTH, STAGE_HEIGHT);
clutter_actor_show_all(box);
g_signal_connect(G_OBJECT(stage), "fullscreen", G_CALLBACK(on_fullscreen), NULL);
g_signal_connect(G_OBJECT(stage), "unfullscreen", G_CALLBACK(on_unfullscreen), NULL);
g_signal_connect(G_OBJECT(stage), "key-press-event", G_CALLBACK(key_press_event), NULL);
/* start the timeline */
clutter_timeline_start (timeline);
clutter_actor_show_all (stage);
if (option_fullscreen)
clutter_stage_set_fullscreen(CLUTTER_STAGE(stage), TRUE);
// OSC server
lo_server_thread osc_server = NULL;
if (option_osc_receive_port != 0)
{
gchar *osc_port_str = g_strdup_printf("%i", option_osc_receive_port);
if (option_verbose)
g_print("Listening on osc.udp://localhost:%s\n", osc_port_str);
osc_server = lo_server_thread_new(osc_port_str, on_osc_error);
g_free(osc_port_str);
lo_server_thread_start(osc_server);
}
clutter_main();
if (option_osc_receive_port != 0)
lo_server_thread_free(osc_server);
return EXIT_SUCCESS;
}
int
main (int argc, char *argv[])
{
ClutterActor *video;
/* So we can fade out at the end. */
clutter_x11_set_use_argb_visual (TRUE);
if (clutter_gst_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return EXIT_FAILURE;
if (argc < 2)
{
g_print ("Usage: %s [OPTIONS] <video file>\n", argv[0]);
return EXIT_FAILURE;
}
if (!clutter_color_from_string (&bg_color, BG_COLOR))
{
g_warning ("Invalid BG_COLOR");
exit (1);
}
stage = clutter_stage_new ();
/* Clutter's full-screening code does not allow us to
* set both that and _NET_WM_STATE_ABOVE, so do the state
* management ourselves for now. */
#if 0
clutter_stage_set_fullscreen (CLUTTER_STAGE (stage), TRUE);
#endif
/* Clutter will set maximum size restrictions (meaning not
* full screen) unless I set this. */
clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
clutter_stage_set_use_alpha (CLUTTER_STAGE (stage), TRUE);
clutter_actor_set_background_color (stage, &bg_color);
clutter_actor_set_layout_manager (stage,
clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_FIXED,
CLUTTER_BIN_ALIGNMENT_FIXED));
clutter_actor_realize (stage);
set_above_and_fullscreen ();
video = clutter_gst_video_texture_new ();
clutter_actor_set_x_expand (video, TRUE);
clutter_actor_set_y_expand (video, TRUE);
clutter_actor_set_x_align (video, CLUTTER_ACTOR_ALIGN_CENTER);
clutter_actor_set_y_align (video, CLUTTER_ACTOR_ALIGN_CENTER);
set_idle_material (CLUTTER_GST_VIDEO_TEXTURE (video));
g_signal_connect (video,
"eos",
G_CALLBACK (on_video_texture_eos),
NULL);
g_signal_connect (stage,
"destroy",
G_CALLBACK (clutter_main_quit),
NULL);
clutter_media_set_filename (CLUTTER_MEDIA (video), argv[1]);
clutter_stage_hide_cursor (CLUTTER_STAGE (stage));
clutter_actor_add_child (stage, video);
g_signal_connect (stage, "key-press-event", G_CALLBACK (key_press_cb), NULL);
clutter_media_set_playing (CLUTTER_MEDIA (video), TRUE);
clutter_actor_show (stage);
clutter_main ();
return EXIT_SUCCESS;
}
void
interface_start (UserInterface * ui, gchar * uri)
{
ClutterColor stage_color = { 0x00, 0x00, 0x00, 0x00 };
g_print ("Loading ui!\n");
// Init UserInterface structure variables
ui->fileuri = uri;
ui->filename = g_path_get_basename (ui->fileuri);
ui->media_width = ui->engine->media_width;
ui->media_height = ui->engine->media_height;
ui->stage_width = ui->engine->media_width;
ui->stage_height = ui->engine->media_height;
ui->stage = clutter_stage_get_default ();
ui->controls_showing = FALSE;
ui->keep_showing_controls = FALSE;
ui->penalty_box_active = FALSE;
ui->controls_timeout = -1;
ui->seek_width = ui->stage_width / SEEK_WIDTH_RATIO;
ui->seek_height = ui->stage_height / SEEK_HEIGHT_RATIO;
ui->progress_id = -1;
ui->title_length = TITLE_LENGTH;
ui->duration_str = position_ns_to_str (ui->engine->media_duration);
ui->rotated = FALSE;
clutter_stage_set_color (CLUTTER_STAGE (ui->stage), &stage_color);
clutter_stage_set_minimum_size (CLUTTER_STAGE (ui->stage),
ui->stage_width, ui->stage_height);
clutter_stage_set_title (CLUTTER_STAGE (ui->stage), ui->filename);
clutter_actor_set_size (CLUTTER_ACTOR (ui->stage), ui->stage_width,
ui->stage_height);
if (ui->fullscreen) {
clutter_stage_set_fullscreen (CLUTTER_STAGE (ui->stage), TRUE);
}
// Controls
load_controls (ui);
// Add video texture and control UI to stage
clutter_container_add (CLUTTER_CONTAINER (ui->stage), ui->texture,
ui->control_box, NULL);
clutter_stage_hide_cursor (CLUTTER_STAGE (ui->stage));
clutter_actor_animate (ui->control_box, CLUTTER_EASE_OUT_QUINT, SECOND,
"opacity", 0, NULL);
g_signal_connect (CLUTTER_STAGE (ui->stage), "fullscreen",
G_CALLBACK (size_change), ui);
g_signal_connect (CLUTTER_STAGE (ui->stage), "unfullscreen",
G_CALLBACK (size_change), ui);
g_signal_connect (ui->stage, "event", G_CALLBACK (event_cb), ui);
clutter_actor_set_anchor_point_from_gravity (CLUTTER_ACTOR (ui->texture),
CLUTTER_GRAVITY_CENTER);
clutter_actor_set_position (CLUTTER_ACTOR (ui->texture), ui->stage_width / 2,
ui->stage_height / 2);
center_controls (ui);
progress_timing (ui);
ui->screensaver = screensaver_new (CLUTTER_STAGE (ui->stage));
screensaver_enable (ui->screensaver, FALSE);
g_timeout_add (SECOND, progress_update_text, ui);
clutter_actor_show (ui->stage);
}
/*
Called whenever the fullscreen button is clicked
*/
void WindowPanel::fullscreen_clicked() {
clutter_stage_set_fullscreen(CLUTTER_STAGE(clutter_stage_get_default()),
!clutter_stage_get_fullscreen(CLUTTER_STAGE(clutter_stage_get_default())));
}
int
main (int argc, char **argv)
{
ClutterActor *stage;
ClutterActor *fader;
ClutterConstraint *constraint;
CoglHandle tex0, tex1;
GError *error = NULL;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
if (argc != 3)
{
g_print ("usage: %s <image1> <image2>\n",
argv[0]);
return 1;
}
tex0 = cogl_texture_new_from_file (argv[1],
COGL_TEXTURE_NO_SLICING |
COGL_TEXTURE_NO_ATLAS,
COGL_PIXEL_FORMAT_ANY,
&error);
if (tex0 == COGL_INVALID_HANDLE)
{
g_print ("error opening %s: %s\n", argv[1], error->message);
g_clear_error (&error);
return 1;
}
tex1 = cogl_texture_new_from_file (argv[2],
COGL_TEXTURE_NO_SLICING |
COGL_TEXTURE_NO_ATLAS,
COGL_PIXEL_FORMAT_ANY,
&error);
if (tex1 == COGL_INVALID_HANDLE)
{
cogl_handle_unref (tex0);
g_print ("error opening %s: %s\n", argv[2], error->message);
g_clear_error (&error);
return 1;
}
fader = foo_fader_new ();
foo_fader_set_texture_0 (FOO_FADER (fader), tex0);
foo_fader_set_texture_1 (FOO_FADER (fader), tex1);
cogl_handle_unref (tex0);
cogl_handle_unref (tex1);
stage = clutter_stage_get_default ();
clutter_stage_set_fullscreen (CLUTTER_STAGE (stage), TRUE);
g_signal_connect (stage, "button-press-event",
G_CALLBACK (button_press_event_cb),
fader);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), fader);
constraint =
clutter_bind_constraint_new (stage,
CLUTTER_BIND_SIZE,
0.0f);
clutter_actor_add_constraint (fader, constraint);
/* massive hack --- nothing to see here! */
foo_fader_set_progress (FOO_FADER (fader), 0.00001f);
clutter_actor_show (stage);
clutter_main ();
return 0;
}
