1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
// Take a look at the license at the top of the repository in the LICENSE file.
use crate::FrameTimings;
use glib::translate::*;
use std::num::NonZeroU64;
impl FrameTimings {
/// Gets the predicted time at which this frame will be displayed. Although
/// no predicted time may be available, if one is available, it will
/// be available while the frame is being generated, in contrast to
/// [`presentation_time()`][Self::presentation_time()], which is only available
/// after the frame has been presented. In general, if you are simply
/// animating, you should use [`FrameClock::frame_time()`][crate::FrameClock::frame_time()] rather
/// than this function, but this function is useful for applications
/// that want exact control over latency. For example, a movie player
/// may want this information for Audio/Video synchronization.
///
/// # Returns
///
/// The predicted time at which the frame will be presented,
/// in the timescale of `g_get_monotonic_time()`, or 0 if no predicted
/// presentation time is available.
#[doc(alias = "gdk_frame_timings_get_predicted_presentation_time")]
#[doc(alias = "get_predicted_presentation_time")]
pub fn predicted_presentation_time(&self) -> Option<NonZeroU64> {
let predicted_presentation_time = unsafe {
ffi::gdk_frame_timings_get_predicted_presentation_time(self.to_glib_none().0)
};
// assuming presentation time is always positive
assert!(predicted_presentation_time >= 0);
// `0` means the value is not available
NonZeroU64::new(predicted_presentation_time as u64)
}
/// Reurns the presentation time. This is the time at which the frame
/// became visible to the user.
///
/// # Returns
///
/// the time the frame was displayed to the user, in the
/// timescale of `g_get_monotonic_time()`, or 0 if no presentation
/// time is available. See [`is_complete()`][Self::is_complete()]
#[doc(alias = "gdk_frame_timings_get_presentation_time")]
#[doc(alias = "get_presentation_time")]
pub fn presentation_time(&self) -> Option<NonZeroU64> {
let presentation_time =
unsafe { ffi::gdk_frame_timings_get_presentation_time(self.to_glib_none().0) };
// assuming presentation time is always positive
assert!(presentation_time >= 0);
// `0` means the value is not available
NonZeroU64::new(presentation_time as u64)
}
/// Gets the natural interval between presentation times for
/// the display that this frame was displayed on. Frame presentation
/// usually happens during the “vertical blanking interval”.
///
/// # Returns
///
/// the refresh interval of the display, in microseconds,
/// or 0 if the refresh interval is not available.
/// See [`is_complete()`][Self::is_complete()].
#[doc(alias = "gdk_frame_timings_get_refresh_interval")]
#[doc(alias = "get_refresh_interval")]
pub fn refresh_interval(&self) -> Option<NonZeroU64> {
let refresh_interval =
unsafe { ffi::gdk_frame_timings_get_refresh_interval(self.to_glib_none().0) };
// assuming refresh interval is always positive
assert!(refresh_interval >= 0);
// `0` means the value is not available
NonZeroU64::new(refresh_interval as u64)
}
}