static gboolean
stage_motion_event_cb (ClutterActor *stage, ClutterEvent *event, ClutterActor *controls)
{
if (g_object_get_data (G_OBJECT (controls), "cursor-in-controls") != NULL) {
rb_debug ("bleep");
return FALSE;
}
clutter_stage_show_cursor (CLUTTER_STAGE (stage));
clutter_actor_show (controls);
stop_hide_timer (controls);
start_hide_timer (controls);
return FALSE;
}
bool StageManager::initStage()
{
stage_ = clutter_stage_get_default();
float width = (float) getAttribute("size").getInt(0);
float height =(float) getAttribute("size").getInt(1);
clutter_actor_set_size(stage_, width, height);
clutter_stage_set_color(CLUTTER_STAGE(stage_), &black);
g_signal_connect(stage_, "destroy", G_CALLBACK(on_stage_destroyed), (gpointer) this);
std::string filename = getAttribute("script").getString(0);
GError *error = NULL;
/* load JSON from a file */
ClutterScript *script = clutter_script_new();
clutter_script_load_from_file(script, filename.c_str(), &error);
if (error != NULL)
{
std::cerr << "Unable to read file: " << error->message << std::endl;
g_error_free(error);
// TODO: fail
g_critical("Could not load GUI");
return false;
}
ClutterActor *group0 = CLUTTER_ACTOR(clutter_script_get_object(script, "group0")); // TODO: rename to root
clutter_container_add_actor(CLUTTER_CONTAINER(stage_), group0);
//clutter_script_connect_signals(script, this);
clutter_script_connect_signals_full(script, tempi_clutter_connect_signals, this);
// timeline to attach a callback for each frame that is rendered
ClutterTimeline *timeline;
timeline = clutter_timeline_new(60); // ms
clutter_timeline_set_loop(timeline, TRUE);
clutter_timeline_start(timeline);
g_signal_connect(timeline, "new-frame", G_CALLBACK(on_frame_cb), this);
g_signal_connect(stage_, "key-press-event", G_CALLBACK(key_event_cb), this);
g_object_unref(script); // avoid memory leak
clutter_actor_show(stage_);
if (CLUTTER_IS_ACTOR(stage_))
return true;
else
return false;
}
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);
}
static void
mex_content_box_notify_open_cb (MexExpanderBox *box,
GParamSpec *pspec)
{
GList *actions;
ClutterStage *stage = CLUTTER_STAGE (
clutter_actor_get_stage (CLUTTER_ACTOR (box)));
MxFocusManager *fmanager = mx_focus_manager_get_for_stage (stage);
MexActionManager *manager = mex_action_manager_get_default ();
MexContentBoxPrivate *priv = MEX_CONTENT_BOX (box)->priv;
gboolean open = mex_expander_box_get_open (box);
if (!open)
{
/* If the action list has focus, push it back onto the tile */
if (mex_actor_has_focus (fmanager, priv->action_list))
mx_focus_manager_push_focus (fmanager, MX_FOCUSABLE (priv->tile));
return;
}
/* Refresh the info panel and the action list */
mex_content_view_set_content (MEX_CONTENT_VIEW (priv->panel), priv->content);
mex_action_list_refresh (MEX_ACTION_LIST (priv->action_list));
/* See if we have any actions */
actions = mex_action_manager_get_actions_for_content (manager,
priv->content);
/* Push focus onto the action list if we have actions, otherwise onto
* the tile.
*/
if (actions)
{
clutter_actor_show (priv->action_list);
mx_focus_manager_push_focus (fmanager,
MX_FOCUSABLE (priv->action_list));
g_list_free (actions);
}
else
{
clutter_actor_hide (priv->action_list);
mx_focus_manager_push_focus (fmanager, MX_FOCUSABLE (priv->tile));
}
}
static ClutterTransition *
get_error_message_transition (CalibArea *area)
{
ClutterTransition *transition;
clutter_actor_show (area->error_text);
transition = clutter_property_transition_new ("opacity");
clutter_timeline_set_progress_mode (CLUTTER_TIMELINE (transition),
CLUTTER_EASE_OUT);
clutter_timeline_set_duration (CLUTTER_TIMELINE (transition),
ERROR_MESSAGE_ANIMATION_DURATION);
clutter_transition_set_animatable (transition,
CLUTTER_ANIMATABLE (area->error_text));
clutter_transition_set_from (transition, G_TYPE_UINT, 0);
clutter_transition_set_to (transition, G_TYPE_UINT, 255);
return transition;
}
void
mpl_application_view_set_subtitle (MplApplicationView *view,
const gchar *text)
{
MplApplicationViewPrivate *priv;
g_return_if_fail (MPL_IS_APPLICATION_VIEW (view));
priv = view->priv;
mx_label_set_text (MX_LABEL (priv->subtitle), text);
if (!strcmp (mx_label_get_text (MX_LABEL (priv->title)),
mx_label_get_text (MX_LABEL (priv->subtitle))))
clutter_actor_hide (priv->subtitle);
else
clutter_actor_show (priv->subtitle);
}
static gboolean
_show_settings_dialog_cb (ClutterActor *actor, MexInfoBar *self)
{
MexInfoBarPrivate *priv = self->priv;
if (!priv->settings_dialog_parented)
{
ClutterActor *stage;
stage = clutter_actor_get_stage (CLUTTER_ACTOR (self));
mx_dialog_set_transient_parent (MX_DIALOG (priv->settings_dialog), stage);
priv->settings_dialog_parented = TRUE;
}
clutter_actor_show (priv->settings_dialog);
return TRUE;
}
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;
}
void
test_pick (TestConformSimpleFixture *fixture,
gconstpointer data)
{
int y, x;
State state;
state.pass = TRUE;
state.stage = clutter_stage_get_default ();
clutter_actor_set_size (state.stage, STAGE_WIDTH, STAGE_HEIGHT);
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 };
ClutterGeometry geom = { x * state.actor_width, y * state.actor_height,
state.actor_width, state.actor_height };
ClutterActor *rect = clutter_rectangle_new_with_color (&color);
clutter_actor_set_geometry (rect, &geom);
clutter_container_add (CLUTTER_CONTAINER (state.stage), rect, NULL);
state.gids[y * ACTORS_X + x] = clutter_actor_get_gid (rect);
}
clutter_actor_show (state.stage);
g_timeout_add (250, (GSourceFunc) on_timeout, &state);
clutter_main ();
if (g_test_verbose ())
g_print ("end result: %s\n", state.pass ? "pass" : "FAIL");
g_assert (state.pass);
}
static gboolean
handle_xembed_event (ClutterBackendX11 *backend_x11,
XEvent *xevent)
{
ClutterActor *stage;
stage = clutter_stage_get_default ();
switch (xevent->xclient.data.l[1])
{
case XEMBED_EMBEDDED_NOTIFY:
CLUTTER_NOTE (EVENT, "got XEMBED_EMBEDDED_NOTIFY from %lx",
xevent->xclient.data.l[3]);
ParentEmbedderWin = xevent->xclient.data.l[3];
clutter_actor_realize (stage);
clutter_actor_show (stage);
xembed_set_info (backend_x11,
clutter_x11_get_stage_window (CLUTTER_STAGE (stage)),
XEMBED_MAPPED);
break;
case XEMBED_WINDOW_ACTIVATE:
CLUTTER_NOTE (EVENT, "got XEMBED_WINDOW_ACTIVATE");
break;
case XEMBED_WINDOW_DEACTIVATE:
CLUTTER_NOTE (EVENT, "got XEMBED_WINDOW_DEACTIVATE");
break;
case XEMBED_FOCUS_IN:
CLUTTER_NOTE (EVENT, "got XEMBED_FOCUS_IN");
if (ParentEmbedderWin)
xembed_send_message (backend_x11, ParentEmbedderWin,
XEMBED_FOCUS_NEXT,
0, 0, 0);
break;
default:
CLUTTER_NOTE (EVENT, "got unknown XEMBED message");
break;
}
/* do not propagate the XEMBED events to the stage */
return FALSE;
}
bool App::launch()
{
if (osc_recv_port_ == 0)
if (verbose_)
std::cout << "OSC receiving disabled." << std::endl;
else
startOSC();
// Poll OSC receiver only when we render a Clutter frame.
if (stage_)
{
std::cerr << "cannot create stage twice" << std::endl;
//return false;
}
stage_ = clutter_stage_get_default();
clutter_actor_set_size(stage_, 1024, 768);
ClutterColor black = { 0x00, 0x00, 0x00, 0xff };
clutter_stage_set_color(CLUTTER_STAGE(stage_), &black);
g_signal_connect(stage_, "destroy", G_CALLBACK(clutter_main_quit), NULL);
clutter_actor_set_reactive(stage_, TRUE);
// timeline to attach a callback for each frame that is rendered
ClutterTimeline *timeline;
timeline = clutter_timeline_new(60); // ms
clutter_timeline_set_loop(timeline, TRUE);
clutter_timeline_start(timeline);
g_signal_connect(timeline, "new-frame", G_CALLBACK(on_frame_cb), this);
g_signal_connect(stage_, "key-press-event", G_CALLBACK(key_event_cb), this);
g_signal_connect(stage_, "button-press-event", G_CALLBACK(button_press_cb), this);
g_signal_connect(stage_, "button-release-event", G_CALLBACK(button_released_cb), this);
g_signal_connect(stage_, "motion-event", G_CALLBACK(motion_event_cb), this);
if (fullscreen_)
{
fullscreen_ = false;
toggleFullscreen();
}
createPalette();
clutter_actor_show(stage_);
return true;
}
static gboolean
show_stage (MetaPlugin *plugin)
{
MetaScreen *screen;
ClutterActor *stage;
screen = meta_plugin_get_screen (plugin);
stage = meta_get_stage_for_screen (screen);
clutter_actor_show (stage);
/* Set up our own keybinding overrides */
meta_keybindings_set_custom_handler(BUDGIE_KEYBINDING_MAIN_MENU,
budgie_launch_menu, NULL, NULL);
meta_keybindings_set_custom_handler(BUDGIE_KEYBINDING_RUN_DIALOG,
budgie_launch_rundialog, NULL, NULL);
return FALSE;
}
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);
}
gboolean meta_switcher_show(MetaSwitcher* self)
{
MetaSwitcherPrivate* priv = self->priv;
int screen_width, screen_height;
MetaScreen* screen = meta_plugin_get_screen(priv->plugin);
priv->workspace = meta_screen_get_active_workspace(screen);
meta_screen_get_size(screen, &screen_width, &screen_height);
meta_switcher_present_list(self);
if (priv->apps == NULL || priv->apps->len == 0) goto _end;
_capture_desktop(self);
clutter_content_invalidate(clutter_actor_get_content(priv->top));
ClutterActor* stage = meta_get_stage_for_screen(screen);
clutter_actor_insert_child_above(stage, priv->top, NULL);
clutter_actor_show(priv->top);
if (!meta_plugin_begin_modal(priv->plugin, 0, clutter_get_current_event_time())) {
if (!meta_plugin_begin_modal(priv->plugin, META_MODAL_POINTER_ALREADY_GRABBED,
clutter_get_current_event_time())) {
g_warning("can not be modal");
goto _end;
}
}
meta_disable_unredirect_for_screen(screen);
priv->modaled = TRUE;
priv->previous_focused = clutter_stage_get_key_focus(CLUTTER_STAGE(stage));
if (priv->previous_focused == stage) priv->previous_focused = NULL;
clutter_stage_set_key_focus(CLUTTER_STAGE(stage), priv->top);
clutter_actor_grab_key_focus(priv->top);
return TRUE;
_end:
clutter_actor_hide(priv->top);
return FALSE;
}
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;
}
void xfdashboard_text_box_set_secondary_icon(XfdashboardTextBox *self, const gchar *inIconName)
{
XfdashboardTextBoxPrivate *priv;
g_return_if_fail(XFDASHBOARD_IS_TEXT_BOX(self));
g_return_if_fail(!inIconName || strlen(inIconName)>0);
priv=self->priv;
/* Set themed icon name or icon file name for primary icon */
if(g_strcmp0(priv->secondaryIconName, inIconName)!=0)
{
/* Set new primary icon name */
if(priv->secondaryIconName)
{
g_free(priv->secondaryIconName);
priv->secondaryIconName=NULL;
}
if(inIconName)
{
/* Load and set new icon */
priv->secondaryIconName=g_strdup(inIconName);
xfdashboard_button_set_icon(XFDASHBOARD_BUTTON(priv->actorSecondaryIcon), priv->secondaryIconName);
/* Show icon */
priv->showSecondaryIcon=TRUE;
clutter_actor_show(priv->actorSecondaryIcon);
clutter_actor_queue_relayout(CLUTTER_ACTOR(self));
}
else
{
/* Hide icon */
priv->showSecondaryIcon=FALSE;
clutter_actor_hide(priv->actorSecondaryIcon);
clutter_actor_queue_relayout(CLUTTER_ACTOR(self));
}
/* Notify about property change */
g_object_notify_by_pspec(G_OBJECT(self), XfdashboardTextBoxProperties[PROP_SECONDARY_ICON_NAME]);
}
}
static void
key_focus_in_cb (ClutterActor *actor,
gpointer data)
{
ClutterActor *focus_box = CLUTTER_ACTOR (data);
if (CLUTTER_IS_STAGE (actor))
clutter_actor_hide (focus_box);
else
{
clutter_actor_set_position (focus_box,
clutter_actor_get_x (actor) - 5,
clutter_actor_get_y (actor) - 5);
clutter_actor_set_size (focus_box,
clutter_actor_get_width (actor) + 10,
clutter_actor_get_height (actor) + 10);
clutter_actor_show (focus_box);
}
}
void
glide_window_paste_action_activate (GtkAction *a,
gpointer user_data)
{
GlideWindow *w = (GlideWindow *)user_data;
GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
if (w->priv->copy_buffer)
{
GlideActor *n = glide_window_construct_copy_buffer (w);
glide_stage_manager_add_actor (w->priv->manager, n);
clutter_actor_show (CLUTTER_ACTOR (n));
return;
}
gtk_clipboard_request_targets (clipboard, glide_window_paste_targets_received, w);
}
gint
main (int argc,
char *argv[])
{
ClutterActor *stage;
clutter_init (&argc, &argv);
stage = clutter_stage_get_default ();
custom_cursor (0, 0, 0);
gcr_prepare ("/tmp/test.mpg");
clutter_actor_show (stage);
gcr_start ();
clutter_main ();
gcr_stop ();
return 0;
}
static void
child_adjustment_changed_cb (TidyAdjustment *adjustment,
ClutterActor *bar)
{
TidyScrollView *scroll;
ClutterFixed lower, upper, page_size;
scroll = TIDY_SCROLL_VIEW (clutter_actor_get_parent (bar));
/* Determine if this scroll-bar should be visible */
tidy_adjustment_get_valuesx (adjustment, NULL, &lower, &upper,
NULL, NULL, &page_size);
if ((upper - lower) > page_size)
clutter_actor_show (bar);
else
clutter_actor_hide (bar);
/* Request a resize */
tidy_scroll_view_request_coords (CLUTTER_ACTOR (scroll), &scroll->priv->box);
}
static gboolean
create_actor (GstGLClutterActor * actor)
{
static gint xpos = 0;
static gint ypos = 0;
actor->texture = g_object_new (CLUTTER_X11_TYPE_TEXTURE_PIXMAP,
"window", actor->win, "automatic-updates", TRUE, NULL);
clutter_container_add_actor (CLUTTER_CONTAINER (actor->stage),
actor->texture);
clutter_actor_set_position (actor->texture, xpos, ypos);
if (xpos > (COLS - 1) * W) {
xpos = 0;
ypos += H + 1;
} else
xpos += W + 1;
clutter_actor_show (actor->texture);
return FALSE;
}
void show_image(XImage *img)
{
ClutterActor *stage, *actor;
// init stage
clutter_init(0, NULL);
stage = clutter_stage_get_default(); // XX TODO: use root window?
// init actor
actor = clutter_texture_new();
clutter_texture_set_from_rgb_data(CLUTTER_TEXTURE(actor), img->data, False, img->width, img->height, img->bytes_per_line, 4, (ClutterTextureFlags)0, NULL);
clutter_container_add(CLUTTER_CONTAINER(stage), actor, NULL);
clutter_actor_set_position(actor, 10, 10);
g_signal_connect(stage, "button-press-event", clutter_main_quit, NULL);
// show and wait for exit
clutter_actor_show(stage);
clutter_main();
}
static void
setup_standalone (DawatiStatusPanel *status_panel)
{
ClutterActor *stage, *status;
Window xwin;
status = make_status (status_panel);
clutter_actor_set_size (status, 1000, 600);
stage = clutter_stage_new ();
clutter_actor_set_size (stage, 1000, 600);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), status);
clutter_actor_realize (stage);
xwin = clutter_x11_get_stage_window (CLUTTER_STAGE (stage));
mpl_panel_clutter_setup_events_with_gtk_for_xid (xwin);
clutter_actor_show (stage);
}
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);
}
static void
mex_telepathy_channel_conference_added (TfChannel *channel,
GstElement *conference,
gpointer user_data)
{
MexTelepathyChannel *self = MEX_TELEPATHY_CHANNEL (user_data);
MexTelepathyChannelPrivate *priv = self->priv;
GKeyFile *keyfile;
MEX_INFO ("Conference added");
/* Add notifier to set the various element properties as needed */
keyfile = fs_utils_get_default_element_properties (conference);
if (keyfile != NULL)
{
FsElementAddedNotifier *notifier;
MEX_INFO ("Loaded default codecs for %s", GST_ELEMENT_NAME (conference));
notifier = fs_element_added_notifier_new ();
fs_element_added_notifier_set_properties_from_keyfile (notifier, keyfile);
fs_element_added_notifier_add (notifier, GST_BIN (priv->pipeline));
priv->notifiers = g_list_prepend (priv->notifiers, notifier);
}
gst_bin_add (GST_BIN (priv->pipeline), conference);
gst_element_set_state (conference, GST_STATE_PLAYING);
if (CLUTTER_IS_ACTOR (priv->video_call_page))
{
g_signal_emit (self,
mex_telepathy_channel_signals[SHOW_ACTOR],
0,
g_object_ref (priv->video_call_page));
clutter_actor_show (priv->busy_box);
clutter_actor_raise_top (priv->busy_box);
}
else
priv->show_page = TRUE;
}
int
main (int argc, char *argv[])
{
ClutterActor *stage;
ClutterActor *texture;
GError *error = NULL;
ClutterActor *clone;
gfloat y_offset;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
stage = clutter_stage_new ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Reflection");
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
texture = clutter_texture_new ();
clutter_texture_set_from_file (CLUTTER_TEXTURE (texture),
"redhand.png",
&error);
clutter_actor_add_constraint (texture, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0.5));
clutter_actor_add_constraint (texture, clutter_align_constraint_new (stage, CLUTTER_ALIGN_Y_AXIS, 0.2));
y_offset = clutter_actor_get_height (texture) + V_PADDING;
clone = clutter_clone_new (texture);
clutter_actor_add_constraint (clone, clutter_bind_constraint_new (texture, CLUTTER_BIND_X, 0.0));
clutter_actor_add_constraint (clone, clutter_bind_constraint_new (texture, CLUTTER_BIND_Y, y_offset));
g_signal_connect (clone,
"paint",
G_CALLBACK (_clone_paint_cb),
NULL);
clutter_container_add (CLUTTER_CONTAINER (stage), texture, clone, NULL);
clutter_actor_show (stage);
clutter_main ();
return EXIT_SUCCESS;
}
int
main (int argc, char *argv[])
{
ClutterActor *stage;
ClutterScript *ui;
gchar *filename = "script-states.json";
GError *error = NULL;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
ui = clutter_script_new ();
clutter_script_load_from_file (ui, filename, &error);
if (error != NULL)
{
g_critical ("Error loading ClutterScript file %s\n%s", filename, error->message);
g_error_free (error);
exit (EXIT_FAILURE);
}
clutter_script_get_objects (ui,
"stage", &stage,
NULL);
/* make the objects in the script available to all signals
* by passing the script as the second argument
* to clutter_script_connect_signals()
*/
clutter_script_connect_signals (ui, ui);
clutter_actor_show (stage);
clutter_main ();
g_object_unref (ui);
return EXIT_SUCCESS;
}
int
main (int argc, char *argv[])
{
gchar *filename = UI_FILE;
ClutterScript *script;
ClutterActor *stage;
GError *error = NULL;
if (argc > 1)
filename = argv[1];
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
script = clutter_script_new ();
clutter_script_load_from_file (script, filename, &error);
if (error != NULL)
{
g_critical ("Error loading ClutterScript file %s\n%s", filename, error->message);
g_error_free (error);
exit (EXIT_FAILURE);
}
/* connect signal handlers as defined in the script */
clutter_script_connect_signals (script, script);
clutter_script_get_objects (script,
"stage", &stage,
NULL);
clutter_actor_show (stage);
clutter_main ();
g_object_unref (script);
return EXIT_SUCCESS;
}
static void
actor_mapped (void)
{
ClutterActor *actor;
ClutterActor *stage;
stage = clutter_test_get_stage ();
clutter_actor_show (stage);
actor = clutter_actor_new ();
g_assert (!(CLUTTER_ACTOR_IS_REALIZED (actor)));
g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor)));
clutter_actor_add_child (stage, actor);
if (g_test_verbose ())
g_print ("adding to a container should map - "
"visible: %s, realized: %s, mapped: %s\n",
CLUTTER_ACTOR_IS_VISIBLE (actor) ? "yes" : "no",
CLUTTER_ACTOR_IS_REALIZED (actor) ? "yes" : "no",
CLUTTER_ACTOR_IS_MAPPED (actor) ? "yes" : "no");
g_assert (CLUTTER_ACTOR_IS_REALIZED (actor));
g_assert (CLUTTER_ACTOR_IS_MAPPED (actor));
g_assert (CLUTTER_ACTOR_IS_VISIBLE (actor));
clutter_actor_hide (actor);
if (g_test_verbose ())
g_print ("hiding should unmap - "
"visible: %s, realized: %s, mapped: %s\n",
CLUTTER_ACTOR_IS_VISIBLE (actor) ? "yes" : "no",
CLUTTER_ACTOR_IS_REALIZED (actor) ? "yes" : "no",
CLUTTER_ACTOR_IS_MAPPED (actor) ? "yes" : "no");
g_assert (CLUTTER_ACTOR_IS_REALIZED (actor));
g_assert (!CLUTTER_ACTOR_IS_MAPPED (actor));
g_assert (!CLUTTER_ACTOR_IS_VISIBLE (actor));
}
int
main (int argc, char *argv[])
{
ClutterActor *stage;
ClutterActor *actor;
ClutterActor *overlay;
clutter_init (&argc, &argv);
stage = clutter_stage_get_default ();
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);
actor = clutter_rectangle_new_with_color (&red);
clutter_actor_set_size (actor, 100, 100);
clutter_actor_set_position (actor, 150, 150);
overlay = clutter_rectangle_new_with_color (&blue);
g_signal_connect (actor,
"allocation-changed",
G_CALLBACK (allocation_changed_cb),
overlay);
clutter_container_add (CLUTTER_CONTAINER (stage), actor, overlay, NULL);
clutter_actor_animate (actor, CLUTTER_LINEAR, 2000,
"width", 300.0,
"height", 300.0,
"x", 50.0,
"y", 50.0,
NULL);
clutter_actor_show (stage);
clutter_main ();
return EXIT_SUCCESS;
}
