Add support for passing the SignalInvocationHint to signal accumulators

Author: sdroege

src/subclass/interface.rs

@@ -196,7 +196,7 @@ pub trait ObjectInterfaceExt: ObjectInterface {
         ret_type: Type,
         accumulator: F,
     ) where
-        F: Fn(&mut Value, &Value) -> bool + Send + Sync + 'static,
+        F: Fn(&super::SignalInvocationHint, &mut Value, &Value) -> bool + Send + Sync + 'static,
     {
         unsafe {
             super::types::add_signal_with_accumulator(
@@ -231,7 +231,7 @@ pub trait ObjectInterfaceExt: ObjectInterface {
         accumulator: G,
     ) where
         F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
-        G: Fn(&mut Value, &Value) -> bool + Send + Sync + 'static,
+        G: Fn(&super::SignalInvocationHint, &mut Value, &Value) -> bool + Send + Sync + 'static,
     {
         unsafe {
             super::types::add_signal_with_class_handler_and_accumulator(

src/subclass/mod.rs

@@ -195,4 +195,4 @@ pub mod prelude {
 pub use self::boxed::register_boxed_type;
 pub use self::interface::register_interface;
 pub use self::object::Property;
-pub use self::types::{register_type, InitializingType, TypeData};
+pub use self::types::{register_type, InitializingType, SignalInvocationHint, TypeData};

src/subclass/object.rs

@@ -233,7 +233,7 @@ pub unsafe trait ObjectClassSubclassExt: Sized + 'static {
         ret_type: Type,
         accumulator: F,
     ) where
-        F: Fn(&mut Value, &Value) -> bool + Send + Sync + 'static,
+        F: Fn(&super::SignalInvocationHint, &mut Value, &Value) -> bool + Send + Sync + 'static,
     {
         unsafe {
             super::types::add_signal_with_accumulator(
@@ -268,7 +268,7 @@ pub unsafe trait ObjectClassSubclassExt: Sized + 'static {
         accumulator: G,
     ) where
         F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
-        G: Fn(&mut Value, &Value) -> bool + Send + Sync + 'static,
+        G: Fn(&super::SignalInvocationHint, &mut Value, &Value) -> bool + Send + Sync + 'static,
     {
         unsafe {
             super::types::add_signal_with_class_handler_and_accumulator(

src/subclass/types.rs

@@ -522,6 +522,19 @@ pub(crate) unsafe fn add_signal(
     );
 }
 
+#[repr(C)]
+pub struct SignalInvocationHint(gobject_ffi::GSignalInvocationHint);
+
+impl SignalInvocationHint {
+    pub fn detail(&self) -> ::Quark {
+        from_glib(self.0.detail)
+    }
+
+    pub fn run_type(&self) -> SignalFlags {
+        from_glib(self.0.run_type)
+    }
+}
+
 pub(crate) unsafe fn add_signal_with_accumulator<F>(
     type_: ffi::GType,
     name: &str,
@@ -530,22 +543,23 @@ pub(crate) unsafe fn add_signal_with_accumulator<F>(
     ret_type: Type,
     accumulator: F,
 ) where
-    F: Fn(&mut Value, &Value) -> bool + Send + Sync + 'static,
+    F: Fn(&SignalInvocationHint, &mut Value, &Value) -> bool + Send + Sync + 'static,
 {
     let arg_types = arg_types.iter().map(|t| t.to_glib()).collect::<Vec<_>>();
 
     let accumulator: Box<F> = Box::new(accumulator);
 
     unsafe extern "C" fn accumulator_trampoline<
-        F: Fn(&mut Value, &Value) -> bool + Send + Sync + 'static,
+        F: Fn(&SignalInvocationHint, &mut Value, &Value) -> bool + Send + Sync + 'static,
     >(
-        _ihint: *mut gobject_ffi::GSignalInvocationHint,
+        ihint: *mut gobject_ffi::GSignalInvocationHint,
         return_accu: *mut gobject_ffi::GValue,
         handler_return: *const gobject_ffi::GValue,
         data: ffi::gpointer,
     ) -> ffi::gboolean {
         let accumulator: &F = &*(data as *const &F);
         accumulator(
+            &SignalInvocationHint(*ihint),
             &mut *(return_accu as *mut Value),
             &*(handler_return as *const Value),
         )
@@ -603,23 +617,24 @@ pub(crate) unsafe fn add_signal_with_class_handler_and_accumulator<F, G>(
     accumulator: G,
 ) where
     F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
-    G: Fn(&mut Value, &Value) -> bool + Send + Sync + 'static,
+    G: Fn(&SignalInvocationHint, &mut Value, &Value) -> bool + Send + Sync + 'static,
 {
     let arg_types = arg_types.iter().map(|t| t.to_glib()).collect::<Vec<_>>();
 
     let class_handler = Closure::new(class_handler);
     let accumulator: Box<G> = Box::new(accumulator);
 
     unsafe extern "C" fn accumulator_trampoline<
-        G: Fn(&mut Value, &Value) -> bool + Send + Sync + 'static,
+        G: Fn(&SignalInvocationHint, &mut Value, &Value) -> bool + Send + Sync + 'static,
     >(
-        _ihint: *mut gobject_ffi::GSignalInvocationHint,
+        ihint: *mut gobject_ffi::GSignalInvocationHint,
         return_accu: *mut gobject_ffi::GValue,
         handler_return: *const gobject_ffi::GValue,
         data: ffi::gpointer,
     ) -> ffi::gboolean {
         let accumulator: &G = &*(data as *const &G);
         accumulator(
+            &SignalInvocationHint(*ihint),
             &mut *(return_accu as *mut Value),
             &*(handler_return as *const Value),
         )