Move signal creation functions into the types module

The same code will also work for interfaces.

Author: sdroege

src/subclass/object.rs

@@ -12,7 +12,7 @@ use std::mem;
 use std::ptr;
 
 use translate::*;
-use {Closure, Object, ObjectClass, Type, Value};
+use {Object, ObjectClass, Type, Value};
 
 use super::prelude::*;
 use super::types;
@@ -177,19 +177,12 @@ pub unsafe trait ObjectClassSubclassExt: Sized + 'static {
     /// This can be emitted later by `glib::Object::emit` and external code
     /// can connect to the signal to get notified about emissions.
     fn add_signal(&mut self, name: &str, arg_types: &[Type], ret_type: Type) {
-        let arg_types = arg_types.iter().map(|t| t.to_glib()).collect::<Vec<_>>();
         unsafe {
-            gobject_ffi::g_signal_newv(
-                name.to_glib_none().0,
+            super::types::add_signal(
                 *(self as *mut _ as *mut ffi::GType),
-                gobject_ffi::G_SIGNAL_RUN_LAST,
-                ptr::null_mut(),
-                None,
-                ptr::null_mut(),
-                None,
-                ret_type.to_glib(),
-                arg_types.len() as u32,
-                arg_types.as_ptr() as *mut _,
+                name,
+                arg_types,
+                ret_type,
             );
         }
     }
@@ -212,38 +205,13 @@ pub unsafe trait ObjectClassSubclassExt: Sized + 'static {
     ) where
         F: Fn(&mut Value, &Value) -> bool + Send + Sync + 'static,
     {
-        let arg_types = arg_types.iter().map(|t| t.to_glib()).collect::<Vec<_>>();
-
-        let accumulator: Box<Box<Fn(&mut Value, &Value) -> bool + Send + Sync + 'static>> =
-            Box::new(Box::new(accumulator));
-
-        unsafe extern "C" fn accumulator_trampoline(
-            _ihint: *mut gobject_ffi::GSignalInvocationHint,
-            return_accu: *mut gobject_ffi::GValue,
-            handler_return: *const gobject_ffi::GValue,
-            data: ffi::gpointer,
-        ) -> ffi::gboolean {
-            let accumulator: &&(Fn(&mut Value, &Value) -> bool + Send + Sync + 'static) =
-                &*(data as *const &(Fn(&mut Value, &Value) -> bool + Send + Sync + 'static));
-            accumulator(
-                &mut *(return_accu as *mut Value),
-                &*(handler_return as *const Value),
-            )
-            .to_glib()
-        }
-
         unsafe {
-            gobject_ffi::g_signal_newv(
-                name.to_glib_none().0,
+            super::types::add_signal_with_accumulator(
                 *(self as *mut _ as *mut ffi::GType),
-                gobject_ffi::G_SIGNAL_RUN_LAST,
-                ptr::null_mut(),
-                Some(accumulator_trampoline),
-                Box::into_raw(accumulator) as ffi::gpointer,
-                None,
-                ret_type.to_glib(),
-                arg_types.len() as u32,
-                arg_types.as_ptr() as *mut _,
+                name,
+                arg_types,
+                ret_type,
+                accumulator,
             );
         }
     }
@@ -258,20 +226,13 @@ pub unsafe trait ObjectClassSubclassExt: Sized + 'static {
     where
         F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
     {
-        let arg_types = arg_types.iter().map(|t| t.to_glib()).collect::<Vec<_>>();
-        let handler = Closure::new(handler);
         unsafe {
-            gobject_ffi::g_signal_newv(
-                name.to_glib_none().0,
+            super::types::add_action_signal(
                 *(self as *mut _ as *mut ffi::GType),
-                gobject_ffi::G_SIGNAL_RUN_LAST | gobject_ffi::G_SIGNAL_ACTION,
-                handler.to_glib_none().0,
-                None,
-                ptr::null_mut(),
-                None,
-                ret_type.to_glib(),
-                arg_types.len() as u32,
-                arg_types.as_ptr() as *mut _,
+                name,
+                arg_types,
+                ret_type,
+                handler,
             );
         }
     }

src/subclass/types.rs

@@ -11,9 +11,9 @@ use std::marker;
 use std::mem;
 use std::ptr;
 
+use object::{ObjectExt, ObjectType};
 use translate::*;
-use {IsA, IsClassFor, StaticType, Type};
-use object::{ObjectType, ObjectExt};
+use {Closure, IsA, IsClassFor, StaticType, Type, Value};
 
 use super::object::ObjectImpl;
 
@@ -484,3 +484,88 @@ where
         type_
     }
 }
+
+pub(crate) unsafe fn add_signal(type_: ffi::GType, name: &str, arg_types: &[Type], ret_type: Type) {
+    let arg_types = arg_types.iter().map(|t| t.to_glib()).collect::<Vec<_>>();
+
+    gobject_ffi::g_signal_newv(
+        name.to_glib_none().0,
+        type_,
+        gobject_ffi::G_SIGNAL_RUN_LAST,
+        ptr::null_mut(),
+        None,
+        ptr::null_mut(),
+        None,
+        ret_type.to_glib(),
+        arg_types.len() as u32,
+        arg_types.as_ptr() as *mut _,
+    );
+}
+
+pub(crate) unsafe fn add_signal_with_accumulator<F>(
+    type_: ffi::GType,
+    name: &str,
+    arg_types: &[Type],
+    ret_type: Type,
+    accumulator: F,
+) where
+    F: Fn(&mut Value, &Value) -> bool + Send + Sync + 'static,
+{
+    let arg_types = arg_types.iter().map(|t| t.to_glib()).collect::<Vec<_>>();
+
+    let accumulator: Box<Box<Fn(&mut Value, &Value) -> bool + Send + Sync + 'static>> =
+        Box::new(Box::new(accumulator));
+
+    unsafe extern "C" fn accumulator_trampoline(
+        _ihint: *mut gobject_ffi::GSignalInvocationHint,
+        return_accu: *mut gobject_ffi::GValue,
+        handler_return: *const gobject_ffi::GValue,
+        data: ffi::gpointer,
+    ) -> ffi::gboolean {
+        let accumulator: &&(Fn(&mut Value, &Value) -> bool + Send + Sync + 'static) =
+            &*(data as *const &(Fn(&mut Value, &Value) -> bool + Send + Sync + 'static));
+        accumulator(
+            &mut *(return_accu as *mut Value),
+            &*(handler_return as *const Value),
+        )
+        .to_glib()
+    }
+
+    gobject_ffi::g_signal_newv(
+        name.to_glib_none().0,
+        type_,
+        gobject_ffi::G_SIGNAL_RUN_LAST,
+        ptr::null_mut(),
+        Some(accumulator_trampoline),
+        Box::into_raw(accumulator) as ffi::gpointer,
+        None,
+        ret_type.to_glib(),
+        arg_types.len() as u32,
+        arg_types.as_ptr() as *mut _,
+    );
+}
+pub(crate) unsafe fn add_action_signal<F>(
+    type_: ffi::GType,
+    name: &str,
+    arg_types: &[Type],
+    ret_type: Type,
+    handler: F,
+) where
+    F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
+{
+    let arg_types = arg_types.iter().map(|t| t.to_glib()).collect::<Vec<_>>();
+    let handler = Closure::new(handler);
+
+    gobject_ffi::g_signal_newv(
+        name.to_glib_none().0,
+        type_,
+        gobject_ffi::G_SIGNAL_RUN_LAST | gobject_ffi::G_SIGNAL_ACTION,
+        handler.to_glib_none().0,
+        None,
+        ptr::null_mut(),
+        None,
+        ret_type.to_glib(),
+        arg_types.len() as u32,
+        arg_types.as_ptr() as *mut _,
+    );
+}