int
main (int argc, char **argv)
{
GtkWidget *window;
gtk_init (&argc, &argv);
if (!load_pixbufs ()) {
g_message ("main(): Could not load all the pixbufs!");
exit (EXIT_FAILURE);
}
frame = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, back_width, back_height);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (window, back_width, back_height);
g_signal_connect (window, "destroy",
G_CALLBACK (destroy_cb), NULL);
da = gtk_drawing_area_new ();
g_signal_connect (da, "draw",
G_CALLBACK (draw_cb), NULL);
gtk_container_add (GTK_CONTAINER (window), da);
gtk_widget_add_tick_callback (da, on_tick, NULL, NULL);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
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 void
create_window (int width,
int height,
gboolean alpha,
gboolean maximized,
gboolean redraws)
{
WindowInfo *info;
info = g_new0 (WindowInfo, 1);
info->width = width;
info->height = height;
info->alpha = alpha;
info->maximized = maximized;
info->redraws = redraws;
info->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if (alpha)
gtk_widget_set_visual (info->window, gdk_screen_get_rgba_visual (gdk_screen_get_default ()));
if (maximized)
gtk_window_maximize (GTK_WINDOW (info->window));
info->pending = TRUE;
info->start_time = -1;
gtk_widget_set_size_request (info->window, width, height);
gtk_widget_set_app_paintable (info->window, TRUE);
g_signal_connect (info->window, "map-event", G_CALLBACK (on_window_map_event), info);
g_signal_connect (info->window, "draw", G_CALLBACK (on_window_draw), info);
gtk_widget_show (info->window);
if (info->redraws)
gtk_widget_add_tick_callback (info->window, tick_callback,
info, NULL);
our_windows = g_list_prepend (our_windows, info);
}
static gboolean
on_map_event (GtkWidget *widget,
GdkEventAny *event)
{
gtk_widget_add_tick_callback (window, tick_callback, NULL, NULL);
return FALSE;
}
G_MODULE_EXPORT gboolean
inhibit_for_3_frames (GtkWidget *widget)
{
reftest_inhibit_snapshot ();
gtk_widget_add_tick_callback (widget,
tick_callback_for_3_frames,
NULL, NULL);
return FALSE;
}
int
main (int argc, char **argv)
{
GtkWidget *window;
GtkWidget *scrolled_window;
GtkWidget *viewport;
GtkWidget *grid;
GError *error = NULL;
int i;
GOptionContext *context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, options, NULL);
frame_stats_add_options (g_option_context_get_main_group (context));
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("Option parsing failed: %s\n", error->message);
return 1;
}
gtk_init ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
frame_stats_ensure (GTK_WINDOW (window));
gtk_window_set_default_size (GTK_WINDOW (window), 800, 600);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), scrolled_window);
viewport = gtk_viewport_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), viewport);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (viewport), grid);
for (i = 0; i < 4; i++)
{
GtkWidget *content = create_widget_factory_content ();
gtk_grid_attach (GTK_GRID (grid), content,
i % 2, i / 2, 1, 1);
g_object_unref (content);
}
gtk_widget_add_tick_callback (viewport,
scroll_viewport,
NULL,
NULL);
gtk_widget_show (window);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_main ();
return 0;
}
static void
gd_stack_schedule_ticks (GdStack *stack)
{
GdStackPrivate *priv = stack->priv;
if (priv->tick_id == 0)
{
priv->tick_id =
gtk_widget_add_tick_callback (GTK_WIDGET (stack), (GtkTickCallback)gd_stack_transition_cb, stack, NULL);
}
}
static void
gtk_gears_init (GtkGears *gears)
{
GtkGearsPrivate *priv = gtk_gears_get_instance_private (gears);
priv->view_rot[GTK_GEARS_X_AXIS] = 20.0;
priv->view_rot[GTK_GEARS_Y_AXIS] = 30.0;
priv->view_rot[GTK_GEARS_Z_AXIS] = 20.0;
priv->tick = gtk_widget_add_tick_callback (GTK_WIDGET (gears), gtk_gears_tick, gears, NULL);
}
/* src_offset and dst_offset need to be in [0.0, 1.0] range */
static gboolean
animate (GstyleSlidein *self,
gdouble target_offset)
{
GtkWidget *child;
g_assert (GSTYLE_IS_SLIDEIN (self));
g_assert (0.0 <= target_offset && target_offset <= 1.0);
child = gtk_bin_get_child (GTK_BIN (self));
if (child == NULL || self->overlay_child == NULL)
return FALSE;
animate_stop (self);
if (!self->duration_set)
self->duration = gstyle_animation_check_enable_animation () ? compute_duration (self) : 0;
self->src_offset = self->offset;
self->dst_offset = target_offset;
gtk_widget_set_child_visible (child, TRUE);
if (self->src_offset == self->dst_offset)
return FALSE;
if (self->src_offset < self->dst_offset)
{
self->is_opening = TRUE;
g_signal_emit (self, signals [OPENING], 0);
}
else
{
self->is_closing = TRUE;
g_signal_emit (self, signals [CLOSING], 0);
}
if (self->duration == 0)
{
self->offset = target_offset;
animation_done_cb (self);
gtk_widget_queue_resize (GTK_WIDGET (self));
}
else if (!self->animation_handler_id)
{
self->animation_starttime = g_get_monotonic_time();
self->animation_handler_id = gtk_widget_add_tick_callback (GTK_WIDGET (self),
animation_tick_cb,
self,
NULL);
}
return TRUE;
}
static void
play_clicked(EdosuView *self)
{
if (!self->playing)
{
printf("start play\n");
self->playing = TRUE;
self->first_frame_time = 0;
self->tick_id = gtk_widget_add_tick_callback(
GTK_WIDGET(self->drawing_area), animate_play, self, NULL);
}
}
static void
gtk_css_widget_node_queue_validate (GtkCssNode *node)
{
GtkCssWidgetNode *widget_node = GTK_CSS_WIDGET_NODE (node);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
if (GTK_IS_RESIZE_CONTAINER (widget_node->widget))
widget_node->validate_cb_id = gtk_widget_add_tick_callback (widget_node->widget,
gtk_css_widget_node_queue_callback,
node,
NULL);
G_GNUC_END_IGNORE_DEPRECATIONS
}
/**
* gtk_test_widget_wait_for_draw:
* @widget: the widget to wait for
*
* Enters the main loop and waits for @widget to be “drawn”. In this
* context that means it waits for the frame clock of @widget to have
* run a full styling, layout and drawing cycle.
*
* This function is intended to be used for syncing with actions that
* depend on @widget relayouting or on interaction with the display
* server.
*
* Since: 3.10
**/
void
gtk_test_widget_wait_for_draw (GtkWidget *widget)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
/* We can do this here because the whole tick procedure does not
* reenter the main loop. Otherwise we'd need to manually get the
* frame clock and connect to the after-paint signal.
*/
gtk_widget_add_tick_callback (widget,
quit_main_loop_callback,
NULL,
NULL);
gtk_main ();
}
void loop_initialize ()
{
timer = xg_timer_new();
g_timer_start (timer);
update_count = 0;
draw_count = 0;
before_update_time = xg_timer_elapsed (timer);
after_update_time = before_update_time;
before_draw_time = before_update_time;
after_draw_time = before_update_time;
main_loop = xg_default_main_loop_new ();
idle_event_source_id = g_timeout_add (1, idle_state_event_cb, NULL);
main_screen_tick_id = gtk_widget_add_tick_callback (GTK_WIDGET(main_screen), tick_cb, NULL, NULL);
initialized_flag = TRUE;
}
static void
gtk_switch_begin_toggle_animation (GtkSwitch *sw)
{
GtkSwitchPrivate *priv = sw->priv;
if (gtk_settings_get_enable_animations (gtk_widget_get_settings (GTK_WIDGET (sw))))
{
gtk_progress_tracker_start (&priv->tracker, 1000 * ANIMATION_DURATION, 0, 1.0);
if (priv->tick_id == 0)
priv->tick_id = gtk_widget_add_tick_callback (GTK_WIDGET (sw),
gtk_switch_on_frame_clock_update,
NULL, NULL);
}
else
{
gtk_switch_set_active (sw, !priv->is_active);
}
}
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 void
switch_to_page (OfficeRunner *run,
int page)
{
gtk_notebook_set_current_page (GTK_NOTEBOOK (run->notebook), page);
switch (page) {
case RUN_PAGE:
set_running_settings (run, TRUE);
gtk_label_set_text (GTK_LABEL (WID ("run_button_label")), _("Run!"));
break;
case RUNNING_PAGE: {
set_running_settings (run, TRUE);
disable_block_timeout (run);
run->timer = g_timer_new ();
run->timeout = gtk_widget_add_tick_callback (run->time_label, count_tick, run, NULL);
gtk_label_set_text (GTK_LABEL (WID ("run_button_label")), _("Done!"));
break;
}
case SCORES_PAGE: {
run->elapsed = g_timer_elapsed (run->timer, NULL);
g_timer_destroy (run->timer);
run->timer = NULL;
gtk_widget_remove_tick_callback (run->time_label, run->timeout);
run->timeout = 0;
gtk_label_set_text (GTK_LABEL (WID ("run_button_label")), _("Try Again"));
set_records_page (run);
/* This should be enough time for the machine to go to sleep */
set_running_settings (run, FALSE);
run->reenable_block_id = g_timeout_add_seconds (3, reenable_block_timeout_cb, run);
break;
}
}
}
static void
rg_graph_ensure_surface (RgGraph *self)
{
RgGraphPrivate *priv = rg_graph_get_instance_private (self);
GtkAllocation alloc;
RgTableIter iter;
gint64 begin_time;
gint64 end_time;
gdouble y_begin;
gdouble y_end;
cairo_t *cr;
gsize i;
g_assert (RG_IS_GRAPH (self));
gtk_widget_get_allocation (GTK_WIDGET (self), &alloc);
if (priv->surface == NULL)
{
priv->surface_dirty = TRUE;
priv->surface = gdk_window_create_similar_surface (gtk_widget_get_window (GTK_WIDGET (self)),
CAIRO_CONTENT_COLOR_ALPHA,
alloc.width,
alloc.height);
}
if (priv->table == NULL)
return;
if (priv->surface_dirty)
{
priv->surface_dirty = FALSE;
cr = cairo_create (priv->surface);
cairo_save (cr);
cairo_rectangle (cr, 0, 0, alloc.width, alloc.height);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_fill (cr);
cairo_restore (cr);
g_object_get (priv->table,
"value-min", &y_begin,
"value-max", &y_end,
NULL);
rg_table_get_iter_last (priv->table, &iter);
end_time = rg_table_iter_get_timestamp (&iter);
begin_time = end_time - rg_table_get_timespan (priv->table);
for (i = 0; i < priv->renderers->len; i++)
{
RgRenderer *renderer;
renderer = g_ptr_array_index (priv->renderers, i);
cairo_save (cr);
rg_renderer_render (renderer, priv->table, begin_time, end_time, y_begin, y_end, cr, &alloc);
cairo_restore (cr);
}
cairo_destroy (cr);
priv->x_offset = 0;
}
if (priv->tick_handler == 0)
priv->tick_handler = gtk_widget_add_tick_callback (GTK_WIDGET (self),
rg_graph_tick_cb,
self,
NULL);
}
GtkWidget *
do_pixbufs (GtkWidget *do_widget)
{
if (!window)
{
GError *error;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Pixbufs");
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
error = NULL;
if (!load_pixbufs (&error))
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Failed to load an image: %s",
error->message);
g_error_free (error);
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
gtk_widget_show (dialog);
}
else
{
gtk_widget_set_size_request (window, back_width, back_height);
frame = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, back_width, back_height);
da = gtk_drawing_area_new ();
g_signal_connect (da, "draw",
G_CALLBACK (draw_cb), NULL);
gtk_container_add (GTK_CONTAINER (window), da);
gtk_widget_add_tick_callback (da, on_tick, NULL, NULL);
}
}
if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
else
{
gtk_widget_destroy (window);
window = NULL;
g_object_unref (frame);
}
return window;
}
