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; }