void
opt_show_add_slide (OptShow *self, OptSlide *slide)
{
ClutterActor *bg, *stage;
self->priv->slides = g_list_append(self->priv->slides, slide);
self->priv->num_slides++;
stage = clutter_stage_get_default();
bg = CLUTTER_ACTOR(opt_slide_get_background_texture (slide));
if (bg == NULL)
bg = clutter_clone_new(self->priv->bg);
clutter_actor_set_size (bg,
clutter_actor_get_width (stage),
clutter_actor_get_height (stage));
clutter_group_add (CLUTTER_GROUP(slide), bg);
clutter_actor_lower_bottom(bg);
clutter_actor_show(bg);
opt_menu_add_slide (self->priv->menu, slide);
}
void
gnome_app_actor_add_background (ClutterActor *actor, gchar *filename)
{
ClutterActor *texture;
ClutterActor *parent;
GError *error;
gfloat width, height;
gfloat x, y;
error = NULL;
texture = clutter_texture_new_from_file (filename, &error);
clutter_actor_set_opacity (texture, 128);
if (error) {
g_error ("Error in add background: %s\n", error->message);
g_error_free (error);
return;
}
clutter_actor_get_size (actor, &width, &height);
clutter_actor_set_size (texture, width, height);
if (CLUTTER_IS_CONTAINER (actor)) {
clutter_container_add_actor (CLUTTER_CONTAINER (actor), texture);
clutter_actor_set_position (texture, 0, 0);
} else {
parent = clutter_actor_get_parent (actor);
clutter_container_add_actor (CLUTTER_CONTAINER (parent), texture);
clutter_actor_get_position (actor, &x, &y);
clutter_actor_set_position (texture, x, y);
}
/*This make it real background ...
* TODO: how about both par/child actor with background */
clutter_actor_lower_bottom (texture);
}
static void
page_transition_frame_cb (OptTransition *trans,
gint frame_num,
gpointer data)
{
OptSlide *from, *to;
ClutterActor *stage;
ClutterColor color = { 0x22, 0x22, 0x22, 0xff };
OptTransitionPrivate *priv;
gint mult, n_frames;
priv = trans->priv;
from = opt_transition_get_from (trans);
to = opt_transition_get_to (trans);
stage = clutter_stage_get_default();
clutter_actor_show_all (CLUTTER_ACTOR(to));
mult = priv->direction ? -1 : 1;
n_frames = clutter_timeline_get_n_frames (CLUTTER_TIMELINE(trans));
if (frame_num > n_frames/2)
{
/* Fix Z ordering */
clutter_actor_lower_bottom (CLUTTER_ACTOR(from));
}
clutter_stage_set_color (CLUTTER_STAGE(stage), &color);
clutter_actor_set_rotation (CLUTTER_ACTOR(from),
CLUTTER_Y_AXIS,
- (float)frame_num * 2 * mult,
CLUTTER_STAGE_WIDTH()*3/2,
0,
-1 * (CLUTTER_STAGE_WIDTH()/2));
clutter_actor_set_rotation (CLUTTER_ACTOR(to),
CLUTTER_Y_AXIS,
(mult * 60) - (frame_num * 2 * mult),
CLUTTER_STAGE_WIDTH()*3/2,
0,
-1 * (CLUTTER_STAGE_WIDTH()/2));
}
static int mp_constructor(TPMediaPlayer * mp)
{
static int init=0;
if (!init)
{
init=1;
gst_init(NULL,NULL);
}
ClutterActor * video_texture=clutter_gst_video_texture_new();
if (!video_texture)
{
g_warning("FAILED TO CREATE CLUTTER GST VIDEO TEXTURE");
return TP_MEDIAPLAYER_ERROR_NO_MEDIAPLAYER;
}
// We own it
g_object_ref_sink(G_OBJECT(video_texture));
// Get the stage, size the video texture and add it to the stage
clutter_actor_hide(video_texture);
ClutterActor * stage=clutter_stage_get_default();
gfloat width,height;
clutter_actor_get_size(stage,&width,&height);
clutter_actor_set_size(video_texture,width,height);
clutter_actor_set_position(video_texture,0,0);
clutter_container_add_actor(CLUTTER_CONTAINER(stage),video_texture);
clutter_actor_lower_bottom(video_texture);
g_signal_connect( stage , "notify::allocation" , ( GCallback ) stage_allocation_notify , video_texture );
// Connect signals
g_signal_connect(video_texture,"eos",G_CALLBACK(mp_end_of_stream),mp);
g_signal_connect(video_texture,"error",G_CALLBACK(mp_error),mp);
// We use gmalloc0 to zero out the whole structure
UserData * user_data=(UserData*) g_malloc0(sizeof(UserData));
user_data->vt=video_texture;
mp->user_data=user_data;
mp->destroy=mp_destroy;
mp->load=mp_load;
mp->reset=mp_reset;
mp->play=mp_play;
mp->seek=mp_seek;
mp->pause=mp_pause;
mp->set_playback_rate=mp_set_playback_rate;
mp->get_position=mp_get_position;
mp->get_duration=mp_get_duration;
mp->get_buffered_duration=mp_get_buffered_duration;
mp->get_video_size=mp_get_video_size;
mp->get_viewport_geometry=mp_get_viewport_geometry;
mp->set_viewport_geometry=mp_set_viewport_geometry;
mp->get_media_type=mp_get_media_type;
mp->get_audio_volume=mp_get_audio_volume;
mp->set_audio_volume=mp_set_audio_volume;
mp->get_audio_mute=mp_get_audio_mute;
mp->set_audio_mute=mp_set_audio_mute;
mp->play_sound=mp_play_sound;
mp->get_viewport_texture=mp_get_viewport_texture;
return 0;
}
G_MODULE_EXPORT int
test_bin_layout_main (int argc, char *argv[])
{
ClutterActor *stage, *box, *rect;
ClutterLayoutManager *layout;
ClutterColor stage_color = { 0xe0, 0xf2, 0xfc, 0xff };
ClutterColor bg_color = { 0xcc, 0xcc, 0xcc, 0x99 };
ClutterColor *color;
clutter_init (&argc, &argv);
stage = clutter_stage_get_default ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Box test");
clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);
clutter_actor_set_size (stage, 640, 480);
layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_BIN_ALIGNMENT_CENTER);
box = clutter_box_new (layout);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), box);
clutter_actor_set_anchor_point_from_gravity (box, CLUTTER_GRAVITY_CENTER);
clutter_actor_set_position (box, 320, 240);
clutter_actor_set_reactive (box, TRUE);
clutter_actor_set_name (box, "box");
rect = make_background (&bg_color, 200, 200);
/* first method: use clutter_box_pack() */
clutter_box_pack (CLUTTER_BOX (box), rect,
"x-align", CLUTTER_BIN_ALIGNMENT_FILL,
"y-align", CLUTTER_BIN_ALIGNMENT_FILL,
NULL);
clutter_actor_lower_bottom (rect);
clutter_actor_set_name (rect, "background");
{
ClutterActor *tex;
GError *error;
gchar *file;
error = NULL;
file = g_build_filename (TESTS_DATADIR, "redhand.png", NULL);
tex = clutter_texture_new_from_file (file, &error);
if (error)
g_error ("Unable to create texture: %s", error->message);
clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (tex), TRUE);
/* second method: use clutter_bin_layout_add() */
clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (layout), tex,
CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_BIN_ALIGNMENT_CENTER);
clutter_actor_raise (tex, rect);
clutter_actor_set_width (tex, 175);
clutter_actor_set_name (tex, "texture");
g_free (file);
}
color = clutter_color_new (g_random_int_range (0, 255),
g_random_int_range (0, 255),
g_random_int_range (0, 255),
224);
rect = clutter_rectangle_new_with_color (color);
/* third method: container_add() and set_alignment() */
clutter_container_add_actor (CLUTTER_CONTAINER (box), rect);
clutter_bin_layout_set_alignment (CLUTTER_BIN_LAYOUT (layout), rect,
CLUTTER_BIN_ALIGNMENT_END,
CLUTTER_BIN_ALIGNMENT_END);
clutter_actor_set_size (rect, 50, 50);
clutter_actor_set_opacity (rect, 0);
clutter_actor_raise_top (rect);
clutter_actor_set_name (rect, "emblem");
g_signal_connect (box,
"enter-event", G_CALLBACK (on_box_enter),
rect);
g_signal_connect (box,
"leave-event", G_CALLBACK (on_box_leave),
rect);
clutter_actor_show_all (stage);
clutter_main ();
clutter_color_free (color);
return EXIT_SUCCESS;
}
IO_METHOD(IoClutterActor, lowerToBottom) {
clutter_actor_lower_bottom(IOCACTOR(self));
return self;
}
static void
load_controls (UserInterface * ui)
{
// Check icon files exist
gchar *vid_panel_png;
gchar *icon_files[6];
gchar *duration_str;
gint c;
ClutterColor control_color1 = { 0x12, 0x12, 0x12, 0xff };
ClutterColor control_color2 = { 0xcc, 0xcc, 0xcc, 0xff };
ClutterLayoutManager *controls_layout;
ClutterLayoutManager *main_box_layout;
ClutterLayoutManager *info_box_layout;
ClutterLayoutManager *bottom_box_layout;
ClutterLayoutManager *volume_box_layout;
ClutterLayoutManager *seek_box_layout;
ClutterLayoutManager *vol_int_box_layout;
ClutterActor *seek_box;
ClutterActor *bottom_box;
ClutterActor *vol_int_box;
GError *error = NULL;
vid_panel_png = g_strdup_printf ("%s%s", SNAPPY_DATA_DIR, "/vid-panel.png");
ui->play_png = g_strdup_printf ("%s%s", SNAPPY_DATA_DIR,
"/media-actions-start.png");
ui->pause_png = g_strdup_printf ("%s%s", SNAPPY_DATA_DIR,
"/media-actions-pause.png");
ui->volume_low_png = g_strdup_printf ("%s%s", SNAPPY_DATA_DIR,
"/audio-volume-low.png");
ui->volume_high_png = g_strdup_printf ("%s%s", SNAPPY_DATA_DIR,
"/audio-volume-high.png");
ui->segment_png = g_strdup_printf ("%s%s", SNAPPY_DATA_DIR,
"/media-actions-segment-point.png");
icon_files[0] = vid_panel_png;
icon_files[1] = ui->play_png;
icon_files[2] = ui->pause_png;
icon_files[3] = ui->volume_low_png;
icon_files[4] = ui->volume_high_png;
icon_files[5] = ui->segment_png;
for (c = 0; c < 6; c++) {
if (!g_file_test (icon_files[c], G_FILE_TEST_EXISTS)) {
g_print ("Icon file doesn't exist, are you sure you have "
" installed snappy correctly?\nThis file needed is: %s\n",
icon_files[c]);
}
}
// Controls layout management
controls_layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_FIXED,
CLUTTER_BIN_ALIGNMENT_FIXED);
ui->control_box = clutter_box_new (controls_layout);
// Controls background
ui->control_bg = clutter_texture_new_from_file (vid_panel_png, &error);
if (!ui->control_bg && error)
g_debug ("Clutter error: %s\n", error->message);
if (error) {
g_error_free (error);
error = NULL;
}
g_free (vid_panel_png);
clutter_container_add_actor (CLUTTER_CONTAINER (ui->control_box),
ui->control_bg);
// Controls play toggle
main_box_layout = clutter_box_layout_new ();
clutter_box_layout_set_vertical (CLUTTER_BOX_LAYOUT (main_box_layout), FALSE);
ui->main_box = clutter_box_new (main_box_layout);
ui->control_play_toggle =
clutter_texture_new_from_file (ui->pause_png, &error);
if (!ui->control_play_toggle && error)
g_debug ("Clutter error: %s\n", error->message);
if (error) {
g_error_free (error);
error = NULL;
}
clutter_box_layout_pack (CLUTTER_BOX_LAYOUT (main_box_layout),
ui->control_play_toggle,
FALSE, /* expand */
FALSE, /* x-fill */
FALSE, /* y-fill */
CLUTTER_BOX_ALIGNMENT_START, /* x-align */
CLUTTER_BOX_ALIGNMENT_CENTER); /* y-align */
clutter_container_add_actor (CLUTTER_CONTAINER (ui->control_box),
ui->main_box);
g_assert (ui->control_bg && ui->control_play_toggle);
// Controls title
info_box_layout = clutter_box_layout_new ();
clutter_box_layout_set_vertical (CLUTTER_BOX_LAYOUT (info_box_layout), TRUE);
ui->info_box = clutter_box_new (info_box_layout);
ui->control_title = clutter_text_new_full ("Sans 32px",
cut_long_filename (ui->filename, ui->title_length), &control_color1);
clutter_text_set_max_length (CLUTTER_TEXT (ui->control_title),
ui->title_length);
clutter_box_layout_pack (CLUTTER_BOX_LAYOUT (info_box_layout),
ui->control_title,
TRUE, /* expand */
FALSE, /* x-fill */
FALSE, /* y-fill */
CLUTTER_BOX_ALIGNMENT_CENTER, /* x-align */
CLUTTER_BOX_ALIGNMENT_START); /* y-align */
// Controls seek
seek_box_layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_FIXED,
CLUTTER_BIN_ALIGNMENT_FIXED);
seek_box = clutter_box_new (seek_box_layout);
// In point
ui->in_point = clutter_texture_new_from_file (ui->segment_png, &error);
if (!ui->in_point && error)
g_debug ("Clutter error: %s\n", error->message);
if (error) {
g_error_free (error);
error = NULL;
}
clutter_container_add_actor (CLUTTER_CONTAINER (seek_box), ui->in_point);
// background box rectangle shows as the border
ui->control_seek1 = clutter_rectangle_new_with_color (&control_color1);
clutter_container_add_actor (CLUTTER_CONTAINER (seek_box), ui->control_seek1);
// smaller background rectangle inside seek1 to create a border
ui->control_seek2 = clutter_rectangle_new_with_color (&control_color2);
clutter_container_add_actor (CLUTTER_CONTAINER (seek_box), ui->control_seek2);
// progress rectangle
ui->control_seekbar = clutter_rectangle_new_with_color (&control_color1);
clutter_container_add_actor (CLUTTER_CONTAINER (seek_box),
ui->control_seekbar);
clutter_box_layout_pack (CLUTTER_BOX_LAYOUT (info_box_layout), seek_box,
TRUE, /* expand */
FALSE, /* x-fill */
FALSE, /* y-fill */
CLUTTER_BOX_ALIGNMENT_CENTER, /* x-align */
CLUTTER_BOX_ALIGNMENT_CENTER); /* y-align */
// Out point
ui->out_point = clutter_texture_new_from_file (ui->segment_png, &error);
if (!ui->out_point && error)
g_debug ("Clutter error: %s\n", error->message);
if (error) {
g_error_free (error);
error = NULL;
}
clutter_container_add_actor (CLUTTER_CONTAINER (seek_box), ui->out_point);
// Controls bottom box
bottom_box_layout = clutter_box_layout_new ();
clutter_box_layout_set_vertical (CLUTTER_BOX_LAYOUT (bottom_box_layout),
FALSE);
bottom_box = clutter_box_new (bottom_box_layout);
// Controls volume box
volume_box_layout = clutter_box_layout_new ();
clutter_box_layout_set_vertical (CLUTTER_BOX_LAYOUT (volume_box_layout),
FALSE);
clutter_box_layout_set_spacing (CLUTTER_BOX_LAYOUT (volume_box_layout), 0);
ui->volume_box = clutter_box_new (volume_box_layout);
clutter_box_pack (CLUTTER_BOX (bottom_box), ui->volume_box,
"x-align", CLUTTER_BOX_ALIGNMENT_START, "expand", TRUE, NULL);
// Controls volume low
ui->volume_low = clutter_texture_new_from_file (ui->volume_low_png, &error);
if (!ui->volume_low && error)
g_debug ("Clutter error: %s\n", error->message);
if (error) {
g_error_free (error);
error = NULL;
}
clutter_box_pack (CLUTTER_BOX (ui->volume_box), ui->volume_low, "x-align",
CLUTTER_BOX_ALIGNMENT_START, NULL);
// Controls volume intensity
vol_int_box_layout =
clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_FIXED,
CLUTTER_BIN_ALIGNMENT_FIXED);
vol_int_box = clutter_box_new (vol_int_box_layout);
ui->vol_int_bg = clutter_rectangle_new_with_color (&control_color1);
clutter_container_add_actor (CLUTTER_CONTAINER (vol_int_box), ui->vol_int_bg);
ui->vol_int = clutter_rectangle_new_with_color (&control_color1);
clutter_container_add_actor (CLUTTER_CONTAINER (vol_int_box), ui->vol_int);
clutter_box_pack (CLUTTER_BOX (ui->volume_box), vol_int_box,
"x-fill", FALSE,
"y-fill", FALSE, "y-align", CLUTTER_BOX_ALIGNMENT_CENTER, NULL);
// Controls volume high
ui->volume_high = clutter_texture_new_from_file (ui->volume_high_png, &error);
if (!ui->volume_high && error)
g_debug ("Clutter error: %s\n", error->message);
if (error) {
g_error_free (error);
error = NULL;
}
clutter_box_pack (CLUTTER_BOX (ui->volume_box), ui->volume_high, "x-align",
CLUTTER_BOX_ALIGNMENT_END, NULL);
// Controls position text
duration_str = g_strdup_printf (" 0:00:00/%s", ui->duration_str);
ui->control_pos = clutter_text_new_full ("Sans 22px", duration_str,
&control_color1);
clutter_box_pack (CLUTTER_BOX (bottom_box), ui->control_pos,
"x-align", CLUTTER_BOX_ALIGNMENT_END, "expand", TRUE, NULL);
clutter_box_layout_pack (CLUTTER_BOX_LAYOUT (info_box_layout), bottom_box,
TRUE, /* expand */
FALSE, /* x-fill */
FALSE, /* y-fill */
CLUTTER_BOX_ALIGNMENT_CENTER, /* x-align */
CLUTTER_BOX_ALIGNMENT_END); /* y-align */
clutter_box_layout_pack (CLUTTER_BOX_LAYOUT (main_box_layout), ui->info_box,
FALSE, /* expand */
TRUE, /* x-fill */
FALSE, /* y-fill */
CLUTTER_BOX_ALIGNMENT_END, /* x-align */
CLUTTER_BOX_ALIGNMENT_CENTER); /* y-align */
clutter_actor_lower_bottom (ui->control_bg);
size_change (CLUTTER_STAGE (ui->stage), ui);
}
void
opt_show_step (OptShow *self, gint step)
{
OptSlide *from, *to;
OptShowPrivate *priv;
OptTransition *trans;
ClutterActor *stage;
priv = self->priv;
/* transition already running */
if (priv->trans_signal_id != 0)
return;
stage = clutter_stage_get_default();
from = g_list_nth_data (priv->slides, priv->current_slide_num);
to = g_list_nth_data (priv->slides, priv->current_slide_num + step);
if (from == NULL)
from = priv->slides->data;
/* Nowhere to go */
if (to == NULL)
return;
/* Add next slide to stage */
clutter_group_add (CLUTTER_GROUP(stage), CLUTTER_ACTOR(to));
trans = opt_slide_get_transition ( step < 0 ? to : from);
/*
* Make sure any textures are loaded before the transitions is started .
*/
clutter_container_foreach (CLUTTER_CONTAINER (to),
(ClutterCallback)clutter_actor_realize,
NULL);
if (trans != NULL)
{
if (step < 0)
opt_transition_set_direction (trans, OPT_TRANSITION_BACKWARD);
else
opt_transition_set_direction (trans, OPT_TRANSITION_FORWARD);
/* Set up transition and start it */
opt_transition_set_to (trans, to);
opt_transition_set_from (trans, from);
priv->trans_signal_id
= g_signal_connect (trans,
"completed",
G_CALLBACK (transition_completed_cb),
self);
/* lower it out of view */
clutter_actor_lower_bottom (CLUTTER_ACTOR(to));
clutter_timeline_start (CLUTTER_TIMELINE(trans));
}
else
{
/* No transition just hide current slide*/
clutter_group_remove (CLUTTER_GROUP(stage), CLUTTER_ACTOR(from));
clutter_actor_hide_all (CLUTTER_ACTOR(from));
}
/* Advance */
priv->current_slide_num += step;
priv->current_slide_num =
CLAMP(priv->current_slide_num, 0, priv->num_slides-1);
if (CLUTTER_ACTOR_IS_VISIBLE (CLUTTER_ACTOR (priv->menu)))
opt_menu_popdown (priv->menu);
opt_menu_set_current_slide (priv->menu, priv->current_slide_num);
}
static void
mnp_world_clock_construct (MnpWorldClock *world_clock)
{
ClutterActor *entry, *box, *stage;
MxBoxLayout *table = (MxBoxLayout *)world_clock;
gfloat width, height;
MnpWorldClockPrivate *priv = GET_PRIVATE (world_clock);
stage = priv->stage;
priv->location_tile = FALSE;
mx_box_layout_set_orientation ((MxBoxLayout *)world_clock, MX_ORIENTATION_VERTICAL);
mx_box_layout_set_spacing ((MxBoxLayout *)world_clock, 0);
clutter_actor_set_name (CLUTTER_ACTOR(world_clock), "TimePane");
construct_heading_and_top_area (world_clock);
priv->completion_timeout = 0;
/* Search Entry */
box = mx_box_layout_new ();
mx_box_layout_set_enable_animations ((MxBoxLayout *)box, TRUE);
mx_box_layout_set_orientation ((MxBoxLayout *)box, MX_ORIENTATION_HORIZONTAL);
mx_box_layout_set_spacing ((MxBoxLayout *)box, 4);
priv->entry_box = box;
mx_stylable_set_style_class (MX_STYLABLE(box), "ZoneSearchEntryBox");
entry = mx_entry_new ();
mx_stylable_set_style_class (MX_STYLABLE (entry), "ZoneSearchEntry");
priv->search_location = (MxEntry *)entry;
mx_entry_set_hint_text (MX_ENTRY (entry), _("Enter a country or city"));
mx_entry_set_secondary_icon_from_file (MX_ENTRY (entry),
THEMEDIR"/edit-clear.png");
g_signal_connect (entry, "secondary-icon-clicked",
G_CALLBACK (clear_btn_clicked_cb), world_clock);
g_signal_connect (G_OBJECT (entry),
"notify::text", G_CALLBACK (text_changed_cb), world_clock);
clutter_actor_get_size (entry, &width, &height);
clutter_actor_set_size (entry, width+10, -1);
mx_box_layout_add_actor ((MxBoxLayout *)box, entry, 0);
clutter_container_child_set (CLUTTER_CONTAINER (box),
entry,
"expand", FALSE,
"y-fill", FALSE,
"x-fill", FALSE,
"y-align", MX_ALIGN_MIDDLE,
"x-align", MX_ALIGN_START,
NULL);
priv->add_location = mx_button_new ();
mx_button_set_label ((MxButton *)priv->add_location, _("Add"));
mx_stylable_set_style_class (MX_STYLABLE(priv->add_location), "ZoneSearchEntryAddButton");
/* mx_box_layout_add_actor ((MxBoxLayout *)box, priv->add_location, 1); */
/* g_signal_connect (priv->add_location, "clicked",
G_CALLBACK (add_location_clicked_cb), world_clock); */
/*clutter_container_child_set (CLUTTER_CONTAINER (box),
priv->add_location,
"expand", FALSE,
"y-fill", FALSE,
"y-align", MX_ALIGN_MIDDLE,
NULL);*/
mx_box_layout_add_actor (MX_BOX_LAYOUT(priv->widget_box), box, -1);
clutter_container_child_set (CLUTTER_CONTAINER (priv->widget_box),
box,
"expand", FALSE,
"y-fill", FALSE,
"x-fill", FALSE,
"x-align", MX_ALIGN_START,
NULL);
/* Prep GeoClue */
priv->geo_position = geoclue_position_new ("org.freedesktop.Geoclue.Providers.Hostip",
"/org/freedesktop/Geoclue/Providers/Hostip");
priv->geo_geocode = geoclue_geocode_new ("org.freedesktop.Geoclue.Providers.Yahoo",
"/org/freedesktop/Geoclue/Providers/Yahoo");
priv->geo_reverse_geocode = geoclue_reverse_geocode_new ("org.freedesktop.Geoclue.Providers.Nominatim",
"/org/freedesktop/Geoclue/Providers/Nominatim");
geoclue_position_get_position_async (priv->geo_position,
mnp_wc_get_position_cb,
world_clock);
/* Clock Area */
priv->area = mnp_clock_area_new ();
g_signal_connect (priv->area, "time-changed", G_CALLBACK(time_changed), world_clock);
clutter_actor_set_size ((ClutterActor *)priv->area, 300, -1);
clutter_actor_set_reactive ((ClutterActor *)priv->area, TRUE);
clutter_actor_set_name ((ClutterActor *)priv->area, "WorldClockArea");
clutter_container_add_actor ((ClutterContainer *)stage, (ClutterActor *)priv->area);
clutter_actor_lower_bottom ((ClutterActor *)priv->area);
mx_droppable_enable ((MxDroppable *)priv->area);
g_object_ref ((GObject *)priv->area);
clutter_container_remove_actor ((ClutterContainer *)stage, (ClutterActor *)priv->area);
mx_box_layout_add_actor ((MxBoxLayout *) table, (ClutterActor *)priv->area, -1);
clutter_container_child_set (CLUTTER_CONTAINER (table),
(ClutterActor *)priv->area,
"expand", TRUE,
"y-fill", TRUE,
"x-fill", TRUE,
NULL);
priv->zones = mnp_load_zones ();
mnp_clock_area_refresh_time (priv->area, TRUE);
mnp_clock_area_set_zone_remove_cb (priv->area, (ZoneRemovedFunc) zone_removed_cb, (gpointer)world_clock);
mnp_clock_area_set_zone_reordered_cb (priv->area, (ClockZoneReorderedFunc) zone_reordered_cb, (gpointer)world_clock);
if (priv->zones->len) {
int i=0;
for (i=0; i<priv->zones->len; i++) {
MnpZoneLocation *loc = (MnpZoneLocation *)priv->zones->pdata[i];
loc->local = FALSE;
MnpClockTile *tile = mnp_clock_tile_new (loc, mnp_clock_area_get_time(priv->area), FALSE);
mnp_clock_area_add_tile (priv->area, tile);
}
if (priv->zones->len >= 4)
clutter_actor_hide (priv->entry_box);
}
/* div = clutter_texture_new_from_file (SINGLE_DIV_LINE, NULL);
mx_box_layout_add_actor (MX_BOX_LAYOUT(world_clock), div, -1);
*/
box = mx_box_layout_new ();
clutter_actor_set_name (box, "DateTimeLauncherBox");
priv->launcher_box = box;
mx_box_layout_set_orientation ((MxBoxLayout *)box, MX_ORIENTATION_VERTICAL);
mx_box_layout_set_spacing ((MxBoxLayout *)box, 6);
priv->launcher = mx_button_new ();
mx_button_set_label ((MxButton *) priv->launcher, _("Set Time & Date"));
mx_stylable_set_style_class (MX_STYLABLE(priv->launcher), "DateTimeLauncherButton");
mx_box_layout_add_actor ((MxBoxLayout *)box, priv->launcher, -1);
clutter_container_child_set (CLUTTER_CONTAINER (box),
(ClutterActor *)priv->launcher,
"expand", FALSE,
"y-fill", FALSE,
"x-fill", FALSE,
"x-align", MX_ALIGN_END,
NULL);
mx_box_layout_add_actor ((MxBoxLayout *)world_clock, box, -1);
}
/* The marker is drawn with cairo. It is composed of 1 static filled circle
* and 1 stroked circle animated as an echo.
*/
static ClutterActor *
create_marker ()
{
ClutterActor *marker;
ClutterActor *bg;
ClutterTimeline *timeline;
cairo_t *cr;
/* Create the marker */
marker = champlain_custom_marker_new ();
/* Static filled circle ----------------------------------------------- */
bg = clutter_cairo_texture_new (MARKER_SIZE, MARKER_SIZE);
cr = clutter_cairo_texture_create (CLUTTER_CAIRO_TEXTURE (bg));
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint(cr);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
/* Draw the circle */
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_arc (cr, MARKER_SIZE / 2.0, MARKER_SIZE / 2.0, MARKER_SIZE / 2.0, 0, 2 * M_PI);
cairo_close_path (cr);
/* Fill the circle */
cairo_set_source_rgba (cr, 0.1, 0.1, 0.9, 1.0);
cairo_fill (cr);
cairo_destroy (cr);
/* Add the circle to the marker */
clutter_container_add_actor (CLUTTER_CONTAINER (marker), bg);
clutter_actor_set_anchor_point_from_gravity (bg, CLUTTER_GRAVITY_CENTER);
clutter_actor_set_position (bg, 0, 0);
/* Echo circle -------------------------------------------------------- */
bg = clutter_cairo_texture_new (2 * MARKER_SIZE, 2 * MARKER_SIZE);
cr = clutter_cairo_texture_create (CLUTTER_CAIRO_TEXTURE (bg));
/* Draw the circle */
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_arc (cr, MARKER_SIZE, MARKER_SIZE, 0.9 * MARKER_SIZE, 0, 2 * M_PI);
cairo_close_path (cr);
/* Stroke the circle */
cairo_set_line_width (cr, 2.0);
cairo_set_source_rgba (cr, 0.1, 0.1, 0.7, 1.0);
cairo_stroke (cr);
cairo_destroy (cr);
/* Add the circle to the marker */
clutter_container_add_actor (CLUTTER_CONTAINER (marker), bg);
clutter_actor_lower_bottom (bg); /* Ensure it is under the previous circle */
clutter_actor_set_position (bg, 0, 0);
clutter_actor_set_anchor_point_from_gravity (bg, CLUTTER_GRAVITY_CENTER);
/* Animate the echo circle */
timeline = clutter_timeline_new (1000);
clutter_timeline_set_loop (timeline, TRUE);
clutter_actor_set_opacity (CLUTTER_ACTOR (bg), 255);
clutter_actor_set_scale (CLUTTER_ACTOR (bg), 0.5, 0.5);
clutter_actor_animate_with_timeline (CLUTTER_ACTOR (bg),
CLUTTER_EASE_OUT_SINE,
timeline,
"opacity", 0,
"scale-x", 2.0,
"scale-y", 2.0,
NULL);
clutter_timeline_start (timeline);
return marker;
}
static void
sync_actor_stacking (MetaCompScreen *info)
{
GList *children;
GList *tmp;
GList *old;
gboolean reordered;
/* NB: The first entries in the lists are stacked the lowest */
/* Restacking will trigger full screen redraws, so it's worth a
* little effort to make sure we actually need to restack before
* we go ahead and do it */
children = clutter_container_get_children (CLUTTER_CONTAINER (info->window_group));
reordered = FALSE;
old = children;
/* We allow for actors in the window group other than the actors we
* know about, but it's up to a plugin to try and keep them stacked correctly
* (we really need extra API to make that reliable.)
*/
/* Of the actors we know, the bottom actor should be the background actor */
while (old && old->data != info->background_actor && !META_IS_WINDOW_ACTOR (old->data))
old = old->next;
if (old == NULL || old->data != info->background_actor)
{
reordered = TRUE;
goto done_with_check;
}
/* Then the window actors should follow in sequence */
old = old->next;
for (tmp = info->windows; tmp != NULL; tmp = tmp->next)
{
while (old && !META_IS_WINDOW_ACTOR (old->data))
old = old->next;
/* old == NULL: someone reparented a window out of the window group,
* order undefined, always restack */
if (old == NULL || old->data != tmp->data)
{
reordered = TRUE;
goto done_with_check;
}
old = old->next;
}
done_with_check:
g_list_free (children);
if (!reordered)
return;
for (tmp = g_list_last (info->windows); tmp != NULL; tmp = tmp->prev)
{
MetaWindowActor *window_actor = tmp->data;
clutter_actor_lower_bottom (CLUTTER_ACTOR (window_actor));
}
clutter_actor_lower_bottom (info->background_actor);
}
