static void st_scroll_bar_set_property (GObject *gobject, guint prop_id, const GValue *value, GParamSpec *pspec) { StScrollBar *bar = ST_SCROLL_BAR (gobject); switch (prop_id) { case PROP_ADJUSTMENT: st_scroll_bar_set_adjustment (bar, g_value_get_object (value)); break; case PROP_VERTICAL: bar->priv->vertical = g_value_get_boolean (value); if (bar->priv->vertical) clutter_actor_set_name (CLUTTER_ACTOR (bar->priv->handle), "vhandle"); else clutter_actor_set_name (CLUTTER_ACTOR (bar->priv->handle), "hhandle"); clutter_actor_queue_relayout ((ClutterActor*) gobject); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); break; } }
static void mpl_panel_background_allocate (ClutterActor *actor, const ClutterActorBox *box, ClutterAllocationFlags flags) { MplPanelBackgroundPrivate *priv = MPL_PANEL_BACKGROUND (actor)->priv; #if 0 ClutterActor *border; border = mx_widget_get_border_image (MX_WIDGET (actor)); /* * We need to use different background asset based on the size allocated to us * -- basically, the panel cannot be smaller than the size of the borders of * its border image (see MB#702), so if it is smaller than the current asset * allows, we change the asset to simpler one. * * The code here assumes that we either have no name, or are called * 'too-small', but since this is a private widget of libmeego-panel, we can * enforce this assumption. */ if (border) { const gchar *name = clutter_actor_get_name (actor); gboolean too_small = FALSE; /* * Get the dimensions of the base texture (we are guaranteed to be called * first with name == NULL, so this works). */ if (!priv->base_geom_known && !name) { mx_texture_frame_get_border_values (/*MX_TEXTURE_FRAME*/ (border), &priv->base_t, &priv->base_r, &priv->base_b, &priv->base_l); priv->base_geom_known = TRUE; } if (priv->base_l + priv->base_r > box->x2 - box->x1 || priv->base_t + priv->base_b > box->y2 - box->y1) { too_small = TRUE; } if (!name && too_small) { clutter_actor_set_name (actor, "too-small"); } else if (name && !too_small) { clutter_actor_set_name (actor, NULL); } } #endif //DV CLUTTER_ACTOR_CLASS ( mpl_panel_background_parent_class)->allocate (actor, box, flags); }
static void st_scroll_bar_init (StScrollBar *self) { self->priv = ST_SCROLL_BAR_GET_PRIVATE (self); self->priv->trough = (ClutterActor *) st_bin_new (); clutter_actor_set_reactive ((ClutterActor *) self->priv->trough, TRUE); clutter_actor_set_name (CLUTTER_ACTOR (self->priv->trough), "trough"); clutter_actor_add_child (CLUTTER_ACTOR (self), CLUTTER_ACTOR (self->priv->trough)); g_signal_connect (self->priv->trough, "button-press-event", G_CALLBACK (trough_button_press_event_cb), self); g_signal_connect (self->priv->trough, "button-release-event", G_CALLBACK (trough_button_release_event_cb), self); g_signal_connect (self->priv->trough, "leave-event", G_CALLBACK (trough_leave_event_cb), self); self->priv->handle = (ClutterActor *) st_button_new (); clutter_actor_set_name (CLUTTER_ACTOR (self->priv->handle), "hhandle"); clutter_actor_add_child (CLUTTER_ACTOR (self), CLUTTER_ACTOR (self->priv->handle)); g_signal_connect (self->priv->handle, "button-press-event", G_CALLBACK (handle_button_press_event_cb), self); g_signal_connect (self->priv->handle, "button-release-event", G_CALLBACK (handle_button_release_event_cb), self); g_signal_connect (self->priv->handle, "motion-event", G_CALLBACK (handle_motion_event_cb), self); clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE); g_signal_connect (self, "notify::reactive", G_CALLBACK (st_scroll_bar_notify_reactive), NULL); }
static void _update_placeholder_state (MnbPeoplePanel *self) { MnbPeoplePanelPrivate *priv = GET_PRIVATE (self); gint accounts_available, accounts_online; g_object_get (priv->tp_feed, "accounts-available", &accounts_available, "accounts-online", &accounts_online, NULL); clutter_actor_set_name (priv->content_table, "people-panel-content-box"); /* There is something in the model, hide all placeholders */ if (clutter_model_get_first_iter (CLUTTER_MODEL (priv->model))) { clutter_actor_hide (priv->no_people_tile); clutter_actor_hide (priv->everybody_offline_tile); /* Ensure content stuff is visible */ clutter_actor_show (priv->main_scroll_view); clutter_actor_show (priv->me_table); if (accounts_available > 0 && accounts_online == 0) { clutter_actor_show (priv->offline_banner); } else { clutter_actor_hide (priv->offline_banner); } } else { /* Hide real content stuff */ clutter_actor_hide (priv->main_scroll_view); if (accounts_online == 0) { if (accounts_available == 0) { clutter_actor_set_name (priv->content_table, "no-people-panel-content-box"); clutter_actor_show (priv->no_people_tile); clutter_actor_hide (priv->me_table); clutter_actor_hide (priv->everybody_offline_tile); clutter_actor_hide (priv->offline_banner); } else { clutter_actor_show (priv->me_table); clutter_actor_show (priv->offline_banner); clutter_actor_hide (priv->no_people_tile); clutter_actor_hide (priv->everybody_offline_tile); } } else { clutter_actor_show (priv->me_table); clutter_actor_show (priv->everybody_offline_tile); clutter_actor_hide (priv->no_people_tile); clutter_actor_hide (priv->offline_banner); } } }
int main (int argc, char *argv[]) { ClutterActor *stage; ClutterAction *action1; ClutterAction *action2; ClutterActor *actor1; ClutterActor *actor2; if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; stage = clutter_stage_new (); 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); actor1 = clutter_actor_new (); clutter_actor_set_name (actor1, "Red Button"); clutter_actor_set_background_color (actor1, CLUTTER_COLOR_Red); clutter_actor_set_size (actor1, 100, 100); clutter_actor_set_reactive (actor1, TRUE); clutter_actor_set_position (actor1, 50, 150); clutter_actor_add_child (stage, actor1); actor2 = clutter_actor_new (); clutter_actor_set_name (actor2, "Blue Button"); clutter_actor_set_background_color (actor2, CLUTTER_COLOR_Blue); clutter_actor_set_size (actor2, 100, 100); clutter_actor_set_position (actor2, 250, 150); clutter_actor_set_reactive (actor2, TRUE); clutter_actor_add_child (stage, actor2); action1 = clutter_click_action_new (); clutter_actor_add_action (actor1, action1); action2 = clutter_click_action_new (); clutter_actor_add_action (actor2, action2); g_signal_connect (action1, "clicked", G_CALLBACK (clicked_cb), NULL); g_signal_connect (action2, "clicked", G_CALLBACK (clicked_cb), NULL); clutter_actor_show (stage); clutter_main (); return EXIT_SUCCESS; }
IO_METHOD(IoClutterActor, setName) { clutter_actor_set_name( IOCACTOR(self), IoMessage_locals_cStringArgAt_(m, locals, 0) ); return self; }
static void mx_expander_update (MxExpander *expander) { MxExpanderPrivate *priv = expander->priv; if (priv->expanded) { clutter_actor_set_name (priv->arrow, "mx-expander-arrow-open"); mx_stylable_set_style_class (MX_STYLABLE (expander), "open-expander"); } /* closed state is set when animation is finished */ if (!priv->child) return; /* setup and start the expansion animation */ if (!priv->expanded) { clutter_actor_hide (priv->child); clutter_timeline_set_direction (priv->timeline, CLUTTER_TIMELINE_BACKWARD); } else { clutter_timeline_set_direction (priv->timeline, CLUTTER_TIMELINE_FORWARD); } if (!clutter_timeline_is_playing (priv->timeline)) clutter_timeline_rewind (priv->timeline); clutter_timeline_start (priv->timeline); }
static void mx_expander_init (MxExpander *self) { MxExpanderPrivate *priv = self->priv = GET_PRIVATE (self); priv->label = clutter_text_new (); clutter_actor_add_child ((ClutterActor *) self, priv->label); priv->arrow = (ClutterActor *) mx_icon_new (); clutter_actor_add_child ((ClutterActor*) self, priv->arrow); clutter_actor_set_name (priv->arrow, "mx-expander-arrow-closed"); /* TODO: make this a style property */ priv->spacing = 10.0f; priv->timeline = clutter_timeline_new (250); clutter_timeline_set_progress_mode (priv->timeline, CLUTTER_EASE_IN_SINE); g_signal_connect (priv->timeline, "new-frame", G_CALLBACK (new_frame), self); g_signal_connect (priv->timeline, "completed", G_CALLBACK (timeline_complete), self); clutter_actor_set_reactive ((ClutterActor *) self, TRUE); g_signal_connect (self, "style-changed", G_CALLBACK (mx_expander_style_changed), NULL); g_signal_connect (self, "actor-added", G_CALLBACK (mx_expander_actor_added), NULL); g_signal_connect (self, "actor-removed", G_CALLBACK (mx_expander_actor_removed), NULL); }
static void mex_telepathy_channel_create_incoming_video (MexTelepathyChannel *self) { MexTelepathyChannelPrivate *priv = MEX_TELEPATHY_CHANNEL (self)->priv; ClutterActor *video_incoming_area; /* Setup the incoming surface to draw to */ priv->incoming_texture = clutter_texture_new (); clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (priv->incoming_texture), TRUE); video_incoming_area = mx_stack_new (); clutter_container_add (CLUTTER_CONTAINER (video_incoming_area), mex_telepathy_channel_create_static_image(), priv->incoming_texture, NULL); /* Create a frame for it with a styled border */ priv->full_frame = mx_frame_new(); clutter_actor_set_name (priv->full_frame, "Incoming Frame"); mx_bin_set_fill (MX_BIN (priv->full_frame), TRUE, TRUE); mx_stylable_set_style_class (MX_STYLABLE (priv->full_frame), "CallWindow"); clutter_actor_add_effect (priv->full_frame, CLUTTER_EFFECT ( mex_telepathy_channel_create_shadow ())); clutter_container_add_actor (CLUTTER_CONTAINER (priv->full_frame), video_incoming_area); priv->incoming_sink = clutter_gst_video_sink_new (CLUTTER_TEXTURE (priv->incoming_texture)); }
static void mnb_statusbar_init (MnbStatusbar *self) { MnbStatusbarPrivate *priv; GDateTime *datetime; priv = self->priv = STATUSBAR_PRIVATE (self); g_signal_connect (self, "event", G_CALLBACK (mnb_statusbar_event_cb), NULL); priv->datetime = mx_button_new (); clutter_actor_set_name (priv->datetime, "statusbar-date-button"); clutter_actor_set_parent (priv->datetime, CLUTTER_ACTOR (self)); mnb_statusbar_update_datetime (self); datetime = g_date_time_new_now_local (); g_timeout_add_seconds (60 - g_date_time_get_second (datetime), (GSourceFunc) mnb_statusbar_initial_timeout_cb, self); g_date_time_unref (datetime); }
int main (int argc, char *argv[]) { ClutterActor *stage; ClutterActor *r1, *r2, *r3; if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; stage = clutter_stage_new (); clutter_actor_set_size (stage, 300, 300); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); r1 = clutter_rectangle_new_with_color (&red); clutter_actor_set_size (r1, 150, 150); clutter_actor_add_constraint (r1, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0.25)); clutter_actor_add_constraint (r1, clutter_align_constraint_new (stage, CLUTTER_ALIGN_Y_AXIS, 0.25)); clutter_actor_set_reactive (r1, TRUE); clutter_actor_set_name (r1, "red"); r2 = clutter_rectangle_new_with_color (&green); clutter_actor_set_size (r2, 150, 150); clutter_actor_add_constraint (r2, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0.5)); clutter_actor_add_constraint (r2, clutter_align_constraint_new (stage, CLUTTER_ALIGN_Y_AXIS, 0.5)); clutter_actor_set_reactive (r2, TRUE); clutter_actor_set_depth (r2, -100); clutter_actor_set_name (r2, "green"); r3 = clutter_rectangle_new_with_color (&blue); clutter_actor_set_size (r3, 150, 150); clutter_actor_add_constraint (r3, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0.75)); clutter_actor_add_constraint (r3, clutter_align_constraint_new (stage, CLUTTER_ALIGN_Y_AXIS, 0.75)); clutter_actor_set_opacity (r3, 125); clutter_actor_set_name (r3, "blue"); clutter_container_add (CLUTTER_CONTAINER (stage), r1, r2, r3, NULL); g_signal_connect (r1, "motion-event", G_CALLBACK (_pointer_motion_cb), NULL); g_signal_connect (r2, "motion-event", G_CALLBACK (_pointer_motion_cb), NULL); clutter_actor_show (stage); clutter_main (); return 0; }
/* Setup various status icons */ static void init_icons(ClutterActor *stage) { ClutterActor *rs_img; ClutterActor *ra_img; ClutterActor *shuffle_img; ClutterActor *play_img; ClutterActor *pause_img; rs_img = clutter_texture_new_from_file("icons/repeat-single.png", NULL); clutter_actor_set_name(rs_img, "rs_img"); clutter_actor_set_size(rs_img, 20, 20); clutter_actor_set_position(rs_img, 430, 102); if (!mozart_get_repeat_single()) clutter_actor_hide(rs_img); clutter_container_add_actor(CLUTTER_CONTAINER(stage), rs_img); ra_img = clutter_texture_new_from_file("icons/repeat-all.png", NULL); clutter_actor_set_name(ra_img, "ra_img"); clutter_actor_set_size(ra_img, 20, 20); clutter_actor_set_position(ra_img, 430, 102); if (!mozart_get_repeat_all()) clutter_actor_hide(ra_img); clutter_container_add_actor(CLUTTER_CONTAINER(stage), ra_img); shuffle_img = clutter_texture_new_from_file("icons/shuffle.png", NULL); clutter_actor_set_name(shuffle_img, "shuffle_img"); clutter_actor_set_size(shuffle_img, 20, 20); clutter_actor_set_position(shuffle_img, 460, 102); if (!mozart_playlist_shuffled(NULL)) clutter_actor_hide(shuffle_img); clutter_container_add_actor(CLUTTER_CONTAINER(stage), shuffle_img); play_img = clutter_texture_new_from_file("icons/playing.png", NULL); clutter_actor_set_name(play_img, "play_img"); clutter_actor_set_size(play_img, 20, 20); clutter_actor_set_position(play_img, 400, 102); clutter_actor_hide(play_img); clutter_container_add_actor(CLUTTER_CONTAINER(stage), play_img); pause_img = clutter_texture_new_from_file("icons/paused.png", NULL); clutter_actor_set_name(pause_img, "pause_img"); clutter_actor_set_size(pause_img, 20, 20); clutter_actor_set_position(pause_img, 400, 102); clutter_actor_hide(pause_img); clutter_container_add_actor(CLUTTER_CONTAINER(stage), pause_img); }
static ClutterActor * _make_offline_banner (MnbPeoplePanel *pane, gint width) { ClutterActor *tile; ClutterActor *tmp_text; ClutterActor *label, *bin; tile = mx_table_new (); mx_table_set_row_spacing (MX_TABLE (tile), 8); clutter_actor_set_width (tile, width); clutter_actor_set_name (tile, "people-pane-you-offline-banner"); label = mx_label_new_with_text (_("To see your IM contacts, " "you need to go online.")); clutter_actor_set_name (label, "people-pane-you-offline-label"); tmp_text = mx_label_get_clutter_text (MX_LABEL (label)); clutter_text_set_line_wrap (CLUTTER_TEXT (tmp_text), TRUE); clutter_text_set_line_wrap_mode (CLUTTER_TEXT (tmp_text), PANGO_WRAP_WORD_CHAR); clutter_text_set_ellipsize (CLUTTER_TEXT (tmp_text), PANGO_ELLIPSIZE_NONE); bin = mx_frame_new (); mx_bin_set_child (MX_BIN (bin), (label)); mx_bin_set_alignment (MX_BIN (bin), MX_ALIGN_START, MX_ALIGN_MIDDLE); mx_bin_set_fill (MX_BIN (bin), FALSE, TRUE); clutter_actor_set_name (bin, "people-pane-you-offline-bin"); mx_table_insert_actor_with_properties (MX_TABLE (tile), (ClutterActor *)bin, 0, 0, "x-expand", TRUE, "y-expand", FALSE, "x-fill", TRUE, "y-fill", FALSE, "x-align", MX_ALIGN_START, NULL); return tile; }
static void mnb_launcher_button_init (MnbLauncherButton *self) { ClutterActor *label; self->priv = MNB_LAUNCHER_BUTTON_GET_PRIVATE (self); g_signal_connect (self, "leave-event", G_CALLBACK (_leave_event_cb), NULL); g_signal_connect (self, "key-focus-out", G_CALLBACK (_leave_event_cb), NULL); g_signal_connect (self, "enter-event", G_CALLBACK (_enter_event_cb), NULL); self->priv->icon = NULL; mx_stylable_set_style_class (MX_STYLABLE (self), "contentTile"); /* "app" label */ self->priv->title = (MxLabel *) mx_label_new (); mx_label_set_x_align (MX_LABEL (self->priv->title), MX_ALIGN_MIDDLE); clutter_actor_set_reactive (CLUTTER_ACTOR (self->priv->title), FALSE); mx_table_insert_actor_with_properties (MX_TABLE (self), CLUTTER_ACTOR (self->priv->title), 1, 0, "x-align", MX_ALIGN_MIDDLE, "x-expand", TRUE, "x-fill", TRUE, "y-align", MX_ALIGN_MIDDLE, "y-expand", TRUE, "y-fill", TRUE, NULL); label = mx_label_get_clutter_text (self->priv->title); clutter_text_set_ellipsize (CLUTTER_TEXT (label), PANGO_ELLIPSIZE_END); clutter_text_set_line_alignment (CLUTTER_TEXT (label), PANGO_ALIGN_CENTER); clutter_text_set_line_wrap (CLUTTER_TEXT (label), TRUE); clutter_text_set_line_wrap_mode (CLUTTER_TEXT (label), PANGO_WRAP_WORD_CHAR); /* "fav app" toggle */ self->priv->fav_toggle = g_object_ref_sink (CLUTTER_ACTOR (mx_button_new ())); mx_button_set_is_toggle (MX_BUTTON (self->priv->fav_toggle), TRUE); clutter_actor_set_name (CLUTTER_ACTOR (self->priv->fav_toggle), "mnb-launcher-button-fav-toggle"); clutter_actor_set_size (self->priv->fav_toggle, FAV_TOGGLE_SIZE, FAV_TOGGLE_SIZE); mx_table_insert_actor (MX_TABLE (self), CLUTTER_ACTOR (self->priv->fav_toggle), 0, 0); g_signal_connect (self->priv->fav_toggle, "notify::toggled", G_CALLBACK (fav_button_notify_toggled_cb), self); clutter_actor_set_reactive ((ClutterActor *) self, TRUE); }
static void mpd_volume_tile_init (MpdVolumeTile *self) { MpdVolumeTilePrivate *priv = GET_PRIVATE (self); ClutterActor *icon; /* Layout */ mx_box_layout_set_spacing (MX_BOX_LAYOUT (self), MPD_TILE_ICON_SPACING); icon = mx_icon_new (); clutter_actor_set_name (icon, "volume-off"); mx_box_layout_add_actor_with_properties (MX_BOX_LAYOUT (self), icon, -1, "y-fill", FALSE, NULL); priv->volume_slider = mx_slider_new (); mx_box_layout_add_actor_with_properties (MX_BOX_LAYOUT (self), priv->volume_slider, -1, "expand", TRUE, NULL); g_signal_connect (priv->volume_slider, "notify::value", G_CALLBACK (_volume_slider_value_notify_cb), self); icon = mx_icon_new (); clutter_actor_set_name (icon, "volume-on"); mx_box_layout_add_actor_with_properties (MX_BOX_LAYOUT (self), icon, -1, "y-fill", FALSE, NULL); /* Control */ priv->control = gvc_mixer_control_new (MIXER_CONTROL_NAME); g_signal_connect (priv->control, "default-sink-changed", G_CALLBACK (_mixer_control_default_sink_changed_cb), self); g_signal_connect (priv->control, "ready", G_CALLBACK (_mixer_control_ready_cb), self); gvc_mixer_control_open (priv->control); }
static ClutterActor * _make_everybody_offline_tile (MnbPeoplePanel *pane) { ClutterActor *tile; ClutterActor *label, *bin; ClutterActor *tmp_text; tile = mx_table_new (); mx_table_set_row_spacing (MX_TABLE (tile), 8); clutter_actor_set_name ((ClutterActor *)tile, "people-pane-everybody-offline-tile"); label = mx_label_new_with_text (_("Sorry, we can't find any people. " \ "It looks like they are all offline.")); clutter_actor_set_name ((ClutterActor *)label, "people-pane-everybody-offline-label"); tmp_text = mx_label_get_clutter_text (MX_LABEL (label)); clutter_text_set_line_wrap (CLUTTER_TEXT (tmp_text), TRUE); clutter_text_set_line_wrap_mode (CLUTTER_TEXT (tmp_text), PANGO_WRAP_WORD_CHAR); clutter_text_set_ellipsize (CLUTTER_TEXT (tmp_text), PANGO_ELLIPSIZE_NONE); bin = mx_frame_new (); mx_bin_set_child (MX_BIN (bin), label); mx_bin_set_alignment (MX_BIN (bin), MX_ALIGN_START, MX_ALIGN_MIDDLE); mx_bin_set_fill (MX_BIN (bin), FALSE, TRUE); clutter_actor_set_name (bin, "people-pane-everybody-offline-bin"); mx_table_insert_actor_with_properties (MX_TABLE (tile), (ClutterActor *)bin, 0, 0, "x-expand", TRUE, "y-expand", FALSE, "x-fill", TRUE, "y-fill", FALSE, "x-align", MX_ALIGN_START, NULL); return tile; }
static ClutterActor * _make_messenger_launcher_tile (MnbPeoplePanel *panel) { ClutterActor *table; ClutterActor *icon_tex; ClutterActor *button; GAppInfo *app_info; gchar *button_str; ClutterActor *bin; bin = mx_frame_new (); clutter_actor_set_name (bin, "people-panel-messenger-launcher-tile"); table = mx_table_new (); mx_bin_set_child (MX_BIN (bin), table); mx_table_set_column_spacing (MX_TABLE (table), 16); app_info = (GAppInfo *)g_desktop_app_info_new ("empathy.desktop"); icon_tex = g_object_new (MX_TYPE_ICON, "icon-name", "netbook-empathy", NULL); mx_table_add_actor_with_properties (MX_TABLE (table), icon_tex, 0, 0, "x-expand", FALSE, "y-expand", TRUE, "x-fill", FALSE, "y-fill", FALSE, NULL); button_str = g_strdup_printf (_("Open %s"), g_app_info_get_name (app_info)); button = mx_button_new_with_label (button_str); g_free (button_str); g_signal_connect (button, "clicked", (GCallback)_messenger_launcher_button_clicked_cb, panel); mx_table_add_actor_with_properties (MX_TABLE (table), button, 0, 1, "x-expand", FALSE, "y-expand", TRUE, "x-fill", FALSE, "y-fill", FALSE, NULL); g_object_unref (app_info); return bin; }
int main(int argc, char **argv) { ClutterActor *stage; ClutterColor stage_clr = { 0x00, 0x00, 0x00, 0xff }; const gchar *stage_title = { "potassium music player" }; struct sigaction action; g_set_application_name("potassium music player"); clutter_init(&argc, &argv); stage = clutter_stage_get_default(); clutter_actor_set_size(stage, 512, 128); clutter_stage_set_color(CLUTTER_STAGE(stage), &stage_clr); clutter_stage_set_title(CLUTTER_STAGE(stage), stage_title); clutter_actor_set_name(stage, "stage"); clutter_actor_show(stage); /* Setup signal handler for USR1 to dump player state */ memset(&action, 0, sizeof(&action)); sigemptyset(&action.sa_mask); action.sa_handler = dump_data; action.sa_flags = SA_RESTART; sigaction(SIGUSR1, &action, NULL); /* Handle keyboard/mouse events */ g_signal_connect(stage, "event", G_CALLBACK(input_events_cb), NULL); mozart_init(argc, argv); if (argc == 2) { /* * strdup() argv[1] here, as it seems to get mangled by * generate_playlist() */ generate_playlist(strdup(argv[1]), strdup(argv[1])); mozart_switch_playlist(argv[1]); } else { read_checkpoint_data(); } init_icons(stage); g_timeout_add(500, (GSourceFunc)update_display, stage); g_timeout_add_seconds(1, (GSourceFunc)write_checkpoint_data, NULL); g_signal_connect(mozart_bus, "message::state-changed", G_CALLBACK(set_status_icons), stage); clutter_main(); mozart_destroy(); exit(0); }
static void mx_slider_init (MxSlider *self) { MxSliderPrivate *priv; self->priv = priv = SLIDER_PRIVATE (self); g_signal_connect (self, "style-changed", G_CALLBACK (mx_slider_style_changed_cb), NULL); priv->trough_bg = CLUTTER_ACTOR (_mx_progress_bar_fill_new ()); clutter_actor_set_name (priv->trough_bg, "trough-background"); clutter_actor_set_reactive (priv->trough_bg, TRUE); clutter_actor_add_child (CLUTTER_ACTOR (self), priv->trough_bg); g_signal_connect (priv->trough_bg, "button-press-event", G_CALLBACK (on_trough_bg_button_press_event), self); g_signal_connect (priv->trough_bg, "button-release-event", G_CALLBACK (on_trough_bg_button_release_event), self); g_signal_connect (priv->trough_bg, "leave-event", G_CALLBACK (on_trough_bg_leave_event), self); priv->fill = CLUTTER_ACTOR (_mx_progress_bar_fill_new ()); clutter_actor_set_name (priv->fill, "fill"); clutter_actor_add_child (CLUTTER_ACTOR (self), priv->fill); priv->trough = CLUTTER_ACTOR (mx_frame_new ()); clutter_actor_set_name (priv->trough, "trough"); clutter_actor_add_child (CLUTTER_ACTOR (self), priv->trough); self->priv->handle = CLUTTER_ACTOR (mx_button_new ()); clutter_actor_set_name (priv->handle, "handle"); clutter_actor_add_child (CLUTTER_ACTOR (self), priv->handle); g_signal_connect (priv->handle, "button-press-event", G_CALLBACK (on_handle_button_press_event), self); priv->buffer = _mx_progress_bar_fill_new (); clutter_actor_set_name (priv->buffer, "buffer"); clutter_actor_add_child (CLUTTER_ACTOR (self), priv->buffer); }
void mnp_clock_tile_refresh (MnpClockTile *tile, time_t now, gboolean tfh) { MnpDateFormat *fmt; tile->priv->time_now = now; fmt = mnp_format_time_from_location (tile->priv->loc, tile->priv->time_now, tfh); mx_label_set_text ((MxLabel *)tile->priv->time, fmt->time); mx_label_set_text ((MxLabel *)tile->priv->date, fmt->date); clutter_actor_set_name ((ClutterActor *)tile->priv->time, fmt->day ? "ClockTileTimeDay" : "ClockTileTimeNight"); FREE_DFMT(fmt); }
static ClutterActor * make_status (DawatiStatusPanel *status_panel) { ClutterActor *pane; ClutterActor *table; ClutterActor *label; status_panel->client = sw_client_new (); #if 0 pane = mps_feed_pane_new (status_panel->client, sw_client_get_service (status_panel->client, "twitter")); #endif table = mx_table_new (); mx_table_set_row_spacing (MX_TABLE (table), 6); clutter_actor_set_name (table, "status-panel"); label = mx_label_new_with_text (_("Status")); clutter_actor_set_name (label, "status-panel-header-label"); mx_table_add_actor_with_properties (MX_TABLE (table), label, 0, 0, "x-expand", FALSE, "y-expand", FALSE, NULL); pane = mps_feed_switcher_new (status_panel->client); mx_table_add_actor_with_properties (MX_TABLE (table), pane, 1, 0, "x-expand", TRUE, "y-expand", TRUE, "x-fill", TRUE, "y-fill", TRUE, NULL); return table; }
static ClutterActor * make_bouncer (const ClutterColor *base_color, gfloat width, gfloat height) { ClutterActor *retval; cairo_t *cr; cairo_pattern_t *pattern; gfloat radius = MAX (width, height); retval = clutter_cairo_texture_new (width, height); cr = clutter_cairo_texture_create (CLUTTER_CAIRO_TEXTURE (retval)); cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR); cairo_paint (cr); cairo_set_operator (cr, CAIRO_OPERATOR_ADD); cairo_arc (cr, radius / 2, radius / 2, radius / 2, 0.0, 2.0 * G_PI); pattern = cairo_pattern_create_radial (radius / 2, radius / 2, 0, radius, radius, radius); cairo_pattern_add_color_stop_rgba (pattern, 0, base_color->red / 255.0, base_color->green / 255.0, base_color->blue / 255.0, base_color->alpha / 255.0); cairo_pattern_add_color_stop_rgba (pattern, 0.9, base_color->red / 255.0, base_color->green / 255.0, base_color->blue / 255.0, 0.1); cairo_set_source (cr, pattern); cairo_fill_preserve (cr); cairo_pattern_destroy (pattern); cairo_destroy (cr); clutter_actor_set_name (retval, "bouncer"); clutter_actor_set_size (retval, width, height); clutter_actor_set_anchor_point (retval, width / 2, height / 2); clutter_actor_set_reactive (retval, TRUE); return retval; }
/** * clutter_test_get_stage: * * Retrieves the #ClutterStage used for testing. * * Return value: (transfer none): the stage used for testing * * Since: 1.18 */ ClutterActor * clutter_test_get_stage (void) { g_assert (test_environ != NULL); if (test_environ->stage == NULL) { /* create a stage, and ensure that it goes away at the end */ test_environ->stage = clutter_stage_new (); clutter_actor_set_name (test_environ->stage, "Test Stage"); g_object_add_weak_pointer (G_OBJECT (test_environ->stage), (gpointer *) &test_environ->stage); } return test_environ->stage; }
static void timeline_complete (ClutterTimeline *timeline, ClutterActor *expander) { guchar opacity; MxExpanderPrivate *priv = MX_EXPANDER (expander)->priv; g_signal_emit (expander, expander_signals[EXPAND_COMPLETE], 0); /* if the expander is now closed, update the style */ if (!priv->expanded) { clutter_actor_set_name (priv->arrow, "mx-expander-arrow-closed"); mx_stylable_set_style_class (MX_STYLABLE (expander), "closed-expander"); clutter_actor_queue_relayout (expander); } if (!priv->child) return; /* continue only if we are "opening" */ if (!priv->expanded) return; /* we can't do an animation if there is already one in progress, * because we cannot get the actors original opacity */ if (clutter_actor_get_transition (priv->child, "opacity")) { clutter_actor_show (priv->child); return; } opacity = clutter_actor_get_opacity (priv->child); clutter_actor_set_opacity (priv->child, 0); clutter_actor_show (priv->child); clutter_actor_save_easing_state (priv->child); clutter_actor_set_easing_mode (priv->child, CLUTTER_EASE_IN_SINE); clutter_actor_set_easing_duration (priv->child, 100); clutter_actor_set_opacity (priv->child, opacity); clutter_actor_restore_easing_state (priv->child); }
/** * mx_toolbar_set_has_close_button: * @toolbar: A #MxToolbar * @has_close_button: #TRUE if a close button should be displayed * * Set the #MxToolbar:has-close-button property * */ void mx_toolbar_set_has_close_button (MxToolbar *toolbar, gboolean has_close_button) { MxToolbarPrivate *priv; g_return_if_fail (MX_IS_TOOLBAR (toolbar)); priv = toolbar->priv; if (priv->has_close_button != has_close_button) { priv->has_close_button = has_close_button; if (!has_close_button) { if (priv->close_button) { clutter_actor_destroy (priv->close_button); priv->close_button = NULL; } } else { priv->close_button = mx_button_new (); clutter_actor_set_name (priv->close_button, "close-button"); clutter_actor_add_child (CLUTTER_ACTOR (toolbar), priv->close_button); g_signal_connect (priv->close_button, "clicked", G_CALLBACK (close_button_click_cb), toolbar); mx_stylable_style_changed (MX_STYLABLE (priv->close_button), MX_STYLE_CHANGED_FORCE); } clutter_actor_queue_relayout (CLUTTER_ACTOR (toolbar)); g_object_notify (G_OBJECT (toolbar), "has-close-button"); } }
static void mpd_devices_pane_init (MpdDevicesPane *self) { ClutterActor *label; ClutterActor *tile; mx_box_layout_set_orientation (MX_BOX_LAYOUT (self), MX_ORIENTATION_VERTICAL); clutter_actor_set_width (CLUTTER_ACTOR (self), MPD_DEVICES_PANE_WIDTH); label = mx_label_new_with_text (_("Other devices")); clutter_actor_set_name (label, "pane-label"); clutter_container_add_actor (CLUTTER_CONTAINER (self), label); tile = mpd_devices_tile_new (); g_signal_connect (tile, "request-hide", G_CALLBACK (_tile_request_hide_cb), self); g_signal_connect (tile, "request-show", G_CALLBACK (_tile_request_show_cb), self); clutter_container_add_actor (CLUTTER_CONTAINER (self), tile); clutter_container_child_set (CLUTTER_CONTAINER (self), tile, "expand", true, NULL); }
G_MODULE_EXPORT int test_egl_image_main (int argc, char **argv) { static const ClutterColor stage_color = { 0x1f, 0x84, 0x56, 0xff }; ClutterActor *stage; ClutterActor *texture; ClutterX11TexturePixmap *x11_texture; Window window; clutter_init (&argc, &argv); if (argc != 2) { g_printerr ("usage: clutter-test xid\n"); return EXIT_FAILURE; } window = (Window)strtol (argv[1], NULL, 0); g_print ("Attempting to redirect window 0x%08x\n", (guint)window); stage = clutter_stage_get_default (); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); texture = clutter_eglx_egl_image_new_with_window (window); x11_texture = CLUTTER_X11_TEXTURE_PIXMAP (texture); clutter_x11_texture_pixmap_set_automatic (x11_texture, TRUE); clutter_actor_set_name (texture, "EGL Image"); clutter_container_add (CLUTTER_CONTAINER (stage), texture, NULL); clutter_actor_set_size (stage, 512, 512); clutter_actor_show (stage); clutter_main (); return EXIT_SUCCESS; }
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); }
static ClutterActor * create_scroll_actor (ClutterActor *stage) { ClutterActor *scroll; ClutterAction *pan_action; /* our scrollable viewport */ scroll = clutter_actor_new (); clutter_actor_set_name (scroll, "scroll"); clutter_actor_add_constraint (scroll, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0)); clutter_actor_add_constraint (scroll, clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0)); clutter_actor_add_child (scroll, create_content_actor ()); pan_action = clutter_pan_action_new (); clutter_pan_action_set_interpolate (CLUTTER_PAN_ACTION (pan_action), TRUE); g_signal_connect (pan_action, "pan", G_CALLBACK (on_pan), NULL); clutter_actor_add_action (scroll, pan_action); clutter_actor_set_reactive (scroll, TRUE); return scroll; }
ClutterActor * setup_camera_texture(ClutterActor *stage) { ClutterActor *texture; GstPipeline *pipeline; GstElement *videosrc0; GstElement *flip0; GstElement *colorspace0; GstElement *alpha0; GstElement *colorspace1; GstElement *cluttersink0; GstElement *videomixer; GstElement *colorspacemix; GstElement *multifilesrc; GstElement *decodebin; GstElement *colorspace; GstElement *videoformat; GstElement *deinterlace; /* We need to set certain props on the target texture currently for * efficient/corrent playback onto the texture (which sucks a bit) */ texture = g_object_new(CLUTTER_TYPE_TEXTURE, "disable-slicing", TRUE, NULL); /* Set up pipeline */ pipeline = GST_PIPELINE(gst_pipeline_new (NULL)); if (option_videotestsrc) videosrc0 = gst_element_factory_make("videotestsrc", "videotestsrc0"); else videosrc0 = gst_element_factory_make("gconfvideosrc", "gconfvideosrc0"); // or autovideosrc? // TODO: check if option_flip_horizontal flip0 = gst_element_factory_make("videoflip", "videoflip0"); g_object_set(G_OBJECT (flip0), "method", 4, NULL); // GST_VIDEO_FLIP_METHOD_HORIZ colorspace0 = gst_element_factory_make("ffmpegcolorspace", "colorspace0"); //colorspace1 = gst_element_factory_make("ffmpegcolorspace", "colorspace1"); //alpha0 = gst_element_factory_make("alpha", "alpha0"); //videomixer = gst_element_factory_make("videomixer", NULL); //colorspacemix = gst_element_factory_make("ffmpegcolorspace", NULL); //multifilesrc = gst_element_factory_make("multifilesrc", NULL); //decodebin = gst_element_factory_make("jpegdec", NULL); //colorspace = gst_element_factory_make("ffmpegcolorspace", NULL); videoformat = gst_element_factory_make("capsfilter", NULL); cluttersink0 = gst_element_factory_make("cluttersink", "cluttersink0"); //deinterlace = gst_element_factory_make("deinterlace", NULL); //g_object_set(alpha0, "method", 3, NULL); // 1 -> ALPHA_METHOD_GREEN 3 -> ALPHA_METHOD_CUSTOM //g_object_set(G_OBJECT (multifilesrc),"location",DEFAULT_IMAGE_PATH,NULL); GstCaps *imagecaps = gst_caps_from_string ("video/x-raw-yuv,format=(fourcc)AYUV"); g_object_set (videoformat,"caps", imagecaps, NULL); g_object_set(cluttersink0, "texture", CLUTTER_TEXTURE(texture), NULL); GstElement *tee0 = gst_element_factory_make("tee", "tee0"); GstElement *queue0 = gst_element_factory_make("queue", "queue0"); GstElement *queue1 = gst_element_factory_make("queue", "queue1"); GstElement *queue2 = gst_element_factory_make("queue", "queue2"); GstElement *xvimagesink0 = gst_element_factory_make("xvimagesink", "xvimagesink0"); g_object_set(xvimagesink0, "force-aspect-ratio", TRUE, NULL); gst_bin_add_many(GST_BIN(pipeline), videosrc0, //alpha0, colorspace0, tee0, flip0, queue0, queue1, queue2, //colorspace1, cluttersink0, xvimagesink0, //videomixer, //colorspacemix, // multifilesrc, // decodebin, //colorspace, videoformat, //deinterlace, NULL); //image branch //link_or_die(multifilesrc,decodebin); //link_or_die(decodebin,colorspace); //link_or_die(colorspace,videoformat); //link_or_die(videoformat,videomixer); //link_or_die(videosrc0, deinterlace); link_or_die(videosrc0, colorspace0); link_or_die(colorspace0, flip0); link_or_die(flip0, queue2); link_or_die(queue2, tee0); if (! gst_element_link_pads(tee0, "src0", queue0, "sink")) g_error("Could not link %s to %s.\n", "tee0", "queue0"); if (! gst_element_link_pads(tee0, "src1", queue1, "sink")) g_error("Could not link %s to %s.\n", "tee0", "queue1"); link_or_die(queue0, cluttersink0); //link_or_die(alpha0, videomixer); //link_or_die(videomixer,colorspacemix); //link_or_die(colorspacemix,cluttersink0); link_or_die(queue1, xvimagesink0); //saving objects for extrernal control //g_object_set_data (G_OBJECT (texture), "gstalpha", alpha0); //g_object_set_data (G_OBJECT (texture), "gstfile", multifilesrc); // TODO: // if (option_verbose) // { // g_print("videosrc0 -- colorspace0 -- queue2 -- tee0 -- queue0 -- alpha0 -- cluttersink0\n"); // g_print(" -- queue1 -- xvimagesink0\n"); // } gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_PLAYING); clutter_actor_set_name(texture, LIVEVIDEO_ACTOR); return texture; }