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