GdkFrameClock

typedef struct {
  GObject parent_instance;
} GdkFrameClock;

gdk_frame_clock_get_frame_time ()

gint64              gdk_frame_clock_get_frame_time      (GdkFrameClock *frame_clock);

Gets the time that should currently be used for animations. Inside the processing of a frame, it's the time used to compute the animation position of everything in a frame. Outside of a frame, it's the time of the conceptual "previous frame," which may be either the actual previous frame time, or if that's too old, an updated time.

Since 3.8

enum GdkFrameClockPhase

typedef enum {
  GDK_FRAME_CLOCK_PHASE_NONE          = 0,
  GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS  = 1 << 0,
  GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT  = 1 << 1,
  GDK_FRAME_CLOCK_PHASE_UPDATE        = 1 << 2,
  GDK_FRAME_CLOCK_PHASE_LAYOUT        = 1 << 3,
  GDK_FRAME_CLOCK_PHASE_PAINT         = 1 << 4,
  GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS = 1 << 5,
  GDK_FRAME_CLOCK_PHASE_AFTER_PAINT   = 1 << 6
} GdkFrameClockPhase;

GdkFrameClockPhase is used to represent the different paint clock phases that can be requested. The elements of the enumeration correspond to the signals of GdkPaintClock.

Since 3.8

gdk_frame_clock_request_phase ()

void                gdk_frame_clock_request_phase       (GdkFrameClock *frame_clock,
                                                         GdkFrameClockPhase phase);

Asks the frame clock to run a particular phase. The signal corresponding the requested phase will be emitted the next time the frame clock processes. Multiple calls to gdk_frame_clock_request_phase() will be combined together and only one frame processed. If you are displaying animated content and want to continually request the GDK_FRAME_CLOCK_PHASE_UPDATE phase for a period of time, you should use gdk_frame_clock_begin_updating() instead, since this allows GTK+ to adjust system parameters to get maximally smooth animations.

Since 3.8

gdk_frame_clock_begin_updating ()

void                gdk_frame_clock_begin_updating      (GdkFrameClock *frame_clock);

Starts updates for an animation. Until a matching call to gdk_frame_clock_end_updating() is made, the frame clock will continually request a new frame with the GDK_FRAME_CLOCK_PHASE_UPDATE phase. This function may be called multiple times and frames will be requested until gdk_frame_clock_end_updating() is called the same number of times.

Since 3.8

gdk_frame_clock_end_updating ()

void                gdk_frame_clock_end_updating        (GdkFrameClock *frame_clock);

Stops updates for an animation. See the documentation for gdk_frame_clock_begin_updating().

Since 3.8

gdk_frame_clock_get_frame_counter ()

gint64              gdk_frame_clock_get_frame_counter   (GdkFrameClock *frame_clock);

A GdkFrameClock maintains a 64-bit counter that increments for each frame drawn.

Since 3.8

gdk_frame_clock_get_history_start ()

gint64              gdk_frame_clock_get_history_start   (GdkFrameClock *frame_clock);

GdkFrameClock internally keeps a history of GdkFrameTiming objects for recent frames that can be retrieved with gdk_frame_clock_get_timings(). The set of stored frames is the set from the counter values given by gdk_frame_clock_get_history_start() and gdk_frame_clock_get_frame_counter(), inclusive.

Since 3.8

gdk_frame_clock_get_timings ()

GdkFrameTimings *   gdk_frame_clock_get_timings         (GdkFrameClock *frame_clock,
                                                         gint64 frame_counter);

Retrieves a GdkFrameTimings object holding timing information for the current frame or a recent frame. The GdkFrameTimings object may not yet be complete: see gdk_frame_timings_get_complete().

Since 3.8

gdk_frame_clock_get_current_timings ()

GdkFrameTimings *   gdk_frame_clock_get_current_timings (GdkFrameClock *frame_clock);

Gets the frame timings for the current frame.

Since 3.8

gdk_frame_clock_get_refresh_info ()

void                gdk_frame_clock_get_refresh_info    (GdkFrameClock *frame_clock,
                                                         gint64 base_time,
                                                         gint64 *refresh_interval_return,
                                                         gint64 *presentation_time_return);

Using the frame history stored in the frame clock, finds the last known presentation time and refresh interval, and assuming that presentation times are separated by the refresh interval, predicts a presentation time that is a multiple of the refresh interval after the last presentation time, and later than base_time.

Since 3.8