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
// Copyright 2018, The Gtk-rs Project Developers. // See the COPYRIGHT file at the top-level directory of this distribution. // Licensed under the MIT license, see the LICENSE file or <http://opensource.org/licenses/MIT> use gdk_sys; use glib::translate::*; use std::num::NonZeroU64; use FrameTimings; 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 /// `FrameTimings::get_presentation_time`, which is only available /// after the frame has been presented. In general, if you are simply /// animating, you should use `FrameClock::get_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. pub fn get_predicted_presentation_time(&self) -> Option<NonZeroU64> { let predicted_presentation_time = unsafe { gdk_sys::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 `FrameTimings::get_complete` pub fn get_presentation_time(&self) -> Option<NonZeroU64> { let presentation_time = unsafe { gdk_sys::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 `FrameTimings::get_complete`. pub fn get_refresh_interval(&self) -> Option<NonZeroU64> { let refresh_interval = unsafe { gdk_sys::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) } }