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;
}
static void
on_monitors_changed (MetaScreen *screen,
MetaPlugin *plugin)
{
MetaDefaultPlugin *self = META_DEFAULT_PLUGIN (plugin);
int i, n;
GRand *rand = g_rand_new_with_seed (123456);
clutter_actor_destroy_all_children (self->priv->background_group);
n = meta_screen_get_n_monitors (screen);
for (i = 0; i < n; i++)
{
MetaRectangle rect;
ClutterActor *background_actor;
MetaBackground *background;
ClutterColor color;
meta_screen_get_monitor_geometry (screen, i, &rect);
background_actor = meta_background_actor_new (screen, i);
clutter_actor_set_position (background_actor, rect.x, rect.y);
clutter_actor_set_size (background_actor, rect.width, rect.height);
/* Don't use rand() here, mesa calls srand() internally when
parsing the driconf XML, but it's nice if the colors are
reproducible.
*/
clutter_color_init (&color,
g_rand_int_range (rand, 0, 255),
g_rand_int_range (rand, 0, 255),
g_rand_int_range (rand, 0, 255),
255);
background = meta_background_new (screen);
meta_background_set_color (background, &color);
meta_background_actor_set_background (META_BACKGROUND_ACTOR (background_actor), background);
g_object_unref (background);
clutter_actor_add_child (self->priv->background_group, background_actor);
}
g_rand_free (rand);
}
/* Private functions */
static void
astro_contact_row_set_name (AstroContactRow *row, const gchar *name)
{
AstroContactRowPrivate *priv;
g_return_if_fail (ASTRO_IS_CONTACT_ROW (row));
g_return_if_fail (name);
priv = row->priv;
if (priv->name)
g_free (priv->name);
priv->name = g_strdup (name);
clutter_label_set_text (CLUTTER_LABEL (priv->label), name);
clutter_actor_set_position (priv->label, (PADDING*2)+ICON_SIZE,
(ROW_HEIGHT /2)-(clutter_actor_get_height (priv->label)/2));
}
static void
center_controls (UserInterface * ui)
{
gfloat x, y, ctl_width, ctl_height;
ctl_width = ui->stage_width * CONTROLS_WIDTH_RATIO;
ctl_height = ui->stage_height * CONTROLS_HEIGHT_RATIO;
if (ctl_width / ctl_height > CONTROLS_ASPECT_RATIO) {
ctl_width = ctl_height * CONTROLS_ASPECT_RATIO;
} else {
ctl_height = ctl_width / CONTROLS_ASPECT_RATIO;
}
x = (ui->stage_width - ctl_width) / 2.0f;
y = ui->stage_height * 2.0f / 3.0f;
clutter_actor_set_position (ui->control_box, x, y);
}
static void
clutter_behaviour_ellipse_applied (ClutterBehaviour *behave,
ClutterActor *actor)
{
ClutterBehaviourEllipse *e = CLUTTER_BEHAVIOUR_ELLIPSE (behave);
ClutterBehaviourEllipsePrivate *priv = e->priv;
knot3d knot = { 0, };
clutter_behaviour_ellipse_advance (e, priv->angle_start, &knot);
clutter_actor_set_position (actor, knot.x, knot.y);
/* the depth should be changed only if there is a tilt on
* any of the X or the Y axis
*/
if (priv->angle_tilt_x != 0 || priv->angle_tilt_y != 0)
clutter_actor_set_depth (actor, knot.z);
}
static void reposition_switcher(MetaSwitcher* self)
{
MetaSwitcherPrivate* priv = self->priv;
MetaScreen* screen = meta_plugin_get_screen(priv->plugin);
gint screen_width = 0, screen_height = 0;
meta_screen_get_size(screen, &screen_width, &screen_height);
clutter_actor_save_easing_state(priv->top);
clutter_actor_set_easing_duration(priv->top, 400);
clutter_actor_set_easing_mode(priv->top, CLUTTER_LINEAR);
gfloat w = clutter_actor_get_width(priv->top), h = clutter_actor_get_height(priv->top),
tx = (screen_width - w)/2, ty = (screen_height - h)/2;
clutter_actor_set_position(priv->top, tx, ty);
clutter_actor_restore_easing_state(priv->top);
}
void GraphicsLayerClutter::updateGeometry(float pageScaleFactor, const FloatPoint& positionRelativeToBase)
{
FloatPoint scaledPosition;
FloatPoint3D scaledAnchorPoint;
FloatSize scaledSize;
// FIXME: Need to support scaling
scaledPosition = m_position;
scaledAnchorPoint = m_anchorPoint;
scaledSize = m_size;
FloatRect adjustedBounds(m_boundsOrigin , scaledSize);
FloatPoint adjustedPosition(scaledPosition.x() + scaledAnchorPoint.x() * scaledSize.width(), scaledPosition.y() + scaledAnchorPoint.y() * scaledSize.height());
clutter_actor_set_size(CLUTTER_ACTOR(m_layer.get()), adjustedBounds.width(), adjustedBounds.height());
clutter_actor_set_position(CLUTTER_ACTOR(m_layer.get()), adjustedPosition.x(), adjustedPosition.y());
graphicsLayerActorSetAnchorPoint(m_layer.get(), scaledAnchorPoint.x(), scaledAnchorPoint.y(), scaledAnchorPoint.z());
}
static void
add_static_box (ClutterActor *group,
gint x,
gint y,
gint width,
gint height)
{
ClutterActor *box;
box = clutter_rectangle_new ();
clutter_actor_set_size (box, width, height);
clutter_actor_set_position (box, x, y);
clutter_group_add (CLUTTER_GROUP (group), box);
clutter_container_child_set (CLUTTER_CONTAINER (group), box,
"mode", CLUTTER_BOX2D_STATIC, NULL);
}
static gboolean
glide_image_motion (ClutterActor *actor,
ClutterMotionEvent *mev)
{
GlideImage *image = GLIDE_IMAGE (actor);
if (image->priv->dragging)
{
image->priv->motion_since_press = TRUE;
clutter_actor_set_position (actor,
mev->x - image->priv->drag_center_x,
mev->y - image->priv->drag_center_y);
return TRUE;
}
return FALSE;
}
void
gnibbles_warpmanager_rescale (GnibblesWarpManager *warpmanager, gint tilesize)
{
int i;
gfloat x_pos, y_pos;
GError *err = NULL;
for (i = 0; i < warpmanager->numwarps; i++) {
clutter_actor_get_position (warpmanager->warps[i]->actor, &x_pos, &y_pos);
clutter_actor_set_position (warpmanager->warps[i]->actor,
(x_pos / properties->tilesize) * tilesize,
(y_pos / properties->tilesize) * tilesize);
gtk_clutter_texture_set_from_pixbuf
(CLUTTER_TEXTURE (warpmanager->warps[i]->actor), boni_pixmaps[WARP], &err);
if (err)
gnibbles_error (err->message);
}
}
static
gboolean
action_add_text (ClutterActor *action,
ClutterEvent *event,
gpointer userdata)
{
ClutterActor *group = CLUTTER_ACTOR (userdata);
ClutterActor *title;
ClutterColor color;
clutter_color_from_string (&color, "#888");
title = clutter_text_new_full ("Sans 30px", "fnord", &color);
clutter_actor_set_position (title, event->button.x, event->button.y);
clutter_group_add (CLUTTER_GROUP (group), title);
return FALSE;
}
ClutterActor *
add_hand (ClutterActor *group,
gint x,
gint y)
{
ClutterActor *actor;
actor = clutter_texture_new_from_file (ASSETS_DIR "redhand.png", NULL);
clutter_group_add (CLUTTER_GROUP (group), actor);
clutter_actor_set_opacity (actor, 1.0 * 255);
clutter_actor_set_position (actor, x, y);
clutter_container_child_set (CLUTTER_CONTAINER (group), actor,
"manipulatable", TRUE,
"mode", CLUTTER_BOX2D_DYNAMIC, NULL);
return actor;
}
static void manager_event_cursor_set(unsigned short type, void *userdata, void *data)
{
tuio_cursor_t *o = (tuio_cursor_t *)data;
manager_cursor_t *it;
ClutterActor *stage;
unsigned wx, wy;
for ( it = manager_cursors_list.lh_first; it != NULL; it = it->next.le_next )
if ( it->id == o->s_id )
break;
if ( it == NULL )
return;
stage = clutter_stage_get_default ();
clutter_actor_get_size(stage, &wx, &wy);
clutter_actor_set_position(it->actor, o->xpos * (float)wx, o->ypos * (float)wy);
}
static void
pkg_graph_2d_place_child (PkgGraph2d *graph,
PkgRenderer *renderer)
{
PkgGraph2dPrivate *priv = graph->priv;
gfloat w, h;
g_debug("renderer place child %p", renderer);
clutter_actor_get_size(CLUTTER_ACTOR(graph), &w, &h);
clutter_actor_set_size(CLUTTER_ACTOR(renderer),
w - priv->x_padding,
h - priv->y_padding);
clutter_actor_set_position(CLUTTER_ACTOR(renderer),
priv->x_padding,
priv->y_padding);
pkg_graph_2d_paint(graph);
clutter_actor_queue_redraw(CLUTTER_ACTOR(graph));
}
void
on_timeline_new_frame(ClutterTimeline *timeline,
gint frame_num,
gpointer data)
{
HandCar *all = (HandCar *)data;
gint x, y, actor_width, actor_height;
clutter_actor_get_position(all->label_actor, &x, &y);
clutter_actor_get_size(all->label_actor, &actor_width, &actor_height);
if (x < (actor_width * -1))
x = STAGE_WIDTH;
else
x -= 10;
clutter_actor_set_position(all->label_actor, x, y);
}
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;
}
Preview::Preview():
width(0),
height(0),
blocknr(-1),
color(-1),
themeID(0),
cell_size(20),
cache(NULL),
enabled(true)
{
blocks = new Block*[PREVIEW_WIDTH];
for (int i = 0; i < PREVIEW_WIDTH; i++) {
blocks[i] = new Block [PREVIEW_HEIGHT];
}
w = gtk_clutter_embed_new();
g_signal_connect (w, "size_allocate", G_CALLBACK (resize), this);
/* FIXME: We should scale with the rest of the UI, but that requires
* changes to the widget layout - i.e. wrap the preview in an
* fixed-aspect box. */
gtk_widget_set_size_request (w, 120, 120);
ClutterActor *stage;
stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (w));
ClutterColor stage_color = { 0x0, 0x0, 0x0, 0xff };
clutter_stage_set_color (CLUTTER_STAGE (stage),
&stage_color);
piece = clutter_group_new ();
clutter_group_add (CLUTTER_GROUP (stage),
piece);
piece_timeline = clutter_timeline_new (180);
alpha = clutter_alpha_new_full (piece_timeline,
CLUTTER_EASE_IN_OUT_SINE);
piece_behav = clutter_behaviour_scale_new (alpha,
0.6, 0.6, 1.0, 1.0);
clutter_actor_set_anchor_point (piece, 60, 60);
clutter_actor_set_position (CLUTTER_ACTOR(piece), 60, 60);
clutter_behaviour_apply (piece_behav, piece);
}
static void
add_clutter_actor (ClutterActor *actor,
ClutterActor *container,
int i)
{
float x, y, w, h;
/* Add to our group group */
clutter_actor_add_child (container, actor);
/* Place around a circle */
w = clutter_actor_get_width (widgets[0]);
h = clutter_actor_get_height (widgets[0]);
x = WINWIDTH / 2 + RADIUS * cosf (i * 2 * M_PI / (MAX_NWIDGETS)) - w / 2;
y = WINHEIGHT / 2 + RADIUS * sinf (i * 2 * M_PI / (MAX_NWIDGETS)) - h / 2;
clutter_actor_set_position (actor, x, y);
clutter_actor_set_pivot_point (actor, 0.5, 0.5);
}
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 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 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
allocation_changed_cb (ClutterActor *actor,
const ClutterActorBox *allocation,
ClutterAllocationFlags flags,
gpointer user_data)
{
ClutterActor *overlay = CLUTTER_ACTOR (user_data);
gfloat width, height, x, y;
clutter_actor_box_get_size (allocation, &width, &height);
clutter_actor_box_get_origin (allocation, &x, &y);
clutter_actor_set_size (overlay,
width * OVERLAY_FACTOR,
height * OVERLAY_FACTOR);
clutter_actor_set_position (overlay,
x - ((OVERLAY_FACTOR - 1) * width * 0.5),
y - ((OVERLAY_FACTOR - 1) * width * 0.5));
}
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);
}
/* Monitor size changed */
static void _xfdashboard_stage_interface_on_geometry_changed(XfdashboardStageInterface *self, gpointer inUserData)
{
XfdashboardStageInterfacePrivate *priv;
gint x, y, w, h;
g_return_if_fail(XFDASHBOARD_IS_STAGE_INTERFACE(self));
priv=self->priv;
/* Resize actor to new monitor */
xfdashboard_window_tracker_monitor_get_geometry(priv->monitor, &x, &y, &w, &h);
clutter_actor_set_position(CLUTTER_ACTOR(self), x, y);
clutter_actor_set_size(CLUTTER_ACTOR(self), w, h);
XFDASHBOARD_DEBUG(self, ACTOR,
"Stage interface moved to %d,%d and resized to %dx%d because %s monitor %d changed geometry",
x, y,
w, h,
xfdashboard_window_tracker_monitor_is_primary(priv->monitor) ? "primary" : "non-primary",
xfdashboard_window_tracker_monitor_get_number(priv->monitor));
}
/* Fade out text, change text, then fade in, all within one play of the timeline
just to keep things interesting :) */
static void
fluttr_viewer_swap_alpha_func (ClutterBehaviour *behave,
guint alpha_value,
gpointer data)
{
FluttrViewerPrivate *priv;
gfloat factor;
guint width = CLUTTER_STAGE_WIDTH ();
guint height = CLUTTER_STAGE_HEIGHT ();
guint w, h;
g_return_if_fail (FLUTTR_IS_VIEWER (data));
priv = FLUTTR_VIEWER_GET_PRIVATE(data);
factor = (gfloat) alpha_value / CLUTTER_ALPHA_MAX_ALPHA;
if (priv->pixbuf != NULL && factor > 0.5) {
clutter_texture_set_pixbuf (CLUTTER_TEXTURE (priv->texture),
priv->pixbuf, NULL);
clutter_actor_get_size (priv->texture, &w, &h);
clutter_actor_set_position (priv->texture,
(width/2) - (w/2),
(height/2) - (h/2));
}
if (factor < 0.5) {
factor *= 2;
factor = 1.0 - factor;
} else {
factor -= 0.5;
factor /= 0.5;
}
clutter_actor_set_opacity (CLUTTER_ACTOR (priv->texture),
255 * factor);
clutter_actor_set_opacity (priv->spinner, 255 * (1-factor));
if (CLUTTER_ACTOR_IS_VISIBLE (CLUTTER_ACTOR(data)))
clutter_actor_queue_redraw (CLUTTER_ACTOR(data));
}
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;
}
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;
}
void
champlain_viewport_set_origin (ChamplainViewport *viewport,
float x,
float y)
{
ChamplainViewportPrivate *priv;
g_return_if_fail (CHAMPLAIN_IS_VIEWPORT (viewport));
priv = viewport->priv;
g_object_freeze_notify (G_OBJECT (viewport));
if (x != priv->x)
{
priv->x = x;
g_object_notify (G_OBJECT (viewport), "x-origin");
if (priv->hadjustment)
champlain_adjustment_set_value (priv->hadjustment,
x);
}
if (y != priv->y)
{
priv->y = y;
g_object_notify (G_OBJECT (viewport), "y-origin");
if (priv->vadjustment)
champlain_adjustment_set_value (priv->vadjustment,
y);
}
g_object_thaw_notify (G_OBJECT (viewport));
if (priv->child)
clutter_actor_set_position (priv->child, -x, -y);
clutter_actor_queue_redraw (CLUTTER_ACTOR (viewport));
}
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;
}
static void
create_stage (guint width, guint height)
{
ClutterActor *stage, *instructions;
GError *error = NULL;
stage = clutter_stage_get_default ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Depth File Viewer");
clutter_actor_set_size (stage, width, height + 100);
clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
g_signal_connect (stage, "destroy", G_CALLBACK (on_destroy), NULL);
depth_tex = clutter_cairo_texture_new (width, height);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), depth_tex);
info_text = clutter_text_new ();
clutter_actor_set_position (info_text, 50, height + 20);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), info_text);
clutter_actor_show_all (stage);
}
