int main(int argc, char *argv[])
{
ClutterColor stage_color = { 0x00, 0x00, 0x00, 0xff };
ClutterColor rect_color = { 0xff, 0xff, 0xff, 0x99 };
clutter_init (&argc, &argv);
/* Get the stage and set its size and color: */
ClutterActor *stage = clutter_stage_get_default ();
clutter_actor_set_size (stage, 200, 200);
clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);
/* Add a rectangle to the stage: */
rect = clutter_rectangle_new_with_color (&rect_color);
clutter_actor_set_size (rect, 40, 40);
clutter_actor_set_position (rect, 10, 10);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), rect);
clutter_actor_show (rect);
/* Show the stage: */
clutter_actor_show (stage);
ClutterTimeline *timeline = clutter_timeline_new(5000 /* milliseconds */);
clutter_timeline_set_loop(timeline, TRUE);
clutter_timeline_start(timeline);
/* Create a clutter alpha for the animation */
ClutterAlpha* alpha = clutter_alpha_new_with_func (timeline, &on_alpha, NULL, NULL);
g_object_unref (timeline);
/* Create an animation to change the properties */
ClutterAnimation* animation =
clutter_actor_animate_with_alpha (rect, alpha,
"x", 150.0,
"y", 150.0,
"opacity", 0,
NULL);
/* Start the main loop, so we can respond to events: */
clutter_main ();
g_object_unref (animation);
return EXIT_SUCCESS;
}
/* object init: create a private structure and pack
* composed ClutterActors into it
*/
static void
cb_button_init (CbButton *self)
{
CbButtonPrivate *priv;
ClutterLayoutManager *layout;
priv = self->priv = CB_BUTTON_GET_PRIVATE (self);
clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE);
/* the only child of this actor is a ClutterBox with a
* ClutterBinLayout: painting and allocation of the actor basically
* involves painting and allocating this child box
*/
layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_BIN_ALIGNMENT_CENTER);
priv->child = clutter_box_new (layout);
/* set the parent of the ClutterBox to this instance */
clutter_actor_set_parent (priv->child,
CLUTTER_ACTOR (self));
/* add text label to the button; see the ClutterText API docs
* for more information about available properties
*/
priv->label = g_object_new (CLUTTER_TYPE_TEXT,
"line-alignment", PANGO_ALIGN_CENTER,
"ellipsize", PANGO_ELLIPSIZE_END,
NULL);
clutter_container_add_actor (CLUTTER_CONTAINER (priv->child),
priv->label);
/* add a ClutterClickAction on this actor, so we can proxy its
* "clicked" signal into a signal from this actor
*/
priv->click_action = clutter_click_action_new ();
clutter_actor_add_action (CLUTTER_ACTOR (self), priv->click_action);
g_signal_connect (priv->click_action,
"clicked",
G_CALLBACK (cb_button_clicked),
NULL);
}
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;
}
static ClutterActor *
_add_from_sw_item (PengeEverythingPane *pane,
SwItem *item)
{
ClutterActor *actor;
actor = g_object_new (PENGE_TYPE_PEOPLE_TILE,
"item", item,
NULL);
clutter_container_add_actor (CLUTTER_CONTAINER (pane), actor);
g_signal_connect (actor,
"remove-clicked",
(GCallback)_people_tile_remove_clicked_cb,
pane);
return actor;
}
int
main (int argc,
char **argv)
{
ClutterActor *stage;
ClutterActor *tile;
clutter_init (&argc, &argv);
stage = clutter_stage_get_default ();
tile = mpd_disk_tile_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (stage), tile);
clutter_actor_show_all (stage);
clutter_main ();
return EXIT_SUCCESS;
}
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);
}
/**
* clutter_box_pack:
* @box: a #ClutterBox
* @actor: a #ClutterActor
* @first_property: the name of the first property to set, or %NULL
* @Varargs: a list of property name and value pairs, terminated by %NULL
*
* Adds @actor to @box and sets layout properties at the same time,
* if the #ClutterLayoutManager used by @box has them
*
* This function is a wrapper around clutter_container_add_actor()
* and clutter_layout_manager_child_set()
*
* Language bindings should use the vector-based clutter_box_addv()
* variant instead
*
* Since: 1.2
*/
void
clutter_box_pack (ClutterBox *box,
ClutterActor *actor,
const gchar *first_property,
...)
{
va_list var_args;
g_return_if_fail (CLUTTER_IS_BOX (box));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
clutter_container_add_actor (CLUTTER_CONTAINER (box), actor);
if (first_property == NULL || *first_property == '\0')
return;
va_start (var_args, first_property);
clutter_box_set_property_valist (box, actor, first_property, var_args);
va_end (var_args);
}
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;
}
EasePdfActor* ease_pdf_actor_construct (GType object_type, EasePdfElement* e, EaseActorContext c) {
#line 325 "ease-pdf-actor.c"
EasePdfActor * self;
Block9Data* _data9_;
EasePdfElement* _tmp0_;
ClutterActor* _tmp1_;
PopplerDocument* _tmp2_;
#line 34 "ease-pdf-actor.vala"
g_return_val_if_fail (e != NULL, NULL);
#line 333 "ease-pdf-actor.c"
_data9_ = g_slice_new0 (Block9Data);
_data9_->_ref_count_ = 1;
_data9_->e = _g_object_ref0 (e);
#line 36 "ease-pdf-actor.vala"
_data9_->self = g_object_ref (self = (EasePdfActor*) ease_actor_construct (object_type, (EaseElement*) _data9_->e, c));
#line 38 "ease-pdf-actor.vala"
self->priv->pdf_element = (_tmp0_ = _g_object_ref0 (_data9_->e), _g_object_unref0 (self->priv->pdf_element), _tmp0_);
#line 40 "ease-pdf-actor.vala"
((EaseActor*) self)->contents = (_tmp1_ = (ClutterActor*) g_object_ref_sink ((ClutterGroup*) clutter_group_new ()), _g_object_unref0 (((EaseActor*) self)->contents), _tmp1_);
#line 41 "ease-pdf-actor.vala"
clutter_actor_set_width (((EaseActor*) self)->contents, ease_element_get_width ((EaseElement*) _data9_->e));
#line 42 "ease-pdf-actor.vala"
clutter_actor_set_height (((EaseActor*) self)->contents, ease_element_get_height ((EaseElement*) _data9_->e));
#line 43 "ease-pdf-actor.vala"
clutter_actor_set_x ((ClutterActor*) self, ease_element_get_x ((EaseElement*) _data9_->e));
#line 44 "ease-pdf-actor.vala"
clutter_actor_set_y ((ClutterActor*) self, ease_element_get_y ((EaseElement*) _data9_->e));
#line 45 "ease-pdf-actor.vala"
clutter_container_add_actor ((ClutterContainer*) self, ((EaseActor*) self)->contents);
#line 47 "ease-pdf-actor.vala"
self->priv->current_page = ease_pdf_element_get_displayed_page (_data9_->e);
#line 48 "ease-pdf-actor.vala"
self->priv->doc = (_tmp2_ = _g_object_ref0 (_data9_->e->pdf_doc), _g_object_unref0 (self->priv->doc), _tmp2_);
#line 49 "ease-pdf-actor.vala"
ease_pdf_actor_draw_page (self);
#line 52 "ease-pdf-actor.vala"
g_signal_connect_data ((EaseElement*) _data9_->e, "changed", (GCallback) __lambda55__ease_element_changed, block9_data_ref (_data9_), (GClosureNotify) block9_data_unref, 0);
#line 361 "ease-pdf-actor.c"
block9_data_unref (_data9_);
return self;
}
static ClutterActor *
_add_from_recent_file_event (PengeEverythingPane *pane,
ZeitgeistEvent *event,
const gchar *thumbnail_path)
{
ClutterActor *actor;
actor = g_object_new (PENGE_TYPE_RECENT_FILE_TILE,
"zg-event", event,
"thumbnail-path", thumbnail_path,
NULL);
clutter_container_add_actor (CLUTTER_CONTAINER (pane), actor);
g_signal_connect (actor,
"remove-clicked",
(GCallback)_recent_file_tile_remove_clicked_cb,
pane);
return actor;
}
gboolean
cs_selected_lasso_start (ClutterActor *actor,
ClutterEvent *event)
{
ClutterModifierType state = event->button.modifier_state;
g_assert (lasso == NULL);
{
ClutterColor lassocolor = {0xff,0x0,0x0,0x11};
ClutterColor lassobordercolor = {0xff,0x0,0x0,0x88};
lasso = clutter_rectangle_new_with_color (&lassocolor);
clutter_rectangle_set_border_color (CLUTTER_RECTANGLE (lasso), &lassobordercolor);
clutter_rectangle_set_border_width (CLUTTER_RECTANGLE (lasso), LASSO_BORDER);
clutter_container_add_actor (CLUTTER_CONTAINER (cs->parasite_root), lasso);
}
lx = event->button.x;
ly = event->button.y;
clutter_actor_set_position (lasso, lx-LASSO_BORDER, ly-LASSO_BORDER);
clutter_actor_set_size (lasso, LASSO_BORDER*2, LASSO_BORDER*2);
manipulate_x = event->button.x;
manipulate_y = event->button.y;
g_signal_connect (clutter_actor_get_stage (actor), "captured-event",
G_CALLBACK (manipulate_lasso_capture), actor);
undo = g_string_new ("");
redo = g_string_new ("");
SELECT_ACTION_PRE2();
if (!((state & CLUTTER_SHIFT_MASK) ||
(state & CLUTTER_CONTROL_MASK)))
{
cs_selected_clear ();
}
return TRUE;
}
static void
pkg_graph_2d_init (PkgGraph2d *graph)
{
graph->priv = G_TYPE_INSTANCE_GET_PRIVATE(graph,
PKG_TYPE_GRAPH_2D,
PkgGraph2dPrivate);
graph->priv->texture = clutter_cairo_texture_new(1, 1);
clutter_container_add_actor(CLUTTER_CONTAINER(graph),
graph->priv->texture);
clutter_actor_show(graph->priv->texture);
graph->priv->x_scale = g_object_ref_sink(pkg_scale_linear_new());
graph->priv->y_scale = g_object_ref_sink(pkg_scale_linear_new());
graph->priv->x_padding = 25.;
graph->priv->y_padding = 25.;
g_signal_connect(graph,
"allocation-changed",
G_CALLBACK(pkg_graph_2d_allocation_changed),
NULL);
}
static void
pkg_graph_2d_real_pack_renderer (PkgGraph *graph,
PkgRenderer *renderer)
{
PkgGraph2dPrivate *priv;
g_return_if_fail(PKG_IS_GRAPH_2D(graph));
g_return_if_fail(PKG_IS_RENDERER(renderer));
priv = PKG_GRAPH_2D(graph)->priv;
if (priv->renderer) {
g_warning("Renderer already added. "
"No support for multiple renderers.");
return;
}
priv->renderer = g_object_ref_sink(renderer);
clutter_container_add_actor(CLUTTER_CONTAINER(graph),
CLUTTER_ACTOR(renderer));
pkg_graph_2d_place_child(PKG_GRAPH_2D(graph), renderer);
}
gint
main (gint argc, /* IN */
gchar *argv[]) /* IN */
{
ClutterActor *stage;
ClutterActor *graph;
clutter_init(&argc, &argv);
stage = clutter_stage_get_default();
graph = uber_graph_new();
clutter_container_add_actor(CLUTTER_CONTAINER(stage), graph);
clutter_actor_set_position(graph, 0, 0);
clutter_actor_set_size(graph,
clutter_actor_get_width(stage),
clutter_actor_get_height(stage));
clutter_actor_show(graph);
clutter_actor_show(stage);
clutter_main();
return 0;
}
void Platform::init(int* argc, char*** argv)
{
if(m_initialized)
return;
m_initialized = true;
if (!g_thread_supported ())
g_thread_init (NULL);
clutter_gst_init (argc, argv);
m_stage = clutter_stage_get_default();
clutter_actor_set_size(m_stage, (gfloat)960, (gfloat)540);
m_videoTexture = clutter_texture_new ();
GstPlaybin::getInstance().init(m_videoTexture);
clutter_container_add_actor (CLUTTER_CONTAINER (m_stage), m_videoTexture);
g_signal_connect (CLUTTER_STAGE (m_stage), "fullscreen", G_CALLBACK (Platform::windowSizeChanged), this);
g_signal_connect (CLUTTER_STAGE (m_stage), "unfullscreen", G_CALLBACK (Platform::windowSizeChanged), this);
// g_signal_connect (CLUTTER_STAGE (m_stage), "event", G_CALLBACK (Platform::stageEvent), this);
}
static gboolean
restart_game (gpointer data)
{
int i;
gnibbles_board_level_new (board, current_level);
gnibbles_board_level_add_bonus (board, 1);
for (i = 0; i < properties->numworms; i++) {
if (!clutter_actor_get_stage (worms[i]->actors))
clutter_container_add_actor (CLUTTER_CONTAINER (stage), worms[i]->actors);
gnibbles_worm_show (worms[i]);
}
for (i = 0; i < properties->human; i++)
worms[i]->human = TRUE;
dummy_id = g_timeout_add_seconds (1, (GSourceFunc) new_game_2_cb, NULL);
restart_id = 0;
return FALSE;
}
static void
add_actor (ClutterContainer *container)
{
ClutterActor *rect;
ClutterColor color = { 0xff, 0xff, 0xff, 255 };
static gboolean expand = TRUE;
clutter_color_from_hls (&color,
g_random_double_range (0.0, 360.0), 0.5, 0.5);
rect = clutter_rectangle_new_with_color (&color);
clutter_actor_set_size (rect, 32, 64);
clutter_container_add_actor (container, rect);
clutter_actor_set_reactive (rect, TRUE);
g_signal_connect (rect, "enter-event", G_CALLBACK (enter_event), NULL);
g_signal_connect (rect, "leave-event", G_CALLBACK (leave_event), NULL);
g_signal_connect (rect, "button-release-event",
G_CALLBACK (button_release_event), container);
clutter_container_child_set (container, rect, "expand", expand, NULL);
expand = !expand;
}
static void
mpl_panel_clutter_constructed (GObject *self)
{
MplPanelClutterPrivate *priv = MPL_PANEL_CLUTTER (self)->priv;
ClutterActor *stage = NULL;
ClutterActor *background;
if (G_OBJECT_CLASS (mpl_panel_clutter_parent_class)->constructed)
G_OBJECT_CLASS (mpl_panel_clutter_parent_class)->constructed (self);
stage = clutter_stage_new ();
priv->stage = stage;
/* Load a base style for widgets used in the Mpl panels */
mpl_panel_clutter_load_base_style ();
background = (ClutterActor*)mpl_panel_background_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (stage), background);
clutter_actor_hide (stage);
}
int
main (int argc, char *argv[])
{
ClutterActor *actor, *stage;
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);
clutter_actor_show (stage);
clutter_main ();
return 0;
}
int
main (int argc,
char **argv)
{
// GError *error = NULL;
// gchar *path;
// MxStyle *style;
ClutterActor *stage, *avatar;
clutter_init (&argc, &argv);
// path = g_build_filename (PKG_DATA_DIR,
// "style.css",
// NULL);
//
// style = mx_style_get_default ();
//
// if (!mx_style_load_from_file (style,
// path,
// &error))
// {
// g_warning (G_STRLOC ": Error opening style: %s",
// error->message);
// g_clear_error (&error);
// }
//
// g_free (path);
stage = clutter_stage_new ();
avatar = anerley_tp_user_avatar_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (stage), avatar);
clutter_actor_show_all (stage);
clutter_main ();
return 0;
}
int
main (int argc,
char **argv)
{
GError *error = NULL;
gchar *path;
MxStyle *style;
ClutterActor *stage, *chooser;
clutter_init (&argc, &argv);
path = g_build_filename (PKG_DATA_DIR,
"style.css",
NULL);
style = mx_style_get_default ();
if (!mx_style_load_from_file (style,
path,
&error))
{
g_warning (G_STRLOC ": Error opening style: %s",
error->message);
g_clear_error (&error);
}
g_free (path);
stage = clutter_stage_new ();
chooser = anerley_presence_chooser_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (stage), chooser);
clutter_actor_show_all (stage);
clutter_main ();
return 0;
}
void AcceleratedCompositingContext::setRootCompositingLayer(GraphicsLayer* graphicsLayer)
{
if (!graphicsLayer) {
gtk_container_remove(GTK_CONTAINER(m_webView), m_rootLayerEmbedder);
m_rootLayerEmbedder = 0;
m_rootLayer = nullptr;
m_nonCompositedContentLayer = nullptr;
return;
}
// Create an instance of GtkClutterEmbed to embed actors as GraphicsLayers.
if (!m_rootLayerEmbedder) {
m_rootLayerEmbedder = gtk_clutter_embed_new();
gtk_container_add(GTK_CONTAINER(m_webView), m_rootLayerEmbedder);
GtkAllocation allocation;
gtk_widget_get_allocation(GTK_WIDGET(m_webView), &allocation);
gtk_widget_size_allocate(GTK_WIDGET(m_rootLayerEmbedder), &allocation);
gtk_widget_show(m_rootLayerEmbedder);
}
// Add the accelerated layer tree hierarchy.
initialize();
m_nonCompositedContentLayer->removeAllChildren();
m_nonCompositedContentLayer->addChild(graphicsLayer);
// Add a root GraphicsLayer to the stage.
if (graphicsLayer) {
ClutterColor stageColor = { 0xFF, 0xFF, 0xFF, 0xFF };
ClutterActor* stage = gtk_clutter_embed_get_stage(GTK_CLUTTER_EMBED(m_rootLayerEmbedder));
clutter_stage_set_color(CLUTTER_STAGE(stage), &stageColor);
clutter_container_add_actor(CLUTTER_CONTAINER(stage), m_rootLayer->platformLayer());
clutter_actor_show_all(stage);
}
scheduleLayerFlush();
}
static void ease_selection_rectangle_make (EaseSelectionRectangle* self, ClutterRectangle** rect) {
#line 190 "ease-selection-rectangle.c"
ClutterRectangle* _tmp0_;
ClutterColor _tmp1_;
ClutterColor _tmp2_;
#line 65 "ease-selection-rectangle.vala"
g_return_if_fail (self != NULL);
#line 196 "ease-selection-rectangle.c"
if (rect != NULL) {
*rect = NULL;
}
#line 67 "ease-selection-rectangle.vala"
*rect = (_tmp0_ = g_object_ref_sink ((ClutterRectangle*) clutter_rectangle_new ()), _g_object_unref0 (*rect), _tmp0_);
#line 68 "ease-selection-rectangle.vala"
clutter_rectangle_set_color (*rect, (_tmp1_ = EASE_SELECTION_RECTANGLE_INNER_COLOR, &_tmp1_));
#line 69 "ease-selection-rectangle.vala"
clutter_rectangle_set_border_color (*rect, (_tmp2_ = EASE_SELECTION_RECTANGLE_OUTER_COLOR, &_tmp2_));
#line 70 "ease-selection-rectangle.vala"
clutter_rectangle_set_border_width (*rect, (guint) EASE_SELECTION_RECTANGLE_BORDER);
#line 71 "ease-selection-rectangle.vala"
clutter_container_add_actor ((ClutterContainer*) self, (ClutterActor*) (*rect));
#line 210 "ease-selection-rectangle.c"
}
void
test_mapped (TestConformSimpleFixture *fixture,
gconstpointer data)
{
ClutterActor *actor;
ClutterActor *stage;
stage = clutter_stage_get_default ();
actor = clutter_rectangle_new ();
g_assert (!(CLUTTER_ACTOR_IS_REALIZED (actor)));
g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor)));
clutter_container_add_actor (CLUTTER_CONTAINER (stage),
actor);
g_assert (CLUTTER_ACTOR_IS_REALIZED (actor));
g_assert (CLUTTER_ACTOR_IS_MAPPED (actor));
g_assert (CLUTTER_ACTOR_IS_VISIBLE (actor));
clutter_actor_destroy (actor);
}
static void
astro_applet_init (AstroApplet *applet)
{
AstroAppletPrivate *priv;
priv = applet->priv = ASTRO_APPLET_GET_PRIVATE (applet);
if (!CLUTTER_IS_TEXTURE (texture))
{
applet_bg = gdk_pixbuf_new_from_file (PKGDATADIR "/applet_bg.png", NULL);
texture = g_object_new (CLUTTER_TYPE_TEXTURE,
"pixbuf", applet_bg,
"tiled", FALSE,
NULL);
}
priv->texture = tidy_texture_frame_new (CLUTTER_TEXTURE (texture),
15, 15, 15, 15);
clutter_container_add_actor (CLUTTER_CONTAINER (applet), priv->texture);
clutter_actor_show_all (CLUTTER_ACTOR (applet));
}
void
meta_compositor_flash_screen (MetaCompositor *compositor,
MetaScreen *screen)
{
ClutterActor *stage;
ClutterActor *flash;
ClutterColor black = { 0, 0, 0, 255 };
gfloat width, height;
stage = meta_get_stage_for_screen (screen);
clutter_actor_get_size (stage, &width, &height);
flash = clutter_rectangle_new_with_color (&black);
clutter_actor_set_size (flash, width, height);
clutter_actor_set_opacity (flash, 0);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), flash);
clutter_actor_animate (flash, CLUTTER_EASE_OUT_QUAD,
FLASH_TIME_MS,
"opacity", 192,
"signal-after::completed", flash_in_completed, flash,
NULL);
}
int
main (int argc, char *argv[])
{
ClutterActor *stage;
ClutterActor *coglbox;
clutter_init(&argc, &argv);
/* Stage */
stage = clutter_stage_get_default ();
clutter_actor_set_size (stage, 400, 400);
clutter_stage_set_title (CLUTTER_STAGE (stage), "Cogl Test");
/* Cogl Box */
coglbox = test_coglbox_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (stage), coglbox);
clutter_actor_show_all (stage);
clutter_main ();
return 0;
}
int
main (int argc, char *argv[])
{
ClutterActor* actor, *stage;
g_thread_init (NULL);
clutter_init (&argc, &argv);
stage = clutter_stage_get_default ();
clutter_actor_set_size (stage, 800, 600);
/* 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);
clutter_actor_show (stage);
clutter_main ();
clutter_actor_destroy (actor);
return 0;
}
static void
setup_panel (DawatiStatusPanel *status_panel)
{
MplPanelClient *panel;
ClutterActor *stage, *status;
panel = mpl_panel_clutter_new ("status",
_("status"),
NULL,
"status-button",
TRUE);
status_panel->panel_client = panel;
mpl_panel_clutter_setup_events_with_gtk ((MplPanelClutter *)panel);
status = make_status (status_panel);
mpl_panel_client_set_size_request (panel, 1024, 580);
stage = mpl_panel_clutter_get_stage (MPL_PANEL_CLUTTER (panel));
clutter_container_add_actor (CLUTTER_CONTAINER (stage), status);
g_signal_connect (panel,
"size-changed", G_CALLBACK (on_client_set_size),
status);
}
void
mnp_clock_area_add_tile (MnpClockArea *area, MnpClockTile *tile)
{
clutter_actor_set_reactive ((ClutterActor *)tile, TRUE);
clutter_actor_set_name ((ClutterActor *)tile, "ClockTile");
clutter_container_add_actor ((ClutterContainer *)clutter_stage_get_default(), (ClutterActor *)tile);
mx_draggable_set_axis (MX_DRAGGABLE (tile), MX_DRAG_AXIS_Y);
mx_draggable_enable ((MxDraggable *)tile);
clutter_actor_set_size ((ClutterActor *)tile, 230, 75);
clutter_actor_set_depth ((ClutterActor *)tile, area->priv->position);
area->priv->position += 0.05;
clutter_actor_reparent ((ClutterActor *)tile, (ClutterActor *)area);
clutter_container_child_set (CLUTTER_CONTAINER (area),
(ClutterActor *)tile,
"expand", FALSE,
"y-fill", FALSE,
"x-fill", TRUE,
NULL);
g_ptr_array_add (area->priv->clock_tiles, tile);
mnp_clock_tile_set_remove_cb (tile, (TileRemoveFunc)mnp_clock_tile_removed, (gpointer)area);
g_signal_connect (tile, "drag-y-pos", G_CALLBACK(tile_drag_run), area);
}
