Struct gdk4::FrameClock [−][src]
pub struct FrameClock(_);Expand description
A FrameClock tells the application when to update and repaint
a surface.
This may be synced to the vertical refresh rate of the monitor, for example. Even when the frame clock uses a simple timer rather than a hardware-based vertical sync, the frame clock helps because it ensures everything paints at the same time (reducing the total number of frames).
The frame clock can also automatically stop painting when it knows the frames will not be visible, or scale back animation framerates.
FrameClock is designed to be compatible with an OpenGL-based implementation
or with mozRequestAnimationFrame in Firefox, for example.
A frame clock is idle until someone requests a frame with
request_phase(). At some later point that makes sense
for the synchronization being implemented, the clock will process a frame and
emit signals for each phase that has been requested. (See the signals of the
FrameClock class for documentation of the phases.
FrameClockPhase::UPDATE and the signal::GdkFrameClock::update signal
are most interesting for application writers, and are used to update the
animations, using the frame time given by frame_time().
The frame time is reported in microseconds and generally in the same
timescale as g_get_monotonic_time(), however, it is not the same
as g_get_monotonic_time(). The frame time does not advance during
the time a frame is being painted, and outside of a frame, an attempt
is made so that all calls to frame_time() that
are called at a “similar” time get the same value. This means that
if different animations are timed by looking at the difference in
time between an initial value from frame_time()
and the value inside the signal::GdkFrameClock::update signal of the clock,
they will stay exactly synchronized.
This is an Abstract Base Class, you cannot instantiate it.
Implementations
Starts updates for an animation.
Until a matching call to end_updating() is made,
the frame clock will continually request a new frame with the
FrameClockPhase::UPDATE phase. This function may be called multiple
times and frames will be requested until end_updating()
is called the same number of times.
Stops updates for an animation.
See the documentation for begin_updating().
Gets the frame timings for the current frame.
Returns
the FrameTimings for the
frame currently being processed, or even no frame is being
processed, for the previous frame. Before any frames have been
processed, returns None.
Calculates the current frames-per-second, based on the
frame timings of self.
Returns
the current fps, as a double
FrameClock maintains a 64-bit counter that increments for
each frame drawn.
Returns
inside frame processing, the value of the frame counter for the current frame. Outside of frame processing, the frame counter for the last frame.
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.
Returns
a timestamp in microseconds, in the timescale of
of g_get_monotonic_time().
Returns the frame counter for the oldest frame available in history.
FrameClock internally keeps a history of FrameTimings
objects for recent frames that can be retrieved with
timings(). The set of stored frames
is the set from the counter values given by
history_start() and
frame_counter(), inclusive.
Returns
the frame counter value for the oldest frame
that is available in the internal frame history of the
FrameClock
Predicts a presentation time, based on history.
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.
base_time
base time for determining a presentaton time
Returns
refresh_interval_return
a location to store the
determined refresh interval, or None. A default refresh interval of
1/60th of a second will be stored if no history is present.
presentation_time_return
a location to store the next candidate presentation time after the given base time. 0 will be will be stored if no history is present.
Retrieves a FrameTimings object holding timing information
for the current frame or a recent frame.
The FrameTimings object may not yet be complete: see
FrameTimings::is_complete() and
history_start().
frame_counter
the frame counter value identifying the frame to be received
Returns
the FrameTimings object
for the specified frame, or None if it is not available
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
request_phase() will be combined together
and only one frame processed. If you are displaying animated
content and want to continually request the
FrameClockPhase::UPDATE phase for a period of time,
you should use begin_updating() instead,
since this allows GTK to adjust system parameters to get maximally
smooth animations.
phase
the phase that is requested
This signal ends processing of the frame.
Applications should generally not handle this signal.
Begins processing of the frame.
Applications should generally not handle this signal.
Used to flush pending motion events that are being batched up and compressed together.
Applications should not handle this signal.
Emitted as the second step of toolkit and application processing of the frame.
Any work to update sizes and positions of application elements should be performed. GTK normally handles this internally.
Emitted as the third step of toolkit and application processing of the frame.
The frame is repainted. GDK normally handles this internally and
emits signal::Surface::render signals which are turned into
signal::Gtk::Widget::snapshot signals by GTK.
Emitted after processing of the frame is finished.
This signal is handled internally by GTK to resume normal event processing. Applications should not handle this signal.
Emitted as the first step of toolkit and application processing of the frame.
Animations should be updated using frame_time().
Applications can connect directly to this signal, or use
Gtk::Widget::add_tick_callback()`` as a more convenient interface.
Trait Implementations
This method returns an ordering between self and other values if one exists. Read more
This method tests less than (for self and other) and is used by the < operator. Read more
This method tests less than or equal to (for self and other) and is used by the <=
operator. Read more
This method tests greater than (for self and other) and is used by the > operator. Read more
Returns the type identifier of Self.
Auto Trait Implementations
impl RefUnwindSafe for FrameClock
impl !Send for FrameClock
impl !Sync for FrameClock
impl Unpin for FrameClock
impl UnwindSafe for FrameClock
Blanket Implementations
Mutably borrows from an owned value. Read more
Upcasts an object to a superclass or interface T. Read more
Upcasts an object to a reference of its superclass or interface T. Read more
Tries to downcast to a subclass or interface implementor T. Read more
Tries to downcast to a reference of its subclass or interface implementor T. Read more
Tries to cast to an object of type T. This handles upcasting, downcasting
and casting between interface and interface implementors. All checks are performed at
runtime, while downcast and upcast will do many checks at compile-time already. Read more
Tries to cast to reference to an object of type T. This handles upcasting, downcasting
and casting between interface and interface implementors. All checks are performed at
runtime, while downcast and upcast will do many checks at compile-time already. Read more
Casts to T unconditionally. Read more
Casts to &T unconditionally. Read more
Returns true if the object is an instance of (can be cast to) T.
pub fn set_property<'a, N, V>(
&self,
property_name: N,
value: V
) -> Result<(), BoolError> where
N: Into<&'a str>,
V: ToValue,
pub fn set_property_from_value<'a, N>(
&self,
property_name: N,
value: &Value
) -> Result<(), BoolError> where
N: Into<&'a str>,
pub fn set_properties_from_value(
&self,
property_values: &[(&str, Value)]
) -> Result<(), BoolError>
pub fn has_property<'a, N>(&self, property_name: N, type_: Option<Type>) -> bool where
N: Into<&'a str>,
pub fn find_property<'a, N>(&self, property_name: N) -> Option<ParamSpec> where
N: Into<&'a str>,
Safety Read more
Safety Read more
Safety Read more
Safety Read more
pub fn connect<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: 'static + Fn(&[Value]) -> Option<Value> + Send + Sync,
Same as connect but takes a SignalId instead of a signal name.
pub fn connect_local<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: 'static + Fn(&[Value]) -> Option<Value>,
Same as connect_local but takes a SignalId instead of a signal name.
pub unsafe fn connect_unsafe<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: Fn(&[Value]) -> Option<Value>,
Same as connect_unsafe but takes a SignalId instead of a signal name.
Emit signal by signal id.
Same as emit but takes Value for the arguments.
Emit signal by its name.
Same as emit_by_name but takes Value for the arguments.
Emit signal with details by signal id.
Same as emit_with_details but takes Value for the arguments.
pub fn connect_notify<F>(&self, name: Option<&str>, f: F) -> SignalHandlerId where
F: 'static + Fn(&T, &ParamSpec) + Send + Sync,
pub fn connect_notify_local<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: 'static + Fn(&T, &ParamSpec),
pub unsafe fn connect_notify_unsafe<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: Fn(&T, &ParamSpec),
pub fn bind_property<'a, O, N, M>(
&'a self,
source_property: N,
target: &'a O,
target_property: M
) -> BindingBuilder<'a> where
O: ObjectType,
N: Into<&'a str>,
M: Into<&'a str>,
Returns a SendValue clone of self.