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
78

// Take a look at the license at the top of the repository in the LICENSE file.

use crate::PixbufAnimation;
use crate::PixbufAnimationIter;
use glib::object::IsA;
use glib::translate::*;

use std::ptr;
use std::time::SystemTime;

pub trait PixbufAnimationExtManual {
    /// Get an iterator for displaying an animation. The iterator provides
    /// the frames that should be displayed at a given time. It should be
    /// freed after use with `g_object_unref()`.
    ///
    /// `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
    /// [`PixbufAnimationIterExtManual::pixbuf()`][crate::prelude::PixbufAnimationIterExtManual::pixbuf()]. Then, you should install
    /// a timeout (with `g_timeout_add()`) or by some other mechanism ensure
    /// that you'll update the image after
    /// [`PixbufAnimationIterExtManual::delay_time()`][crate::prelude::PixbufAnimationIterExtManual::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 [`None`], the result of
    /// `g_get_current_time()` will be used automatically.
    ///
    /// To update the image (i.e. possibly change the result of
    /// [`PixbufAnimationIterExtManual::pixbuf()`][crate::prelude::PixbufAnimationIterExtManual::pixbuf()] to a new frame of the animation),
    /// call [`PixbufAnimationIterExtManual::advance()`][crate::prelude::PixbufAnimationIterExtManual::advance()].
    ///
    /// If you're using [`PixbufLoader`][crate::PixbufLoader], in addition to updating the image
    /// after the delay time, you should also update it whenever you
    /// receive the area_updated signal and
    /// [`PixbufAnimationIterExtManual::on_currently_loading_frame()`][crate::prelude::PixbufAnimationIterExtManual::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()),
            ))
        }
    }
}