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 74 75 76 77
// Take a look at the license at the top of the repository in the LICENSE file.
use std::{ptr, time::SystemTime};
use glib::{object::IsA, translate::*};
use crate::{PixbufAnimation, PixbufAnimationIter};
pub trait PixbufAnimationExtManual {
/// Get an iterator for displaying an animation.
///
/// The iterator provides the frames that should be displayed at a
/// given time.
///
/// @start_time would normally come from g_get_current_time(), and marks
/// the beginning of animation playback. After creating an iterator, you
/// should immediately display the pixbuf returned by
/// gdk_pixbuf_animation_iter_get_pixbuf(). Then, you should install
/// a timeout (with g_timeout_add()) or by some other mechanism ensure
/// that you'll update the image after
/// gdk_pixbuf_animation_iter_get_delay_time() milliseconds. Each time
/// the image is updated, you should reinstall the timeout with the new,
/// possibly-changed delay time.
///
/// As a shortcut, if @start_time is `NULL`, the result of
/// g_get_current_time() will be used automatically.
///
/// To update the image (i.e. possibly change the result of
/// gdk_pixbuf_animation_iter_get_pixbuf() to a new frame of the animation),
/// call gdk_pixbuf_animation_iter_advance().
///
/// If you're using #GdkPixbufLoader, in addition to updating the image
/// after the delay time, you should also update it whenever you
/// receive the area_updated signal and
/// gdk_pixbuf_animation_iter_on_currently_loading_frame() returns
/// `TRUE`. In this case, the frame currently being fed into the loader
/// has received new data, so needs to be refreshed. The delay time for
/// a frame may also be modified after an area_updated signal, for
/// example if the delay time for a frame is encoded in the data after
/// the frame itself. So your timeout should be reinstalled after any
/// area_updated signal.
///
/// A delay time of -1 is possible, indicating "infinite".
/// ## `start_time`
/// time when the animation starts playing
///
/// # Returns
///
/// an iterator to move over the animation
#[doc(alias = "gdk_pixbuf_animation_get_iter")]
#[doc(alias = "get_iter")]
fn iter(&self, start_time: Option<SystemTime>) -> PixbufAnimationIter;
}
impl<T: IsA<PixbufAnimation>> PixbufAnimationExtManual for T {
fn iter(&self, start_time: Option<SystemTime>) -> PixbufAnimationIter {
let start_time = start_time.map(|s| {
let diff = s
.duration_since(SystemTime::UNIX_EPOCH)
.expect("failed to convert time");
glib::ffi::GTimeVal {
tv_sec: diff.as_secs() as _,
tv_usec: diff.subsec_micros() as _,
}
});
unsafe {
from_glib_full(ffi::gdk_pixbuf_animation_get_iter(
self.as_ref().to_glib_none().0,
start_time
.as_ref()
.map(|t| t as *const glib::ffi::GTimeVal)
.unwrap_or(ptr::null()),
))
}
}
}