Merge pull request #933 from sdroege/pixbuf-iter-duration

gdk-pixbuf: Fix time related types

Author: sdroege

gdk-pixbuf/src/pixbuf_animation_iter.rs

@@ -1,6 +1,6 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use std::time::SystemTime;
+use std::time::{Duration, SystemTime};
 
 use glib::translate::*;
 
@@ -17,8 +17,8 @@ glib::wrapper! {
 
 impl PixbufAnimationIter {
     #[doc(alias = "gdk_pixbuf_animation_iter_advance")]
-    pub fn advance(&self, start_time: SystemTime) -> bool {
-        let diff = start_time
+    pub fn advance(&self, current_time: SystemTime) -> bool {
+        let diff = current_time
             .duration_since(SystemTime::UNIX_EPOCH)
             .expect("failed to convert time");
 
@@ -45,8 +45,16 @@ impl PixbufAnimationIter {
 
     #[doc(alias = "gdk_pixbuf_animation_iter_get_delay_time")]
     #[doc(alias = "get_delay_time")]
-    pub fn delay_time(&self) -> i32 {
-        unsafe { ffi::gdk_pixbuf_animation_iter_get_delay_time(self.to_glib_none().0) }
+    pub fn delay_time(&self) -> Option<Duration> {
+        unsafe {
+            let res = ffi::gdk_pixbuf_animation_iter_get_delay_time(self.to_glib_none().0);
+
+            if res < 0 {
+                None
+            } else {
+                Some(Duration::from_millis(res as u64))
+            }
+        }
     }
 
     #[doc(alias = "gdk_pixbuf_animation_iter_on_currently_loading_frame")]

gdk-pixbuf/src/subclass/pixbuf_animation.rs

@@ -3,7 +3,10 @@
 // rustdoc-stripper-ignore-next
 //! Traits intended for subclassing [`PixbufAnimation`](crate::PixbufAnimation).
 
-use std::{mem::MaybeUninit, time::Duration};
+use std::{
+    mem::MaybeUninit,
+    time::{Duration, SystemTime},
+};
 
 use glib::{prelude::*, subclass::prelude::*, translate::*};
 use once_cell::sync::Lazy;
@@ -23,7 +26,7 @@ pub trait PixbufAnimationImpl: ObjectImpl {
         self.parent_size()
     }
 
-    fn iter(&self, start_time: Duration) -> PixbufAnimationIter {
+    fn iter(&self, start_time: SystemTime) -> PixbufAnimationIter {
         self.parent_iter(start_time)
     }
 }
@@ -32,7 +35,7 @@ pub trait PixbufAnimationImplExt: ObjectSubclass {
     fn parent_is_static_image(&self) -> bool;
     fn parent_static_image(&self) -> Option<Pixbuf>;
     fn parent_size(&self) -> (i32, i32);
-    fn parent_iter(&self, start_time: Duration) -> PixbufAnimationIter;
+    fn parent_iter(&self, start_time: SystemTime) -> PixbufAnimationIter;
 }
 
 impl<T: PixbufAnimationImpl> PixbufAnimationImplExt for T {
@@ -89,24 +92,27 @@ impl<T: PixbufAnimationImpl> PixbufAnimationImplExt for T {
         }
     }
 
-    fn parent_iter(&self, start_time: Duration) -> PixbufAnimationIter {
+    fn parent_iter(&self, start_time: SystemTime) -> PixbufAnimationIter {
         unsafe {
             let data = T::type_data();
             let parent_class = data.as_ref().parent_class() as *mut ffi::GdkPixbufAnimationClass;
             let f = (*parent_class)
                 .get_iter
                 .expect("No parent class implementation for \"get_iter\"");
 
+            let diff = start_time
+                .duration_since(SystemTime::UNIX_EPOCH)
+                .expect("failed to convert time");
             let time = glib::ffi::GTimeVal {
-                tv_sec: start_time.as_secs() as _,
-                tv_usec: start_time.subsec_micros() as _,
+                tv_sec: diff.as_secs() as _,
+                tv_usec: diff.subsec_micros() as _,
             };
             from_glib_full(f(
                 self.obj()
                     .unsafe_cast_ref::<PixbufAnimation>()
                     .to_glib_none()
                     .0,
-                &time as *const _,
+                &time,
             ))
         }
     }
@@ -189,8 +195,9 @@ unsafe extern "C" fn animation_get_iter<T: PixbufAnimationImpl>(
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
-    let total = Duration::from_secs((*start_time_ptr).tv_sec.try_into().unwrap())
+    let start_time = SystemTime::UNIX_EPOCH
+        + Duration::from_secs((*start_time_ptr).tv_sec.try_into().unwrap())
         + Duration::from_micros((*start_time_ptr).tv_usec.try_into().unwrap());
 
-    imp.iter(total).into_glib_ptr()
+    imp.iter(start_time).into_glib_ptr()
 }

gdk-pixbuf/src/subclass/pixbuf_animation_iter.rs

@@ -3,7 +3,7 @@
 // rustdoc-stripper-ignore-next
 //! Traits intended for subclassing [`PixbufAnimationIter`](crate::PixbufAnimationIter).
 
-use std::time::Duration;
+use std::time::{Duration, SystemTime};
 
 use glib::{prelude::*, subclass::prelude::*, translate::*};
 use once_cell::sync::Lazy;
@@ -25,16 +25,16 @@ pub trait PixbufAnimationIterImpl: ObjectImpl {
         self.parent_on_currently_loading_frame()
     }
 
-    fn advance(&self, time: Duration) -> bool {
-        self.parent_advance(time)
+    fn advance(&self, current_time: SystemTime) -> bool {
+        self.parent_advance(current_time)
     }
 }
 
 pub trait PixbufAnimationIterImplExt: ObjectSubclass {
     fn parent_delay_time(&self) -> Option<Duration>;
     fn parent_pixbuf(&self) -> Pixbuf;
     fn parent_on_currently_loading_frame(&self) -> bool;
-    fn parent_advance(&self, time: Duration) -> bool;
+    fn parent_advance(&self, current_time: SystemTime) -> bool;
 }
 
 impl<T: PixbufAnimationIterImpl> PixbufAnimationIterImplExt for T {
@@ -52,10 +52,10 @@ impl<T: PixbufAnimationIterImpl> PixbufAnimationIterImplExt for T {
                 .unsafe_cast_ref::<PixbufAnimationIter>()
                 .to_glib_none()
                 .0);
-            if time == -1 {
+            if time < 0 {
                 None
             } else {
-                Some(Duration::from_millis(time.try_into().unwrap()))
+                Some(Duration::from_millis(time as u64))
             }
         }
     }
@@ -94,7 +94,7 @@ impl<T: PixbufAnimationIterImpl> PixbufAnimationIterImplExt for T {
         }
     }
 
-    fn parent_advance(&self, time: Duration) -> bool {
+    fn parent_advance(&self, current_time: SystemTime) -> bool {
         unsafe {
             let data = T::type_data();
             let parent_class =
@@ -103,16 +103,19 @@ impl<T: PixbufAnimationIterImpl> PixbufAnimationIterImplExt for T {
                 .advance
                 .expect("No parent class implementation for \"advance\"");
 
+            let diff = current_time
+                .duration_since(SystemTime::UNIX_EPOCH)
+                .expect("failed to convert time");
             let time = glib::ffi::GTimeVal {
-                tv_sec: time.as_secs() as _,
-                tv_usec: time.subsec_micros() as _,
+                tv_sec: diff.as_secs() as _,
+                tv_usec: diff.subsec_micros() as _,
             };
             from_glib(f(
                 self.obj()
                     .unsafe_cast_ref::<PixbufAnimationIter>()
                     .to_glib_none()
                     .0,
-                &time as *const _,
+                &time,
             ))
         }
     }
@@ -165,13 +168,14 @@ unsafe extern "C" fn animation_iter_on_currently_loading_frame<T: PixbufAnimatio
 
 unsafe extern "C" fn animation_iter_advance<T: PixbufAnimationIterImpl>(
     ptr: *mut ffi::GdkPixbufAnimationIter,
-    time_ptr: *const glib::ffi::GTimeVal,
+    current_time_ptr: *const glib::ffi::GTimeVal,
 ) -> glib::ffi::gboolean {
     let instance = &*(ptr as *mut T::Instance);
     let imp = instance.imp();
 
-    let total = Duration::from_secs((*time_ptr).tv_sec.try_into().unwrap())
-        + Duration::from_micros((*time_ptr).tv_usec.try_into().unwrap());
+    let current_time = SystemTime::UNIX_EPOCH
+        + Duration::from_secs((*current_time_ptr).tv_sec.try_into().unwrap())
+        + Duration::from_micros((*current_time_ptr).tv_usec.try_into().unwrap());
 
-    imp.advance(total).into_glib()
+    imp.advance(current_time).into_glib()
 }