static void
gd_stack_start_transition (GdStack *stack)
{
GdStackPrivate *priv = stack->priv;
GtkWidget *widget = GTK_WIDGET (stack);
gboolean animations_enabled;
g_object_get (gtk_widget_get_settings (widget),
"gtk-enable-animations", &animations_enabled,
NULL);
if (gtk_widget_get_mapped (widget) &&
animations_enabled &&
priv->transition_type != GD_STACK_TRANSITION_TYPE_NONE &&
priv->last_visible_child != NULL)
{
gtk_widget_set_opacity (widget, 0.999);
priv->transition_pos = 0.0;
priv->start_time = gdk_frame_clock_get_frame_time (gtk_widget_get_frame_clock (widget));
priv->end_time = priv->start_time + (priv->transition_duration * 1000);
gd_stack_schedule_ticks (stack);
}
else
{
gd_stack_unschedule_ticks (stack);
gd_stack_set_transition_position (stack, 1.0);
}
}
static gboolean
tick_callback (GtkWidget *widget,
GdkFrameClock *frame_clock,
gpointer user_data)
{
WindowInfo *info = user_data;
if (info->start_time < 0)
info->start_time = info->time = gdk_frame_clock_get_frame_time (frame_clock);
else
info->time = gdk_frame_clock_get_frame_time (frame_clock);
gtk_widget_queue_draw (widget);
return TRUE;
}
static gboolean
gd_stack_transition_cb (GdStack *stack,
GdkFrameClock *frame_clock,
gpointer user_data)
{
GdStackPrivate *priv = stack->priv;
gint64 now;
gdouble t;
now = gdk_frame_clock_get_frame_time (frame_clock);
t = 1.0;
if (now < priv->end_time)
t = (now - priv->start_time) / (double) (priv->end_time - priv->start_time);
/* Finish animation early if not mapped anymore */
if (!gtk_widget_get_mapped (GTK_WIDGET (stack)))
t = 1.0;
if (gd_stack_set_transition_position (stack, t))
{
gtk_widget_set_opacity (GTK_WIDGET (stack), 1.0);
priv->tick_id = 0;
return FALSE;
}
return TRUE;
}
static gboolean
fade_and_request_redraw (GtkWidget *canvas,
GdkFrameClock *frame_clock,
gpointer user_data)
{
NautilusSelectionCanvasItem *self = user_data;
gint64 frame_time;
gdouble percentage;
frame_time = gdk_frame_clock_get_frame_time (frame_clock);
if (frame_time >= self->priv->fade_out_end_time)
{
self->priv->fade_out_tick_id = 0;
eel_canvas_item_destroy (EEL_CANVAS_ITEM (self));
return G_SOURCE_REMOVE;
}
percentage = 1.0 - (gdouble) (frame_time - self->priv->fade_out_start_time) /
(gdouble) (self->priv->fade_out_end_time - self->priv->fade_out_start_time);
self->priv->fade_out_fill_alpha = self->priv->fill_color.alpha * percentage;
self->priv->fade_out_outline_alpha = self->priv->outline_color.alpha * percentage;
eel_canvas_item_request_redraw (EEL_CANVAS_ITEM (self));
return G_SOURCE_CONTINUE;
}
static void
gtk_revealer_start_animation (GtkRevealer *revealer,
gdouble target)
{
GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer);
GtkWidget *widget = GTK_WIDGET (revealer);
GtkRevealerTransitionType transition;
if (priv->target_pos == target)
return;
priv->target_pos = target;
g_object_notify (G_OBJECT (revealer), "reveal-child");
transition = effective_transition (revealer);
if (gtk_widget_get_mapped (widget) &&
priv->transition_duration != 0 &&
transition != GTK_REVEALER_TRANSITION_TYPE_NONE)
{
priv->source_pos = priv->current_pos;
priv->start_time = gdk_frame_clock_get_frame_time (gtk_widget_get_frame_clock (widget));
priv->end_time = priv->start_time + (priv->transition_duration * 1000);
if (priv->tick_id == 0)
priv->tick_id =
gtk_widget_add_tick_callback (widget, (GtkTickCallback)gtk_revealer_animate_cb, revealer, NULL);
gtk_revealer_animate_step (revealer, priv->start_time);
}
else
{
gtk_revealer_set_position (revealer, target);
}
}
static gboolean
animation_tick_cb (GtkWidget *widget,
GdkFrameClock *frame_clock,
gpointer user_data)
{
GstyleSlidein *self = (GstyleSlidein *)widget;
gint64 time;
gdouble time_offset;
gdouble ease_offset;
g_assert (GSTYLE_IS_SLIDEIN (self));
g_assert (frame_clock != NULL);
if (!self->is_closing && !self->is_opening)
return G_SOURCE_REMOVE;
time = gdk_frame_clock_get_frame_time (frame_clock);
time_offset = MIN ((time - self->animation_starttime) / ( 1000.0 * self->duration), 1.0);
ease_offset = gstyle_animation_ease_in_out_cubic (time_offset);
self->offset = ease_offset * (self->dst_offset - self->src_offset) + self->src_offset;
gtk_widget_queue_resize (GTK_WIDGET (self));
if (time_offset == 1.0)
{
animation_done_cb (self);
return G_SOURCE_REMOVE;
}
else
return G_SOURCE_CONTINUE;
}
static gboolean on_tick_callback(DeepinFixed* self, GdkFrameClock* clock,
gpointer data)
{
DeepinFixedPrivate* priv = self->priv;
ChildAnimationInfo* ai = (ChildAnimationInfo*)data;
gint64 now = gdk_frame_clock_get_frame_time(clock);
gdouble duration = (now - ai->last_time) / 1000000.0;
if (ai->last_time != ai->start_time && duration < 0.033) return G_SOURCE_CONTINUE;
ai->last_time = now;
gdouble t = 1.0;
if (now < ai->end_time) {
t = (now - ai->start_time) / (gdouble)(ai->end_time - ai->start_time);
}
t = ease_out_cubic(t);
ai->current_pos = t * ai->target_pos;
if (ai->current_pos > ai->target_pos) ai->current_pos = ai->target_pos;
deepin_fixed_move_internal(self, ai->child,
ai->target_x * ai->current_pos + ai->old_x * (1 - ai->current_pos),
ai->target_y * ai->current_pos + ai->old_y * (1 - ai->current_pos));
if (ai->current_pos >= ai->target_pos) {
deepin_fixed_end_animation(self, ai);
return G_SOURCE_REMOVE;
}
return G_SOURCE_CONTINUE;
}
static gboolean
gtk_switch_on_frame_clock_update (GtkWidget *widget,
GdkFrameClock *clock,
gpointer user_data)
{
GtkSwitch *sw = GTK_SWITCH (widget);
GtkSwitchPrivate *priv = sw->priv;
gtk_progress_tracker_advance_frame (&priv->tracker,
gdk_frame_clock_get_frame_time (clock));
if (gtk_progress_tracker_get_state (&priv->tracker) != GTK_PROGRESS_STATE_AFTER)
{
if (priv->is_active)
priv->handle_pos = 1.0 - gtk_progress_tracker_get_ease_out_cubic (&priv->tracker, FALSE);
else
priv->handle_pos = gtk_progress_tracker_get_ease_out_cubic (&priv->tracker, FALSE);
}
else
{
gtk_switch_set_active (sw, !priv->is_active);
}
gtk_widget_queue_allocate (GTK_WIDGET (sw));
return G_SOURCE_CONTINUE;
}
static void
gtk_switch_begin_toggle_animation (GtkSwitch *sw)
{
GtkSwitchPrivate *priv = sw->priv;
gboolean animate;
g_object_get (gtk_widget_get_settings (GTK_WIDGET (sw)),
"gtk-enable-animations", &animate,
NULL);
if (animate)
{
GdkFrameClock *clock = gtk_widget_get_frame_clock (GTK_WIDGET (sw));
priv->start_time = gdk_frame_clock_get_frame_time (clock);
priv->end_time = priv->start_time + 1000 * ANIMATION_DURATION;
priv->offset = priv->handle_x;
if (priv->tick_id == 0)
{
priv->tick_id = g_signal_connect (clock, "update",
G_CALLBACK (gtk_switch_on_frame_clock_update), sw);
gdk_frame_clock_begin_updating (clock);
}
}
else
{
gtk_switch_set_active (sw, !priv->is_active);
}
}
static void
gtk_switch_on_frame_clock_update (GdkFrameClock *clock,
GtkSwitch *sw)
{
GtkSwitchPrivate *priv = sw->priv;
gint64 now;
now = gdk_frame_clock_get_frame_time (clock);
if (now < priv->end_time)
{
gdouble t;
gint dest_offset;
if (priv->is_active)
dest_offset = 0;
else
dest_offset = gtk_widget_get_allocated_width (GTK_WIDGET (sw)) / 2;
t = (now - priv->start_time) / (gdouble) (priv->end_time - priv->start_time);
t = ease_out_cubic (t);
priv->handle_x = priv->offset + t * (dest_offset - priv->offset);
}
else
{
gtk_switch_set_active (sw, !priv->is_active);
}
gtk_widget_queue_draw (GTK_WIDGET (sw));
}
static int
tick_cb (GtkWidget *widget, GdkFrameClock *frame_clock, void *user_data)
{
double cur_time;
if (quitting_flag)
return FALSE;
// cur_time = xg_timer_elapsed (timer);
cur_time = (double) gdk_frame_clock_get_frame_time (frame_clock) * 1.0e-6;
if (initialized_flag && !minimized_flag)
{
if (active_flag)
{
if (run_full_speed_flag || ((cur_time - before_draw_time) > REFRESH_RATE))
{
paint ();
if (do_after_draw_frame != SCM_UNSPECIFIED)
scm_call_1 (do_after_draw_frame, scm_from_double (after_draw_time));
draw_count ++;
before_draw_time = cur_time;
after_draw_time = (double) gdk_frame_clock_get_frame_time (frame_clock) * 1.0e-6;
if (draw_count % 1000 == 0)
{
measured_frame_rate
= 1000.0 / (after_draw_time - thousand_frames_draw_time);
thousand_frames_draw_time = after_draw_time;
g_debug ("Frame Rate: %f", measured_frame_rate);
}
}
if (!run_full_speed_flag)
xg_usleep (1000);
}
else
{
//audio_pause ();
// Figure out a way to sleep until the next gtk event comes in
}
}
return TRUE;
}
static gboolean
gtk_gears_tick (GtkWidget *widget,
GdkFrameClock *frame_clock,
gpointer user_data)
{
GtkGears *gears = GTK_GEARS (widget);
GtkGearsPrivate *priv = gtk_gears_get_instance_private (gears);
GdkFrameTimings *timings, *previous_timings;
gint64 previous_frame_time = 0;
gint64 frame_time;
gint64 history_start, history_len;
gint64 frame;
char *s;
frame = gdk_frame_clock_get_frame_counter (frame_clock);
frame_time = gdk_frame_clock_get_frame_time (frame_clock);
if (priv->first_frame_time == 0)
{
/* No need for changes on first frame */
priv->first_frame_time = frame_time;
if (priv->fps_label)
gtk_label_set_label (priv->fps_label, "FPS: ---");
return G_SOURCE_CONTINUE;
}
/* glxgears advances 70 degrees per second, so do the same */
priv->angle = fmod ((frame_time - priv->first_frame_time) / (double)G_USEC_PER_SEC * 70.0, 360.0);
gtk_widget_queue_draw (widget);
history_start = gdk_frame_clock_get_history_start (frame_clock);
if (priv->fps_label && frame % 60 == 0)
{
history_len = frame - history_start;
if (history_len > 0)
{
previous_timings = gdk_frame_clock_get_timings (frame_clock, frame - history_len);
previous_frame_time = gdk_frame_timings_get_frame_time (previous_timings);
s = g_strdup_printf ("FPS: %-4.1f", (G_USEC_PER_SEC * history_len) / (double)(frame_time - previous_frame_time));
gtk_label_set_label (priv->fps_label, s);
g_free (s);
}
}
timings = gdk_frame_clock_get_current_timings (frame_clock);
previous_timings = gdk_frame_clock_get_timings (frame_clock,
gdk_frame_timings_get_frame_counter (timings) - 1);
if (previous_timings != NULL)
previous_frame_time = gdk_frame_timings_get_frame_time (previous_timings);
return G_SOURCE_CONTINUE;
}
static gint64
gtk_css_node_get_timestamp (GtkCssNode *cssnode)
{
GdkFrameClock *frameclock;
frameclock = gtk_css_node_get_frame_clock_or_null (cssnode);
if (frameclock == NULL)
return 0;
return gdk_frame_clock_get_frame_time (frameclock);
}
static gboolean
tick_callback (GtkWidget *widget,
GdkFrameClock *frame_clock,
gpointer user_data)
{
gint64 frame_time = gdk_frame_clock_get_frame_time (frame_clock);
double scaled_time;
if (start_frame_time == 0)
start_frame_time = frame_time;
scaled_time = (frame_time - start_frame_time) / (CYCLE_TIME * 1000000);
on_frame (scaled_time - floor (scaled_time));
return G_SOURCE_CONTINUE;
}
static gboolean
rg_graph_tick_cb (GtkWidget *widget,
GdkFrameClock *frame_clock,
gpointer user_data)
{
RgGraph *self = (RgGraph *)widget;
RgGraphPrivate *priv = rg_graph_get_instance_private (self);
GtkAllocation alloc;
gint64 frame_time;
gint64 end_time;
gint64 timespan;
gint x_offset;
g_assert (RG_IS_GRAPH (self));
if ((priv->surface == NULL) || (priv->table == NULL) || !gtk_widget_get_visible (widget))
goto remove_handler;
timespan = rg_table_get_timespan (priv->table);
if (timespan == 0)
goto remove_handler;
gtk_widget_get_allocation (widget, &alloc);
frame_time = gdk_frame_clock_get_frame_time (frame_clock);
end_time = rg_table_get_end_time (priv->table);
x_offset = -((frame_time - end_time) / (gdouble)timespan * alloc.width);
if (x_offset != priv->x_offset)
{
priv->x_offset = x_offset;
gtk_widget_queue_draw (widget);
}
return G_SOURCE_CONTINUE;
remove_handler:
if (priv->tick_handler != 0)
{
gtk_widget_remove_tick_callback (widget, priv->tick_handler);
priv->tick_handler = 0;
}
return G_SOURCE_REMOVE;
}
static gboolean
gtk_revealer_animate_cb (GtkRevealer *revealer,
GdkFrameClock *frame_clock,
gpointer user_data)
{
GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer);
gint64 now;
now = gdk_frame_clock_get_frame_time (frame_clock);
gtk_revealer_animate_step (revealer, now);
if (priv->current_pos == priv->target_pos)
{
priv->tick_id = 0;
return FALSE;
}
return TRUE;
}
static void deepin_fixed_prepare_animation(DeepinFixed* self, ChildAnimationInfo* ai)
{
if (!gtk_widget_get_realized(GTK_WIDGET(self))) {
gtk_widget_realize(GTK_WIDGET(self));
}
DeepinFixedPrivate* priv = self->priv;
ai->target_pos = 1.0;
ai->current_pos = 0.0;
ai->start_time = gdk_frame_clock_get_frame_time(
gtk_widget_get_frame_clock(GTK_WIDGET(self)));
ai->last_time = ai->start_time;
ai->end_time = ai->start_time + (priv->animation_duration * 1000);
ai->tick_id = gtk_widget_add_tick_callback(GTK_WIDGET(self),
(GtkTickCallback)on_tick_callback, ai, g_free);
}
void
nautilus_selection_canvas_item_fade_out (NautilusSelectionCanvasItem *self,
guint transition_time)
{
EelCanvasItem *item = EEL_CANVAS_ITEM (self);
GtkWidget *widget;
GdkFrameClock *clock;
self->priv->fade_out_fill_alpha = self->priv->fill_color.alpha;
self->priv->fade_out_outline_alpha = self->priv->outline_color.alpha;
widget = GTK_WIDGET (item->canvas);
clock = gtk_widget_get_frame_clock (widget);
self->priv->fade_out_start_time = gdk_frame_clock_get_frame_time (clock);
self->priv->fade_out_end_time = self->priv->fade_out_start_time + 1000 * transition_time;
self->priv->fade_out_tick_id =
gtk_widget_add_tick_callback (GTK_WIDGET (item->canvas), fade_and_request_redraw, self, NULL);
}
static gboolean animate_play(GtkWidget *widget,
GdkFrameClock *frame_clock,
gpointer data)
{
(void) widget;
EdosuView *self = data;
gint64 frame_time = gdk_frame_clock_get_frame_time(frame_clock);
if (self->first_frame_time == 0)
{
self->start_position = self->position;
self->first_frame_time = frame_time;
return G_SOURCE_CONTINUE;
}
// frame time is in micro seconds
gint64 d = (frame_time - self->first_frame_time) / 1000;
gtk_adjustment_set_value(self->time_adjust, d + self->start_position);
return G_SOURCE_CONTINUE;
}
gboolean
scroll_viewport (GtkWidget *viewport,
GdkFrameClock *frame_clock,
gpointer user_data)
{
static gint64 start_time;
gint64 now = gdk_frame_clock_get_frame_time (frame_clock);
gdouble elapsed;
GtkAdjustment *hadjustment, *vadjustment;
if (start_time == 0)
start_time = now;
elapsed = (now - start_time) / 1000000.;
hadjustment = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (viewport));
vadjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (viewport));
set_adjustment_to_fraction (hadjustment, 0.5 + 0.5 * sin (elapsed));
set_adjustment_to_fraction (vadjustment, 0.5 + 0.5 * cos (elapsed));
return TRUE;
}
/* Handler to regenerate the frame */
static gboolean
on_tick (GtkWidget *widget,
GdkFrameClock *frame_clock,
gpointer data)
{
gint64 current_time;
double f;
int i;
double xmid, ymid;
double radius;
gdk_pixbuf_copy_area (background, 0, 0, back_width, back_height,
frame, 0, 0);
if (start_time == 0)
start_time = gdk_frame_clock_get_frame_time (frame_clock);
current_time = gdk_frame_clock_get_frame_time (frame_clock);
f = ((current_time - start_time) % CYCLE_TIME) / (double)CYCLE_TIME;
xmid = back_width / 2.0;
ymid = back_height / 2.0;
radius = MIN (xmid, ymid) / 2.0;
for (i = 0; i < N_IMAGES; i++)
{
double ang;
int xpos, ypos;
int iw, ih;
double r;
GdkRectangle r1, r2, dest;
double k;
ang = 2.0 * G_PI * (double) i / N_IMAGES - f * 2.0 * G_PI;
iw = gdk_pixbuf_get_width (images[i]);
ih = gdk_pixbuf_get_height (images[i]);
r = radius + (radius / 3.0) * sin (f * 2.0 * G_PI);
xpos = floor (xmid + r * cos (ang) - iw / 2.0 + 0.5);
ypos = floor (ymid + r * sin (ang) - ih / 2.0 + 0.5);
k = (i & 1) ? sin (f * 2.0 * G_PI) : cos (f * 2.0 * G_PI);
k = 2.0 * k * k;
k = MAX (0.25, k);
r1.x = xpos;
r1.y = ypos;
r1.width = iw * k;
r1.height = ih * k;
r2.x = 0;
r2.y = 0;
r2.width = back_width;
r2.height = back_height;
if (gdk_rectangle_intersect (&r1, &r2, &dest))
gdk_pixbuf_composite (images[i],
frame,
dest.x, dest.y,
dest.width, dest.height,
xpos, ypos,
k, k,
GDK_INTERP_NEAREST,
((i & 1)
? MAX (127, fabs (255 * sin (f * 2.0 * G_PI)))
: MAX (127, fabs (255 * cos (f * 2.0 * G_PI)))));
}
gtk_widget_queue_draw (da);
return G_SOURCE_CONTINUE;
}
